Werkzeuge

AI Unified Process Werkzeuge

Drei Werkzeuge, ein Workflow
Open-Source-Agent-Plugins für Anforderungen, Modellierung, Implementierung und Tests, der AI Unified Process Navigator für IntelliJ und Visual Studio Code, der Testmethoden mit ihren Use-Case-Spezifikationen verknüpft, und AI Unified Studio, ein webbasierter Arbeitsplatz, der allen Stakeholdern einen Blick auf Ihr Projekt nach dem AI Unified Process erlaubt. Gemeinsam halten sie Anforderungen im Zentrum Ihres Entwicklungsworkflows.
Erste Version:Dies sind die ersten Versionen der Werkzeuge des AI Unified Process; alles, was auf dieser Seite beschrieben ist, funktioniert heute. Als Nächstes folgt die KI-Automatisierung des Prozesses selbst, damit der Workflow des AI Unified Process mit weniger manueller Arbeit Befehl für Befehl abläuft.
Überblick

Wie die Werkzeuge zusammenspielen #

Die Agent-Plugins decken den Workflow des AI Unified Process von Anfang bis Ende ab, in Claude Code, Codex, Cursor, Copilot und anderen Agenten. Der AI Unified Process Navigator hält die entstehenden Spezifikationen und Tests in Ihrer IDE verbunden. Und AI Unified Studio erlaubt allen Stakeholdern einen Blick auf das Projekt, direkt aus dem Git Repository.

Agent-Plugins #

Open-Source-Plugins, die den AI-Unified-Process-Workflow in Ihrem Coding-Agenten vorantreiben: Anforderungen erfassen, Entitäten modellieren, Use Cases spezifizieren sowie Implementierung und Tests generieren.

Enthält das stack-unabhängige aiup-core Plugin und vier technologiespezifische Plugins: aiup-vaadin-jooq für Vaadin + jOOQ Anwendungen, aiup-angular-jpa für Angular + Spring Boot JPA Anwendungen, aiup-blazor-dotnet für C# + Blazor Anwendungen auf .NET 10 und aiup-nestjs-nextjs für NestJS + Next.js Anwendungen.

IDE-Plugin #

Der AI Unified Process Navigator ist ein eigenständiges IDE-Plugin, verfügbar für IntelliJ und Visual Studio Code, das mit @UseCase annotierte Testmethoden über Gutter-Symbole mit ihren UC-XXX-*.md-Spezifikationen verknüpft, und vom Spec zurück zum Test.

Funktioniert unabhängig vom Coding-Agenten, ergänzt aber die Plugins ideal: Spezifikationen und Tests mit Ihrem Agenten generieren und anschliessend in Ihrer IDE navigieren.

AI Unified Studio #

Ein webbasierter Arbeitsplatz, der allen Stakeholdern einen Blick auf Projekte nach dem AI Unified Process erlaubt: strukturierte Editoren für Anforderungen, Entity Model und Use-Case-Spezifikationen, mit automatisch generierten Diagrammen.

Alle Artefakte liegen in Ihrem Git Repository auf GitHub oder Bitbucket: dieselben Dateien, die auch die Plugins erzeugen und konsumieren, ohne Konvertierung. Zurzeit in privater Beta; der Zugang erfolgt auf Einladung.

Agent-Plugins

Die Plugins im Detail #

Ein stack-unabhängiger Kern für Requirements Engineering, kombiniert mit technologiespezifischen Plugins für die Implementierung mit Vaadin + jOOQ, Angular + JPA, Blazor + .NET und NestJS + Next.js. Anderer Stack? Erstellen Sie Ihr eigenes Stack-Plugin.

aiup-core #

Stack-unabhängiges Methodologie-Plugin mit Vorlagen für spezifikationsgetriebene Entwicklung mit den Anforderungen im Zentrum. Funktioniert mit jedem Technologie-Stack.

/requirements – Anforderungskatalog erstellen
/entity-model – Entitätsmodell mit ER-Diagrammen erstellen
/use-case-diagram – PlantUML Use-Case-Diagramm generieren
/use-case-spec – Use-Case-Spezifikation schreiben
/test-case – End-to-End-Testfall schreiben, der mehrere Use Cases verkettet, oder aus einem BPMN-Geschäftsprozessmodell je Pfad einen ableiten
/reverse-engineer – Bestehendes Projekt in Artefakte des AI Unified Process rückentwickeln
/spec-review – Spezifikationen gegeneinander prüfen: ein deterministischer Lint, der den Build stoppen kann, plus ein beratendes Review auf Widersprüche, Lücken und Mehrdeutigkeiten
  • Context7 – Aktuelle Bibliotheks-Dokumentation

aiup-vaadin-jooq #

