# Von der Spezifikation zum Code: Spec-getriebene Entwicklung mit Agenten

> Spec-getriebene Entwicklung legt vor dem Code fest, was gebaut wird: Eine Spezifikation beschreibt Verhalten und Abnahmekriterien, ein Plan die Technik, eine Aufgabenliste die Schritte. Der Agent setzt Aufgabe für Aufgabe um, und Tests sowie ein Review gegen die Spezifikation prüfen das Ergebnis.

Kanonische URL: https://www.ruebstudio.de/de/wissen/ki-agenten-entwicklung/spec-driven-development-agenten  
Autor: Dr.-Ing. Marcus Rüb, CEO  
Veröffentlicht: 2026-10-29

Coding-Agenten schreiben Code schnell, aber sie bauen das, was im Prompt steht – nicht das, was gemeint war. Je größer die Aufgabe, desto teurer wird diese Lücke. Spec-getriebene Entwicklung schließt sie, indem der Prozess vor dem Code feste Stationen bekommt: Spezifikation, Plan, Zerlegung in Aufgaben, Umsetzung und Prüfung. Dieser Überblick erklärt die Bausteine, die verbreiteten Werkzeuge, die Voraussetzungen und die Grenzen. Stand: Oktober 2026.

## Was ist spec-getriebene Entwicklung und wofür wird sie eingesetzt?

Spec-getriebene Entwicklung (englisch spec driven development) bedeutet: Bevor ein Agent Code schreibt, gibt es ein schriftliches Dokument, das Verhalten, Grenzen und Abnahmekriterien festlegt. Aus diesem Dokument entstehen Plan und Aufgaben, und am Ende wird das Ergebnis gegen genau dieses Dokument geprüft – nicht gegen das Bauchgefühl.

