“Thanks to the precise specifications, the subsequent implementation was surprisingly fast.”
Customers validate it, analysts write it, engineers generate from it, testers verify it. Requirements, AI generation, business review, repeat.
Use cases describe the system in your language, not in code. You read and validate them in AI Unified Studio, straight from the project, and every iteration ends with a business review. Acceptance tests follow the same use cases you approved.
You own: vision, business processes, acceptance
You write vision, requirements, entity model, and use cases in a format that stakeholders, engineers, and AI agents read alike. AI drafts, you own. Code, tests, and documentation are generated from your specifications and regenerated when they change.
You own: requirements, entity model, use cases
Architecture decisions live in a stack plugin, not in tribal knowledge. Open-source agent plugins generate the application from the use cases in Claude Code, Codex, Cursor, or Copilot; you review the pull request, refine the specification, and regenerate. Works for new projects and for modernizing existing systems.
You own: architecture, stack plugin, generated code
Test cases are end-to-end journeys through the specified use cases, written with their test data before the implementation. One command turns a test case into a Playwright test, a coverage check finds use cases without tests, and the AI Unified Process Navigator, the plugin for IntelliJ and VS Code, traces every test back to its use case.
You own: test cases, coverage, traceability
Code-centric development leads to maintenance problems, hinders modernization, and causes business misalignment.
Traditional development is code-centric. Requirements get outdated, documentation drifts, and when bugs appear, we dig through code to understand what the system was supposed to do.
AI coding tools make this worse by generating code faster without fixing the underlying process problems. Even spec-driven tools mostly use the spec to describe the code a developer is about to write; the code stays the real artifact, and the spec is just a means to produce it.
AI Unified Process flips this around. Requirements stay at the center, and everything else gets generated from them using AI as the consistency engine.
Iterative Improvement: Through short iterations, specifications, code, and tests improve together. Documentation enables sustainable development and modernization.
Test-Driven Consistency: Tests ensure the system behaves the same regardless of code generation changes, enabling safe refactoring and evolution.
In most spec-driven tools, developers write specs to describe the code. AI Unified Process specs describe the behavior of the system, so customers can validate them, analysts can own them, engineers can build from them, and testers can verify them. The code is just the current implementation.
Developer-centric by design. Specs are written by developers to describe the code: an elaborate prompt for one feature's implementation, and effectively discarded once the code ships.
The spec serves the code: the code remains the source of truth, the spec decays the moment it ships, and requirements knowledge never leaves the development team.
Requirements-centric from the start. Use cases specify the behavior of the system: what it must do, not how the code does it. They are first-class, living artifacts: written by business analysts and requirements engineers, validated by customers and end users, implemented by engineers, and verified by test engineers.
The code serves the spec: behavior is the source of truth; code, tests, and documentation are generated and regenerated around it. Use cases outlive any implementation.
Spec-anchored, not spec-first: the specification stays in the repository for the life of the system. See where that sits among the three levels of spec-driven development.
Developers win too: “For the first time in agentic engineering, it felt like control was given back to me, the developer.” Marc Affolter, all voices from the field.
The name is deliberate. The Unified Process of the late 1990s got the fundamentals right: use cases as first-class artifacts, four phases, short iterations, architecture first. What it never had was a way to keep specifications, code, and tests in sync once the project got moving. That is exactly what AI is good at.
Two ways to learn the method in depth. Workshops are under Get started.
From Specs to Code with AI Agents. Simon Martinelli's practical guide to making specifications the single source of truth for code, tests, and validation, built on the AI Unified Process.
How to write use cases for stakeholders, engineers, and AI agents: the specification format at the heart of the AI Unified Process, in eleven short chapters with a template, a worked example, and checklists.
For us at WBS GRUPPE, the AI Unified Process is the ideal method for analyzing and evolving existing products in a structured way. With requirements and use cases consistently at the center, we stay in full control even in an established codebase. Particularly remarkable: thanks to the precise specifications, the subsequent implementation was surprisingly fast. A highly efficient framework for agile software development in the AI era.
Using AIUP, we delivered our internal B2B sales app in a fraction of the time I expected, including its interfaces to the aging in-house system that manages our product licenses. We had our old, manually maintained Word offers and sales statements analyzed and specified in markdown, and it was astounding to see the generated PDFs come out perfect, with every calculation done automatically. The specifications carried the whole thing. Now we can move functionality out of that hard-to-maintain legacy system, step by step.
I used AIUP for both a green-field and an existing brown-field project. Both worked, and both approaches were as efficient as they were fun to use. Moreover, for the first time in agentic engineering, it felt like control was given back to me, the developer: a feeling I had missed since leaving the AI-prompting phase and venturing into 'vibe-coding'. Because the aiup-vaadin-jooq tech stack was not feasible for my existing brown-field project, I contribute to AIUP by providing the aiup-angular-jpa plugin.
Building software with AIUP and Claude Code is genuinely fun. Two Rust projects came out of it: AudioSnip, a cross-platform desktop app built with Tauri 2 to extract audio from video files, and Konzertmeister CLI, a tool for the Konzertmeister API. Thanks to Claude Code, both were packaged as a Homebrew Tap, so I can install them directly with brew install on my Mac. Writing specs, implementing, and testing together with Claude Code: cool stuff. And afterwards you actually understand what the code does.
With AIUP and spec-driven development, I shipped a complete product, deckweaver, in three calendar days, with maybe four to five hours of actual work. From a two-sentence README, Claude Code generated requirements and use cases that matched exactly what I had in mind. It then handled the tedious parts (OAuth, the Google Slides API, the Thymeleaf frontend) without a hitch. Genuinely impressed.
Pick a thread: the Studio, the methodology, the enterprise story, the videos, the tools, or the articles.
The web workspace for every stakeholder: structured editors for requirements, use cases, and tests, straight from your Git repository. Private beta, by invitation.
Four agile phases, two workflows (Greenfield and Brownfield), six core principles, and the iterative approach that replaces the determinism fallacy.
Governance and traceability, brownfield modernization, parallel team scaling, risk-managed AI evolution, and knowledge that outlives teams.
Conference talks, walkthroughs, and methodology overviews showing the AI Unified Process and spec-driven development in practice.
Open-source plugins for Claude Code, Codex, Cursor, and Copilot, plus the AI Unified Process Navigator for IntelliJ and VS Code, which links use case specs to their tests.
Curated writing on spec-driven development, requirements engineering, AI-ready architectures, and the AI Unified Process methodology.
The questions we hear most from customers, analysts, engineers, and testers.
No. The process starts with a vision, business processes, requirements, and use cases written in plain language. Customers and end users validate them, business analysts and requirements engineers own them, and engineers generate and test the application from them. AI Unified Studio gives non-technical stakeholders a view of the project without a repository checkout.
The project overview in AI Unified Studio →No. The plugins are skill files that follow the open Agent Skills and Agent Plugins standards. They run in Claude Code, OpenAI Codex CLI, Cursor, GitHub Copilot, Gemini CLI, and OpenCode, and can be installed with Tessl for any of them. The tutorial uses Claude Code as its example; the commands and the generated files are the same in every tool.
Use the plugins with other AI coding tools →Use cases that describe what the system does, in their language, with generated diagrams and their current status. Every iteration ends with a business review of exactly those use cases, and acceptance tests follow them one by one. What was approved is what gets built, and what gets built is what gets tested.
The four phases and the business review →Four stack plugins are ready to use: Vaadin with jOOQ, Angular with JPA, Blazor with .NET, and NestJS with Next.js. The core plugin is stack-independent, so any other stack works too: a stack plugin encodes your frameworks and architecture decisions, and your team can write one along the stack guide, or have it built together with the harness around it.
All plugins on the tools page → Create your own stack →Yes. The Brownfield workflow reverse-engineers use cases, entity model, and test cases from the existing code first, so the specification catches up with reality. From then on, changes, new features, and bug fixes flow through the use cases, and functionality can move out of the legacy system step by step.
Greenfield vs. Brownfield →The agent plugins and the AI Unified Process Navigator are open source and free. AI Unified Studio is in private beta: access is by invitation, the free trial starts with the invitation, and pricing is announced at general availability. The book is sold by Apress; the guide is free.
Request a Studio invitation →In your own environment. All artifacts live in your Git repository. The plugins run in your coding agent's session; the Studio triggers generation in the CI of your own repository, and the result arrives as a pull request. Your AI access token is stored only as a secret at your Git provider, never in the Studio.
How generation runs in your CI →The good parts of it, yes. The AI Unified Process keeps the four phases, use cases, and short iterations of the Unified Process, and drops the artifact catalog, the role descriptions, and the ceremony. What makes it work today is that AI keeps specification, code, and tests consistent, which is the part the original process could only ask people to do by hand.
Where the name comes from →Pick the one that fits your team. Everything begins with the same artifacts: vision, requirements, entity model, use cases, test cases. The question is only how much help you want on the way.
Install the plugins, follow the tutorial, and build your first application from a use case today. Everything stays in your Git repository.
Spec-Driven Development with the AI Unified Process
Bring your analysts, engineers, and testers into one workshop. You leave with a use case catalog for your own product and a generated first iteration.
CHF 4'400 per in-house day, up to 10 people · online session from $290
See the workshop Everything about the workshop →For teams where customers and analysts should work on the specifications too. AI Unified Studio gives every stakeholder a view of the project without a repository checkout, and generation runs in your own CI.
Not sure which one? Book a 30-minute call and we figure it out together.
Updates on the AI Unified Process: methodology, tools, and workshop dates. No spam.