Technologiespezifisches Plugin für Java-Webanwendungsentwicklung, das das Vaadin UI-Framework mit jOOQ typsicherem Datenbankzugriff kombiniert.

/flyway-migration – Flyway Datenbankmigration erstellen
/implement – Use Case mit Vaadin + jOOQ implementieren
/implement-hilla – Use Case mit Hilla (React/TypeScript-Views) + jOOQ implementieren
/browserless-test – Vaadin Browserless Unit-Tests erstellen
/hilla-test – Vitest- und Spring-Boot-Tests für Hilla-Views und -Services erstellen
/playwright-test – Playwright-Integrationstests für einen Use Case (UC-*) und End-to-End-Journey-Tests für einen Testfall (TC-*) erstellen
/coverage-check – Use Case oder Testfall gegen seine Spezifikation prüfen und die Abdeckungsmatrix ausgeben
  • Vaadin – UI-Komponenten-Dokumentation und APIs
  • jOOQ – Typsichere SQL-Query-Dokumentation
  • Karibu Testing – Vaadin Unit-Testing-Patterns
  • JavaDocs – Java API-Dokumentationssuche
  • Playwright – Browser-Automatisierung und E2E-Tests

aiup-angular-jpa #

Technologiespezifisches Plugin für eine getrennte Client/Server-Architektur: ein Spring Boot + JPA Backend (flach oder hexagonal mit mehreren Modulen) mit einem Angular-Frontend.

Ein besonderer Dank geht an Marc Affolter für den Beitrag dieses Plugins.

/flyway-migration – Flyway Datenbankmigration erstellen
/implement – Use Case mit Spring Boot + Angular implementieren
/spring-boot-test – Spring Boot API-Tests erstellen
/vitest-test – Vitest Komponententests für Angular erstellen
/playwright-test – Playwright E2E-Tests erstellen
  • JavaDocs – Java API-Dokumentationssuche
  • Playwright – Browser-Automatisierung und E2E-Tests

aiup-blazor-dotnet #

Technologiespezifisches Plugin für C# und Blazor auf .NET 10: EF Core Datenzugriff und Blazor-Komponenten, umgesetzt in einer Vertical Slice Architecture.

Ein besonderer Dank geht an Carl J. Mosca für den Beitrag dieses Plugins.

/ef-migration – EF Core Datenbankmigration erstellen
/implement – Use Case mit C# + Blazor implementieren
/bunit-test – bUnit Komponententests für Blazor erstellen
/dotnet-test – Backend Unit- und Integrationstests erstellen
/playwright-test – Playwright E2E-Tests erstellen
  • Microsoft Learn – .NET und Blazor Dokumentation
  • bUnit Docs – Blazor Komponententest-Patterns
  • Playwright – Browser-Automatisierung und E2E-Tests

aiup-nestjs-nextjs #

Technologiespezifisches Plugin für eine TypeScript-native Client/Server-Architektur: ein NestJS-Backend mit Drizzle ORM über PostgreSQL und ein Next.js App Router Frontend.

Ein besonderer Dank geht an Swift Ugandan für den Beitrag dieses Plugins.

/drizzle-migration – Drizzle-Schema und SQL-Migration erstellen
/implement – Use Case mit NestJS + Next.js implementieren
/nest-test – NestJS Backend-Tests mit Vitest erstellen
/react-test – Vitest Komponententests für Next.js erstellen
/playwright-test – Playwright E2E-Tests erstellen
  • Playwright – Browser-Automatisierung und E2E-Tests

Weitere Plugins folgen

Weitere technologiespezifische Plugins sind in Entwicklung. Beiträge sind willkommen! Fügen Sie Ihre eigenen Plugins hinzu, um der Community zu helfen.

KI-Automatisierung des Prozesses

Die heutigen Plugins automatisieren einzelne Schritte, die Sie Befehl für Befehl aufrufen. Wir arbeiten daran, den AI Unified Process durchgehend zu automatisieren, damit die Kette von den Anforderungen bis zu den Tests mit deutlich weniger manuellen Befehlsaufrufen abläuft.

Erste Schritte

Plugins installieren #

