JoinedWorkz – Executable Project Knowledge for AI

Using ChatGPT and Codex, a new JoinedWorkz Cartridge was developed and then used in a demo to show how explicit, executable project knowledge enables more effective AI-assisted software engineering.

Comment

JoinedWorkz – Executable Project Knowledge

Inspiration

Software projects does not become difficult because we cannot write code.

They become difficult because valuable project knowledge gradually disappears into documentation, tickets, conversations and people's heads.

As a result, every new developer—and every new AI session—must reconstruct architecture, conventions and business semantics before productive work can begin.

I started JoinedWorkz because I believe software projects should preserve this knowledge in an explicit, executable form that can be reused consistently by humans, generators and now also by AI. The starting point originally was MDSD and DSL. Creating 'joinedworkz-ai-context' was the next step to provide knowledge specially for AI.

At this time I the fear that AI could make my approach absolete, but soon I discovered that AI finally has the same challanges then human developers and architects.

Why this matters

Modern AI is excellent at implementation, reasoning and software design.

Its biggest challenge is understanding a project and all details. Maybe working on a more abstract level could also be a benefit for AI.

Architecture, naming conventions, framework decisions and business semantics are repeatedly explained instead of being reused.

JoinedWorkz addresses this by treating project knowledge as a first-class engineering artifact (basically models, cartridges and 'joinedworkz-ai-context').

Model-Driven Software Development preserves project knowledge, while AI applies it during engineering. Rather than competing, the two approaches complement each other.

What I built during OpenAI Build Week

Instead of creating a standalone demo, I extended the existing JoinedWorkz platform with an Angular + TypeScript frontend cartridge, a public demonstration project and updated and extended the 'joinedworkz-ai-context' to a reusable knowledge packages.

During implementation it turns out, that we easily can prove the effect. Therefore we created also: an AI validation experiment.

For all our work we created a complete engineering documentation and evidence.

The JoinedWorkz platform itself as well as the existing Spring Boot and Vue/Quasar generators remained unchanged.

We demonstrated basically 3 different things

  1. It was possible to extract the architecture complex functionality of JoinedWorkz by steering of ChatGPT, execution by Codex and review by me. The result was a sufficient foundation for the next step.

  2. ChatGPT and Codex could develop an Angualar cartridge which is deeply integrated in the JoinedWorkz platform. Even if this cartridge coveres just a subset of the features of the Quasar cartridge (which is use in production) the implemented features works perfectly.

  3. Codex was able implemented a small feature in an existing demo application and in a correct way by utilizing the provided executable knowledge base. It just changed the model and did not touch generated code. It also invoked the generator and verified that the feature was correctly implemented be itself. After a human review nothing needs to be changed. - And finally a log of files has been changed (Spring-Boot Controller, Entities, Repositories, DTOs, OpenAPI Specifications and the Angular frontend code). Further details about this verification are described in the next chapter.

Executable Knowledge Base Verification Details

To evaluate the approach, I intentionally started a new Codex session with only:

  • framework knowledge
  • project knowledge
  • the project sources
  • a compact task prompt

Therefore I started a new session by adding an new folder and started the new chat in that new folder. I could observe a different session id the session before.

The task was to extend the demo application with a new Plugin domain concept.

The complete experiment—including prompts, execution logs, reports and human review—is included in this repository.

How I used ChatGPT and Codex

I assigned different responsibilities to myself, GPT-5.6 and Codex.

My responsibilities

  • Architecture
  • Design decisions
  • Reviews
  • Validation
  • Final acceptance

ChatGPT (GPT-5.6)

  • Architectural discussions
  • Design reviews
  • Documentation
  • Communication
  • Prompt engineering

Codex 5.6 Sol (Max and Ultra)

  • Repository analysis
  • Implementation
  • Refactoring
  • Testing
  • Documentation updates

Every implementation batch was reviewed and accepted before becoming part of the project.

Challenges

The biggest challenge was not implementing another frontend generator.

It was deciding which knowledge should become part of the long-term project knowledge base and which should remain task-specific.

The validation experiment helped confirm these architectural decisions.

Outcome

The most important result is that explicit, executable project knowledge reduced the amount of task-specific prompting required for successful AI-assisted software engineering.

I do not see AI as a replacement for Model-Driven Software Development.

Instead, I believe AI becomes significantly more effective when it can build upon executable project knowledge that evolves together with the software project.

Built With

  • ai
  • angular.js
  • chatgpt
  • code-generation
  • codex
  • developer-tools
  • java
  • joinedworkz
  • model-driven-development
  • software-architecture
  • typescript
  • xtext
Share this project:

Updates