Die Idee ist älter als KI-Agenten, bekommt mit ihnen aber neues Gewicht. Ein Mensch, der eine vage Anforderung bekommt, fragt nach. Ein Agent füllt Lücken oft mit plausiblen Annahmen und arbeitet weiter. Die [Best Practices zu Claude Code](https://code.claude.com/docs/en/best-practices) beschreiben genau dieses Muster: Wenn Claude etwas anderes gebaut hat als gedacht, fehlte ihm meist eine Information, die nicht im Repository steht.

GitHub formuliert den Anspruch in der Methodikbeschreibung von [Spec Kit](https://github.com/github/spec-kit/blob/main/spec-driven.md) zugespitzt: „Specifications don't serve code—code serves specifications.“ Die Spezifikation ist dort das primäre Artefakt, der Code ihr Ausdruck. Sie müssen diese Haltung nicht vollständig übernehmen, um zu profitieren. Schon die schwächere Form – „die Spezifikation ist der Maßstab, an dem wir prüfen“ – verändert, wie Aufgaben an Agenten übergeben werden.

Typische Einsatzfelder:

- **Neue Features mit mehreren Dateien oder Schichten**, etwa eine Schnittstelle mit Datenmodell, Validierung und Oberfläche.
- **Änderungen mit vielen Randfällen**, zum Beispiel Rechtelogik, Preisberechnung oder Datenmigration.
- **Lange Läufe ohne Aufsicht**, bei denen der Agent selbst feststellen muss, wann er fertig ist.
- **Arbeit, die auf mehrere Agenten oder Sitzungen verteilt wird**, weil jede Sitzung denselben schriftlichen Bezugspunkt braucht.

## Worin unterscheidet sich das von agentischer Softwareentwicklung allgemein?

Agentische Softwareentwicklung beschreibt, wie Teams mit Werkzeugen wie Claude Code, Codex oder Cursor arbeiten. Spec-getriebene Entwicklung ist ein Teil davon: der Ablauf vor dem ersten Codezeichen und die Prüfung danach. Werkzeugwahl, Einführung im Team und Rechte sind ein anderes Thema.

Der Überblick zur [agentischen Softwareentwicklung im Team](https://www.ruebstudio.de/de/wissen/ki-agenten-entwicklung/agentische-softwareentwicklung-team) behandelt, welche Werkzeuge es gibt, wie sie sich unterscheiden und wie ein Team sie einführt. Dieser Artikel setzt eine Ebene darunter an und fragt: Wie sieht eine einzelne Aufgabe aus, wenn sie nicht als Prompt, sondern als Spezifikation beginnt? Die Antworten gelten weitgehend unabhängig vom Werkzeug.

## Wie funktioniert spec-getriebene Entwicklung? Die Bausteine

Der Ablauf besteht aus fünf Bausteinen, die aufeinander aufbauen: Projektregeln, Spezifikation, technischer Plan, Aufgabenliste und Prüfung. Jeder Baustein ist ein Dokument oder ein Befehl, den Mensch und Agent gemeinsam nutzen. Die Namen unterscheiden sich je nach Werkzeug, die Funktion ist überall ähnlich.

### Projektregeln

Projektregeln gelten für alle Aufgaben: Architekturentscheidungen, Teststrategie, verbotene Abhängigkeiten. Spec Kit nennt dieses Dokument „Constitution“ und legt es unter `memory/constitution.md` ab; die [Methodikbeschreibung](https://github.com/github/spec-kit/blob/main/spec-driven.md) nennt es die „architectural DNA of the system“. In Claude Code übernimmt die Datei `CLAUDE.md` eine ähnliche Rolle. Die [Best Practices](https://code.claude.com/docs/en/best-practices) empfehlen, dort nur festzuhalten, was der Agent nicht aus dem Code ablesen kann, etwa die genauen Test- und Lint-Befehle oder Entscheidungen, die nirgends dokumentiert sind.

### Spezifikation

Die Spezifikation beschreibt das *Was*: Verhalten aus Sicht der Nutzer, Abnahmekriterien, Randfälle und ausdrücklich ausgeschlossene Punkte. Sie beschreibt nicht, welche Bibliothek verwendet wird. Kiro schreibt Anforderungen in `requirements.md` und nutzt dafür laut [Kiro-Dokumentation](https://kiro.dev/docs/specs/feature-specs/) die EARS-Notation (Easy Approach to Requirements Syntax) mit dem Muster „WHEN [condition/event] THE SYSTEM SHALL [expected behavior]“. Spec Kit lässt den Agenten Unklarheiten mit der Markierung `[NEEDS CLARIFICATION: …]` kennzeichnen, statt sie zu raten.

### Technischer Plan

Der Plan beschreibt das *Wie*: Architektur, Datenmodell, Schnittstellen, Teststrategie. Bei Kiro heißt die Datei `design.md` und enthält laut [Dokumentation](https://kiro.dev/docs/specs/) Architektur, Sequenzdiagramme und Umsetzungsüberlegungen. Spec Kit erzeugt neben `plan.md` je nach Vorhaben weitere Dateien wie `research.md`, `data-model.md`, einen Ordner `contracts/` und `quickstart.md`.

### Aufgabenliste

Die Aufgabenliste zerlegt den Plan in einzeln prüfbare Schritte. Bei Kiro ist das `tasks.md`, bei Spec Kit ebenfalls `tasks.md`. Entscheidend ist, dass jede Aufgabe ein klares Ergebnis hat und dass sichtbar ist, welche Aufgaben voneinander abhängen. Spec Kit markiert unabhängige Aufgaben mit `[P]`; Kiro baut beim Ausführen aller Aufgaben einen Abhängigkeitsgraphen.

### Prüfung

Die Prüfung schließt den Kreis: Tests, Typprüfung, Linting und ein Review gegen die Spezifikation. Ohne diesen Baustein ist die Spezifikation nur ein besserer Prompt. Erst wenn das Ergebnis gegen das Dokument abgeglichen wird, entsteht der eigentliche Nutzen.

## Welche Werkzeuge und Varianten gibt es?

Es gibt drei verbreitete Varianten: ein eigenständiges Vorlagenwerkzeug wie Spec Kit, eine Entwicklungsumgebung mit eingebautem Spec-Ablauf wie Kiro und eine schlanke Variante mit Markdown-Datei und Plan-Modus im Coding-Agenten. Alle drei folgen derselben Reihenfolge; sie unterscheiden sich darin, wie viel Struktur sie vorgeben.

**Spec Kit** ist ein Open-Source-Werkzeug von GitHub. Laut [README](https://github.com/github/spec-kit) läuft der Kernablauf über Befehle im Chat des Agenten: Projektprinzipien festlegen (Constitution, einmal pro Projekt), Feature spezifizieren, technischen Plan erstellen, Arbeit in Aufgaben zerlegen und umsetzen. Eingerichtet wird es über das Kommandozeilenwerkzeug `specify`. Spec Kit ist nicht an einen Agenten gebunden, sondern bietet Integrationen für mehrere Coding-Agenten. Der Vorteil sind fertige Vorlagen und ein einheitliches Verzeichnislayout; der Preis ist mehr Struktur, als manches kleine Projekt braucht.

**Kiro** baut den Ablauf direkt in die Entwicklungsumgebung ein. Die [Kiro-Dokumentation](https://kiro.dev/docs/specs/) unterscheidet Feature-Specs, Bugfix-Specs und eine „Quick Spec“, die alle drei Dateien in einem Durchgang ohne Freigabeschritte erzeugt. Für Features gibt es zwei Reihenfolgen: Requirements-First (Anforderungen, dann Design, dann Aufgaben) für produktgetriebene Vorhaben und Design-First für Projekte mit strengen nichtfunktionalen Anforderungen oder bestehenden Designdokumenten.

**Markdown-Datei plus Plan-Modus** ist die schlanke Variante. Die [Best Practices zu Claude Code](https://code.claude.com/docs/en/best-practices) beschreiben sie so: Der Agent interviewt Sie, bis er die Spezifikation schreiben kann, und legt sie als `SPEC.md` ab. Danach starten Sie eine frische Sitzung, die aus dieser Datei baut. Der [Plan-Modus](https://code.claude.com/docs/en/permission-modes) sorgt dafür, dass der Agent zunächst liest und einen Plan schreibt, ohne Quellcode zu ändern. Diese Variante braucht kein zusätzliches Werkzeug und passt gut für Teams, die erst ausprobieren wollen.

Die Reihe zu diesem Thema vertieft die einzelnen Schritte: wie eine Spezifikation aussieht, die Agenten zuverlässig umsetzen, und wie der Plan-Modus in Claude Code im Alltag funktioniert. Die Artikel erscheinen nach und nach und werden unten auf dieser Seite aufgelistet.

## Welche Voraussetzungen braucht der Ablauf?

Spec-getriebene Entwicklung setzt drei Dinge voraus: ein Repository mit automatisierten Prüfungen, Menschen, die Spezifikationen fachlich freigeben können, und die Bereitschaft, für größere Aufgaben vor dem Code Zeit zu investieren. Fehlt eines davon, bleibt vom Ablauf vor allem zusätzliche Dokumentation übrig.

**Automatisierte Prüfungen.** Der Agent muss selbst feststellen können, ob er fertig ist. Die [Best Practices](https://code.claude.com/docs/en/best-practices) warnen: Hat der Agent nichts, das ihm sagt, ob die Arbeit wirklich fertig ist, bleibt ihm nur „sieht fertig aus“ – und Sie werden selbst zur Testsuite. Mindestens ein Testlauf, eine Typprüfung oder ein Linter, die per Befehl starten, gehören deshalb dazu.

**Fachliche Freigabe.** Eine Spezifikation ist nur so gut wie die Person, die sie abnimmt. Bei internen Werkzeugen ist das oft die Fachabteilung, bei Schnittstellen das Team auf der anderen Seite. Klären Sie vorher, wer freigibt und wie schnell.

**Versionierung.** Spezifikation, Plan und Aufgaben liegen am besten im selben Repository wie der Code. Dann sind Änderungen nachvollziehbar, und ein Review kann Spezifikation und Diff nebeneinanderlegen.

**Saubere Arbeitskopien für parallele Arbeit.** Wer mehrere Agenten gleichzeitig arbeiten lässt, braucht getrennte Checkouts. Claude Code startet dafür Sitzungen in eigenen Git-Worktrees (`claude -w <name>`); dort fehlen allerdings ignorierte Dateien wie `.env` und installierte Abhängigkeiten, wie die [Best Practices](https://code.claude.com/docs/en/best-practices) festhalten.

## Wie gehe ich in Schritten vor?

Der Ablauf hat sechs Schritte: Anforderung klären, Spezifikation schreiben und freigeben, Plan erstellen, in Aufgaben zerlegen, Aufgaben umsetzen und gegen die Spezifikation prüfen. Zwischen den Schritten gibt es bewusste Haltepunkte, an denen ein Mensch entscheidet, ob es weitergeht.

### 1. Anforderung klären

Wenn Sie noch nicht genau wissen, was Sie wollen, lassen Sie sich befragen. Die [Best Practices](https://code.claude.com/docs/en/best-practices) schlagen einen Prompt dieser Art vor: Der Agent soll Sie interviewen, bis er die Spezifikation schreiben kann, und sie dann als `SPEC.md` ablegen. Er stellt dann Fragen zu den offenen Punkten, im Beispiel der Doku etwa Grenzen pro Nutzer oder pro Schlüssel und was nicht zum Umfang gehört.

### 2. Spezifikation schreiben und freigeben

Eine brauchbare Spezifikation für einen Agenten hat wenige, feste Abschnitte:

```markdown
# Feature: Export offener Angebote als CSV

## Ziel
Vertriebsinnendienst exportiert alle offenen Angebote eines Zeitraums.

## Anforderungen
- WHEN ein Nutzer einen Zeitraum wählt und „Export“ klickt,
  THE SYSTEM SHALL eine CSV-Datei mit allen offenen Angeboten liefern.
- WHEN der Zeitraum keine Angebote enthält,
  THE SYSTEM SHALL eine Datei nur mit Kopfzeile liefern.

## Randfälle
- Umlaute und Semikolons in Kundenfeldern
- Zeitraum über einen Jahreswechsel

## Nicht im Umfang
- Excel-Format, geplante Exporte

## Abnahme
- Tests für alle Anforderungen und Randfälle grün
- [NEEDS CLARIFICATION: Welche Spalten braucht die Buchhaltung?]
```

Wichtig sind der Abschnitt „Nicht im Umfang“ und die offenen Fragen. Beides verhindert, dass der Agent Lücken mit eigenen Annahmen füllt. Geben Sie die Spezifikation erst frei, wenn keine Markierung für Unklarheiten mehr offen ist.

### 3. Plan erstellen

Für den Plan wechseln Sie in einen Modus, in dem der Agent liest, aber nicht ändert. In Claude Code ist das der [Plan-Modus](https://code.claude.com/docs/en/permission-modes): per `Shift+Tab`, mit `/plan` vor einem einzelnen Prompt oder beim Start mit `claude --permission-mode plan`. Der Agent liest Dateien, führt erkundende Befehle aus und schreibt einen Plan; Quellcode ändert er nicht, bis Sie den Plan freigeben. Mit `Ctrl+G` öffnen Sie den Plan vorher im Editor und können ihn anpassen.

```bash
# Planungssitzung direkt im Plan-Modus starten
claude --permission-mode plan
```

### 4. In Aufgaben zerlegen

Eine gute Aufgabe ist klein genug, um in einer Sitzung fertig zu werden, und hat ein prüfbares Ergebnis, idealerweise einen Test, der vorher rot und danach grün ist. Spec Kit verlangt in seiner Methodik ausdrücklich, dass Tests vor der Umsetzung fehlschlagen („Red phase“). Ordnen Sie jeder Aufgabe zu, welche Anforderung aus der Spezifikation sie erfüllt. So sehen Sie am Ende, ob etwas fehlt.

### 5. Umsetzen

Für die Umsetzung empfiehlt es sich, mit frischem Kontext zu beginnen. Die [Best Practices](https://code.claude.com/docs/en/best-practices) raten, nach dem Schreiben der `SPEC.md` eine neue Sitzung zu starten, damit der Bau mit sauberem Kontext und einer schriftlichen Definition von „fertig“ beginnt. Lassen Sie den Agenten nach jeder Aufgabe die Prüfungen laufen und sich die Ausgabe zeigen – die Doku betont, dass „alle Tests grün“ allein wenig aussagt, die tatsächliche Befehlsausgabe dagegen schon.

### 6. Gegen die Spezifikation prüfen

Zum Schluss prüft ein Reviewer, der den Code nicht geschrieben hat. Die [Best Practices](https://code.claude.com/docs/en/best-practices) schlagen vor, einen Subagenten den Diff gegen `SPEC.md` prüfen zu lassen: Ist jede Anforderung umgesetzt, haben die genannten Randfälle Tests? Der Zusatz, Stilfragen auszulassen, ist dabei wichtig – ein Reviewer, der Probleme finden soll, findet immer etwas, und wer jeden Hinweis umsetzt, baut unnötige Abstraktionen ein.

## Wie parallelisiere ich Aufgaben sicher?

Parallel arbeiten lohnt sich nur bei Aufgaben, die keine gemeinsamen Dateien ändern und nicht aufeinander warten. Die Aufgabenliste ist dafür die Grundlage: Erst wenn Abhängigkeiten sichtbar sind, lässt sich entscheiden, was gleichzeitig laufen darf. Jede parallele Arbeit braucht eine eigene Arbeitskopie.

Die Werkzeuge lösen das unterschiedlich. Spec Kit markiert unabhängige Aufgaben mit `[P]` und skizziert sichere Parallelgruppen. Kiro baut laut [Dokumentation](https://kiro.dev/docs/specs/) beim Ausführen aller Aufgaben einen Abhängigkeitsgraphen und fasst unabhängige Aufgaben zu Wellen zusammen; die Wellen laufen nacheinander, die Aufgaben innerhalb einer Welle gleichzeitig. In Claude Code trennen Sie parallele Sitzungen über Git-Worktrees.

Drei Regeln haben sich bewährt:

- **Schnittstellen zuerst.** Gemeinsame Datenmodelle und Verträge gehören in eine frühe Aufgabe, die abgeschlossen ist, bevor parallele Arbeit beginnt.
- **Keine geteilten Dateien.** Zwei Aufgaben, die dieselbe Datei ändern, sind nicht unabhängig, auch wenn sie fachlich getrennt wirken.
- **Zusammenführen ist eine eigene Aufgabe.** Nach jeder Welle laufen die vollständigen Prüfungen auf dem zusammengeführten Stand, nicht nur in den einzelnen Arbeitskopien.

Bedenken Sie die Kosten: Laut [Best Practices](https://code.claude.com/docs/en/best-practices) verbraucht jeder Subagent eigene Anfragen, und ein frischer Subagent muss Kontext erst sammeln, den die Hauptsitzung schon hatte. Parallelität bringt Tempo oder einen unvoreingenommenen Blick, aber keine klügere Antwort.

## Wo liegen die Grenzen und Risiken?

Spec-getriebene Entwicklung verschiebt Aufwand nach vorn. Bei kleinen oder explorativen Aufgaben übersteigt dieser Aufwand den Nutzen. Außerdem kann eine schlechte Spezifikation den Agenten zuverlässig in die falsche Richtung lenken – Struktur schützt nicht vor falschen Anforderungen.

- **Überdokumentation.** Ein vollständiger Satz aus Spezifikation, Plan, Datenmodell und Aufgabenliste für eine Änderung von zehn Zeilen ist Bürokratie. Die Claude-Code-Doku hält ausdrücklich fest, dass beim Erkunden auch ein vager Prompt völlig in Ordnung ist.
- **Veraltete Dokumente.** Wenn sich während der Umsetzung Anforderungen ändern und die Spezifikation nicht nachgezogen wird, prüft das Review gegen einen falschen Stand. Ändern Sie zuerst die Spezifikation, dann den Code.
- **Scheingenauigkeit.** Formale Notationen wie EARS machen Anforderungen prüfbarer, aber nicht automatisch richtig. Die fachliche Freigabe bleibt menschliche Arbeit.
- **Zu große Aufgaben.** Wenn eine Aufgabe nicht in einer Sitzung fertig wird, wächst der Kontext, und Korrekturen häufen sich. Die [Best Practices](https://code.claude.com/docs/en/best-practices) empfehlen, nach zwei gescheiterten Korrekturen mit `/clear` neu zu beginnen und einen besseren Prompt zu schreiben. Für spec-getriebene Arbeit heißt das: die Aufgabe kleiner schneiden.
- **Unkritisches Review.** Ein Review-Agent, der jeden Fund meldet, erzeugt Arbeit ohne Nutzen. Begrenzen Sie das Review auf Abweichungen von der Spezifikation, die die Korrektheit betreffen.

## Wie fange ich an?

Beginnen Sie mit einem einzigen, mittelgroßen Feature und der schlanken Variante: einer Markdown-Spezifikation im Repository, einer Planungsphase ohne Codeänderungen und einem Review gegen die Spezifikation am Ende. Erst wenn das funktioniert, lohnt ein Werkzeug mit festen Vorlagen.

Ein pragmatischer Einstieg in drei Schritten:

1. **Prüfbefehle festhalten.** Schreiben Sie die Befehle für Tests, Typprüfung und Linting in die Projektregeln, etwa in `CLAUDE.md`. Ohne sie kann kein Agent seine Arbeit prüfen.
2. **Eine Vorlage für Spezifikationen anlegen.** Ziel, Anforderungen, Randfälle, nicht im Umfang, Abnahme, offene Fragen – mehr braucht es für den Anfang nicht.
3. **Einen Durchlauf auswerten.** Notieren Sie nach dem ersten Feature, wo der Agent von der Spezifikation abgewichen ist und warum. Meist zeigt sich, dass ein Abschnitt fehlte oder eine Anforderung nicht prüfbar formuliert war.

In unserem eigenen Betrieb hat sich vor allem der Haltepunkt nach dem Plan bewährt, eine einfache Form von [Human-in-the-Loop](https://www.ruebstudio.de/de/lexikon/human-in-the-loop): Ein kurzer Blick auf den Plan kostet wenig und verhindert, dass ein Agent in die falsche Richtung baut. Wer den Ablauf im Team verankern will, kann Spezifikation, Plan und Prüfung in einem [Workshop](https://www.ruebstudio.de/de/workshop) an eigenen Aufgaben durchspielen.

## Häufige Fragen

### Brauche ich für spec-getriebene Entwicklung ein eigenes Werkzeug?

Nein. Spec Kit und Kiro geben den Ablauf mit Vorlagen vor, aber dieselbe Disziplin funktioniert auch mit einer einfachen Markdown-Datei im Repository, die der Agent liest und gegen die geprüft wird.

### Wie lang sollte eine Spezifikation sein?

So lang, dass jede Anforderung prüfbar ist und offene Punkte benannt sind. Für ein überschaubares Feature reicht oft eine Seite; wichtiger als die Länge sind klare Abnahmekriterien und eine Liste dessen, was ausdrücklich nicht dazugehört.

### Lohnt sich der Aufwand auch für kleine Änderungen?

Meist nicht. Einen Tippfehler oder eine klar umrissene Korrektur beschreibt ein präziser Prompt mit einem Test besser als ein mehrstufiges Dokument.

### Wer schreibt die Spezifikation – Mensch oder Agent?

Beide gemeinsam. Bewährt hat sich, dass der Agent per Rückfragen einen Entwurf erstellt und ein Mensch ihn prüft und freigibt, bevor ein Plan entsteht.

## Quellen

- [GitHub Spec Kit – Repository und README](https://github.com/github/spec-kit)
- [GitHub Spec Kit – Spec-Driven Development (Methodik)](https://github.com/github/spec-kit/blob/main/spec-driven.md)
- [Kiro Docs – Specs](https://kiro.dev/docs/specs/)
- [Kiro Docs – Feature Specs](https://kiro.dev/docs/specs/feature-specs/)
- [Claude Code Docs – Best practices](https://code.claude.com/docs/en/best-practices)
- [Claude Code Docs – Permission modes (Plan-Modus)](https://code.claude.com/docs/en/permission-modes)