Starten Sie in Claude Code in wenigen Schritten; andere Agenten folgen weiter unten

  • 1. Werkzeuge installieren: Führen Sie in Claude Code die folgenden Befehle aus:
    /plugin marketplace add ai-unified-process/marketplace
    /plugin install aiup-core
    /plugin install aiup-vaadin-jooq  # oder: aiup-angular-jpa, aiup-blazor-dotnet, aiup-nestjs-nextjs
    Installieren Sie das Stack-Plugin, das zu Ihrem Projekt passt: aiup-vaadin-jooq für Vaadin + jOOQ, aiup-angular-jpa für Angular + Spring Boot JPA, aiup-blazor-dotnet für C# + Blazor auf .NET 10 oder aiup-nestjs-nextjs für NestJS + Next.js. Nur aiup-core genügt, wenn Sie einen anderen Tech-Stack verwenden; die Methodik-Skills sind stack-agnostisch, und der Stack-Leitfaden beschreibt, wie Sie ein Plugin für Ihren eigenen Stack bauen. Erfahren Sie mehr über Plugin-Marktplätze in der Claude Code Dokumentation.
  • 2. Befehl ausführen: Nach der Installation funktionieren Slash-Befehle direkt (z. B. /requirements). Wenn zwei installierte Plugins denselben Befehlsnamen liefern, mit der Namespaced-Form /plugin-name:command unterscheiden.
    /requirements
    /aiup-core:requirements
  • 3. Dem AI Unified Process-Workflow folgen: Beginnen Sie mit den aiup-core-Befehlen für Anforderungen und Modellierung, dann nutzen Sie die Befehle Ihres Stack-Plugins (aiup-vaadin-jooq, aiup-angular-jpa, aiup-blazor-dotnet oder aiup-nestjs-nextjs) für Implementierung und Tests. Jeder Schritt baut auf dem vorherigen auf. Noch ist das ein Workflow Befehl für Befehl; die KI-Automatisierung des Prozesses ist in Entwicklung. Dieselben Befehle decken auch Änderungen an einem bestehenden System ab: Aktualisieren Sie die Use-Case-Spezifikation und führen Sie /implement und die Test-Befehle erneut aus; sie gleichen den bestehenden Code und die bestehenden Tests ab, statt neue zu erzeugen. Für ein neues Feature, eine Änderung oder einen Bug gibt es keinen eigenen Befehl.
  • 4. Spezifikationen prüfen, bevor Sie implementieren: /spec-review (aiup-core) prüft die Spezifikationen gegeneinander, in zwei Teilen. Ein deterministischer Lint ohne LLM prüft, ob jeder Use Case im Diagramm eine Spezifikation hat, jede ID eindeutig ist, jeder Verweis auf FR, UC, Geschäftsregel und Prozess aufgelöst wird, jede funktionale Anforderung abgedeckt ist und jede BPMN-Aktivität einem Use Case entspricht; dazu meldet er vage Formulierungen und Glossar-Synonyme. Er liefert bei jedem Lauf dasselbe Ergebnis und kann deshalb einen Build stoppen. Ein beratendes semantisches Review sucht danach nach widersprüchlichen oder doppelten Geschäftsregeln, UI- oder Technikdetails in einem Use Case, Schritten, die fehlschlagen können, ohne dass ein Alternativablauf greift, nicht testbaren Regeln und Daten, die nicht zum Entitätsmodell passen. Wie /coverage-check berichtet es nur: Es ändert nie eine Spezifikation und schlägt für jeden Befund den Befehl vor, der ihn behebt. Bei einem bestehenden System übernehmen Sie die aktuellen Lint-Befunde als Baseline; danach lassen nur neue Befunde den Build scheitern.
    /spec-review  # das ganze Projekt
    /spec-review UC-004
    python3 tools/aiup/spec-review/scripts/spec_lint.py --docs docs --strict  # der Lint als CI-Gate
  • 5. Abdeckung prüfen, bevor Sie fertig sind: /coverage-check (aiup-vaadin-jooq) prüft einen implementierten Use Case (UC-*) oder Testfall (TC-*) gegen seine Spezifikation und liefert eine Abdeckungsmatrix: welche Schritte des Hauptszenarios, Alternativabläufe, Geschäftsregeln, Vorbedingungen und Nachbedingungen durch Code und Tests abgedeckt sind, was noch offen ist und wo Code oder Tests von der Spezifikation abgewichen sind. Gemeint ist Spezifikationsabdeckung, nicht Zeilenabdeckung, und der Befehl liest nur: Er meldet die Lücken und schlägt den nächsten Status der Spezifikation vor, schreibt aber weder Code noch Tests noch Dateien. Schliessen Sie die Lücken, indem Sie /implement und die Test-Befehle erneut ausführen.
    /coverage-check UC-001
    /coverage-check TC-001
Weitere KI-Coding-Tools

Den AI Unified Process mit weiteren KI-Coding-Tools nutzen #

Agent Skills (SKILL.md) ist mittlerweile ein offener Standard, und jedes Plugin entspricht zusätzlich dem Agent-Plugins-Paketstandard (agent-plugins.org). Dieselben Skill-Dateien aus diesem Marketplace laufen nativ, mit automatischer Aktivierung über die Beschreibung, in OpenAI Codex CLI, Cursor, GitHub Copilot, Gemini CLI und OpenCode. Installieren Sie sie mit Tessl, laden Sie sie mit einem beliebigen Agent-Plugins-Client, oder klonen Sie das Repository, legen Sie die Skill-Ordner in das Skills-Verzeichnis Ihres Tools ab und konfigurieren Sie die MCP-Server.

