SAP Joule promises to simplify application development with AI-driven features like model generation, service creation, and application building. This blog shares a hands-on exploration of its capabilities, highlighting both successes and challenges.

From creating models and services to attempting application generation with SAP Fiori and SAPUI5, the journey reveals Joule's potential and limitations. While it excels at generating models and data, functionality issues in generated applications showcase areas for improvement. Dive in to learn more about Joule's current scope and practical applications in development workflows.

Model

SAP Joule is capable of generating models based on prompts. However, I defined my own model in the `schema.cds` file for simple structures containing multiple units, as shown in the following block of code:

namespace company;
using {cuid} from '@sap/cds/common';
entity Structures : cuid {
    name  : String;
    units : Composition of many Units
                on units.parent = $self;
}
entity Units : cuid {
    name   : String;
    parent : Association to Structures;
}

Service

I then instructed Joule to create a service for the defined model, which it successfully completed:

Data

I then instructed Joule to create a service for the defined model, which it also successfully completed. After creating the service, I needed sample data. Joule generated several rows of data in new CSV files:

SAP Fiori Elements Application

Finally, I needed an application to view the data. Using a simple prompt, I instructed Joule to generate the application based on the previously created `schema.cds` file:

However, this did not work, as an error message appeared stating that Joule was unable to create the application because it did not match a supported floorplan.

I also tried two other approaches:

1. Instructing Joule to generate an application for viewing structures, where each structure contains units.

2. Generating the application using our model as an attached file.

For both options, Joule generated a new `schema.cds` file, which differed from the one I provided. This was not desirable. I attempted to attach the file in different formats: first as `.cds`, which Joule did not support, and then as `.txt`. Although Joule did not complain about the `.txt` format, it still did not work and continued to create a new `schema.cds` file:

namespace myNamespace;
entity Structures {
  key ID: UUID;
  structureID: String(50) @assert.unique @mandatory;
  structureName: String(100);
  location: String(100);
  units: Association to many Units on units.structures = $self;
}
entity Units {
  key ID: UUID;
  unitID: String(50) @assert.unique @mandatory;
  unitName: String(100);
  structureID: String(50);
  unitType: String(50);
  structures: Association to Structures;
}

SAPUI5 Application

Another approach was to create the application using SAPUI5. The command for SAPUI5 is `/ui5`. I defined a prompt to create a SAPUI5 application, but Joule was unable to generate it. Instead, it provided step-by-step instructions for creating the application manually. However, after following these instructions, the application still did not work.

I then attempted to generate the application using the BAS (Business Application Studio) Application Generator, hoping Joule could at least make changes to this application. To test this, I created a prompt for Joule to update the generated application to use a flexible column layout. Joule suggested several changes, but after applying them, the application stopped functioning.

I also tried using Joule to update another application that was already working. However, Joule sometimes replaced existing code, removing functionality necessary for the application to run.

After these issues, I decided to stop further exploration.

Summary

This blog discusses challenges with SAP Joule in generating models, services, and applications. While Joule successfully created a service and sample data from a custom `schema.cds` file, attempts to generate an application failed due to unsupported floorplans. Alternative methods, such as attaching the schema or using SAPUI5, also proved unsuccessful, with Joule either ignoring the provided schema or providing non-functional instructions.

Using the BAS Application Generator to create an application worked initially, but Joule’s updates, such as adding a flexible column layout, caused functionality issues. Attempts to update a working application also led to overwritten critical code. Due to these persistent challenges, further exploration with SAP Joule was discontinued.