Installation via Tessl (jeder Agent) #

Tessl ist ein agent-agnostischer Paketmanager für Skills: Er installiert versionierte Skills und trägt die MCP-Server in das richtige Verzeichnis des jeweils erkannten Coding-Agents ein. Alle Plugins sind in der Tessl-Registry als ai-unified-process/aiup-core, ai-unified-process/aiup-vaadin-jooq, ai-unified-process/aiup-angular-jpa, ai-unified-process/aiup-blazor-dotnet und ai-unified-process/aiup-nestjs-nextjs veröffentlicht.

tessl init --agent claude-code  # oder: cursor, gemini, codex, copilot, agents
tessl install ai-unified-process/aiup-core
tessl install ai-unified-process/aiup-vaadin-jooq  # oder: ai-unified-process/aiup-angular-jpa, ai-unified-process/aiup-blazor-dotnet, ai-unified-process/aiup-nestjs-nextjs

Installierte Plugins landen in .tessl/plugins/ und werden in tessl.json versioniert, reproduzierbar im ganzen Team.

Agent-Plugins-Standard #

Jedes Plugin-Verzeichnis ist zugleich ein konformes Agent-Plugins-Paket: der offene, herstellerneutrale Plugin-Standard, dessen Steering Committee Vertreter von Amazon, Cursor, Microsoft, OpenAI und Vercel angehören. Jedes Plugin liefert die plugin.json- und mcp.json-Manifeste des Standards zusätzlich zu den Claude-Code-Manifesten mit.

Jeder Client, der Agent Plugins implementiert, kann ein Plugin direkt aus einem Checkout des Marketplace-Repositorys laden, inklusive Skills und MCP-Servern, ohne Konvertierung.

Manuelle Einrichtung (ohne Tessl) #

Klonen Sie das Marketplace-Repository, kopieren oder verlinken Sie die Skill-Ordner in das Skills-Verzeichnis Ihres Tools und übernehmen Sie die MCP-Server aus der .mcp.json des jeweiligen Plugins in die MCP-Konfiguration Ihres Tools.

Skills lösen Sie genauso aus wie in Claude Code: sagen Sie „schreibe Anforderungen" oder rufen Sie /requirements auf. Die erzeugten Dateien sind toolunabhängig identisch, sodass die Kette auch beim Mischen von Tools über die Schritte hinweg funktioniert.

OpenAI Codex CLI

Native SKILL.md-Unterstützung: Ablage in ~/.codex/skills/ oder .agents/skills/.

Cursor

Native Agent Skills seit Cursor 2.4: Ablage im projektlokalen .cursor/skills/.

GitHub Copilot

Versteht die /plugin-Marketplace-Befehle von Claude Code direkt: Plugins wie in Claude Code installieren, inklusive Skills und MCP.

Gemini CLI

Native SKILL.md-Unterstützung: Ablage in .gemini/skills/ oder ~/.gemini/skills/.

OpenCode

Native Skill-Unterstützung; durchsucht auch .claude/skills/ und .agents/skills/, sodass für Claude Code installierte Skills ohne Kopieren übernommen werden.

IDE-Plugin

AI Unified Process Navigator #

Ein separates IDE-Plugin für IntelliJ und Visual Studio Code, das Use-Case-Spezifikationen mit ihren Tests verknüpft, unabhängig von Claude Code

Spec ↔ Test Navigation #

Klicken Sie auf das Gutter-Symbol einer mit @UseCase annotierten Testmethode, um zur passenden UC-XXX-*.md-Spezifikation zu springen, und vom Spec-Header zurück zum Test.

Markdown-Header und Geschäftsregel-Referenzen in Ihren Spezifikationen werden klickbar, sodass Anforderungen und Tests synchron bleiben.

Von den Marketplaces installieren #

In IntelliJ IDEA: Einstellungen → Plugins → Marketplace; in Visual Studio Code: Extensions-Ansicht öffnen. Suchen Sie nach "AI Unified Process Navigator" und klicken Sie auf Installieren. Claude Code wird nicht benötigt.

Open Source unter Apache License 2.0. Funktioniert mit IntelliJ IDEA und anderen JetBrains-IDEs sowie mit Visual Studio Code.

Kontakt

Den AI Unified Process im Team einführen? #

Workshops, Beratung und massgeschneiderte Einführungen des AI Unified Process. Vereinbaren Sie einen Termin, um zu besprechen, wie der AI Unified Process zu Ihrem Stack und Team passt.