Agentic Development Patterns

Die Art, wie ich Software baue, hat sich grundlegend verändert. Statt jede Zeile selbst zu schreiben, orchestriere ich heute KI-Agenten, die die Implementierung übernehmen, während ich mich auf Architektur, Anforderungen und Qualität konzentriere. Es geht nicht darum, Entwickler zu ersetzen — es geht darum, das zu verstärken, was ein einzelner Entwickler (oder ein kleines Team) erreichen kann.

Nach über 25 Jahren Softwareentwicklung kann ich mit Überzeugung sagen: Das ist der größte Produktivitätssprung, den ich erlebt habe — größer als der Wechsel zu Agile, größer als Cloud, größer als CI/CD. Hier sind die Muster, die funktionieren.

Mein Development Stack

Primär: Claude Code (Max Subscription)

Claude Code ist ein CLI-Tool, das als autonomer Coding-Agent arbeitet. Es liest Projektdateien, versteht Kontext aus CLAUDE.md-Spezifikationen und führt mehrstufige Implementierungsaufgaben aus: Dateien erstellen, Code bearbeiten, Tests ausführen, Fehler beheben, Git-Commits erstellen.

Warum es mein primäres Tool ist:

• Tiefes Codebase-Verständnis: Es liest und indiziert das gesamte Projekt, nicht nur die aktuelle Datei
• Autonome Ausführung: Aufgabe geben, weggehen, mit funktionierender Implementierung zurückkommen
• CLAUDE.md-Integration: Projektspezifikationen leiten jede Interaktion ohne Wiederholung
• Tool-Nutzung: Shell-Befehle ausführen, Dateien lesen, Code durchsuchen — der vollständige Entwicklungszyklus
• Git-Awareness: Erstellt Commits, versteht Branches, respektiert den Workflow

Ich führe Claude Code Sessions in tmux aus, damit sie über Terminal-Schließungen hinweg bestehen bleiben. Mehrere Sessions in verschiedenen Panes, jede arbeitet an einem anderen Worktree.

Sekundär: Cursor Pro (Agent Mode)

Cursor ergänzt Claude Code für Aufgaben, bei denen visueller Kontext wichtig ist:

• Code Review: Diffs inline mit Syntax-Highlighting sind schneller als im Terminal
• UI-Arbeit: Beim Erstellen von Frontend-Komponenten Code und Ergebnis nebeneinander sehen
• Refactoring-Exploration: Agent Mode für “probier das auf drei verschiedene Arten und lass mich vergleichen”
• Schnelle Änderungen: Für kleine, fokussierte Änderungen, bei denen eine Claude Code Session überdimensioniert wäre

Tertiär: Lokale LLMs (Qwen3-Coder via MLX/Ollama)

Für schnelle Abfragen, Offline-Arbeit und sensiblen Code, der das Gerät nicht verlassen soll:

• Code-Erklärungen und Dokumentations-Lookups
• Einfache Refactoring-Vorschläge
• Brainstorming und Rubber-Ducking
• Verarbeitung von proprietärem Code oder Daten, die nicht an Cloud-APIs gesendet werden sollen

Kernmuster

Muster 1: Spezifikationsgetriebene Entwicklung

Das wichtigste Muster. Statt Code zu schreiben, schreibe detaillierte Spezifikationen und lass Agenten dagegen implementieren.

# CLAUDE.md (oder Aufgabenspezifikation)

## Feature: Workflow Exception Dashboard

### Anforderungen
- Tabellenansicht mit sortierbaren Spalten: Exception Type, Customer, Amount, Age, Status
- Filterleiste mit Multi-Select-Dropdowns für jede Spalte
- Klick auf Zeile öffnet Detail-Panel (Slide-out rechts)
- Detail-Panel zeigt: Exception-Details, Audit-Trail, Aktions-Buttons
- Aktionen: Approve, Reject, Escalate, Reassign

### Technische Constraints
- Bestehende DataTable-Komponente aus src/components/ui/ verwenden
- State Management via Zustand Store (Pattern in src/stores/)
- API-Aufrufe via React Query (Pattern in src/hooks/)
- Bestehende Tailwind Design Tokens befolgen

### Akzeptanzkriterien
- Alle Spalten auf-/absteigend sortierbar
- Filter bleiben über Seitennavigation hinweg bestehen
- Detail-Panel animiert von rechts herein (300ms ease-out)
- Loading- und Error-States behandelt
- Unit Tests für den Zustand Store

Die Spezifikation wird zum Vertrag zwischen menschlicher Absicht und maschineller Ausführung. 30 Minuten für eine klare Spec sparen 3+ Stunden Hin und Her mit Agenten. Die Spec zwingt mich, klar zu denken, bevor die Implementierung beginnt — eine Disziplin, die Ergebnisse verbessert, unabhängig davon, ob Menschen oder Agenten den Code schreiben.

Muster 2: Parallele Agenten-Workstreams

Mit Git Worktrees führe ich mehrere Agenten gleichzeitig an unabhängigen Features aus. Jeder Agent bekommt seine eigene isolierte Umgebung — eigener Branch, eigenes Arbeitsverzeichnis, null Interferenz mit anderen.

# Parallele Workstreams aufsetzen
git worktree add ../project-feature-a feature/dashboard-redesign
git worktree add ../project-feature-b feature/api-v2-migration
git worktree add ../project-feature-c feature/test-coverage

# Terminal 1: Claude Code auf Feature A
cd ../project-feature-a && claude

# Terminal 2: Claude Code auf Feature B
cd ../project-feature-b && claude

# Terminal 3: Cursor Agent Mode auf Feature C
# ../project-feature-c in Cursor öffnen

Typischerweise laufen bei mir 2-3 parallele Workstreams während fokussierter Arbeitssessions. Jeder Agent arbeitet an einem unabhängigen Feature ohne geteilten State. Ich wechsle zwischen Panes, um den Fortschritt zu prüfen, gebe Orientierung wenn Agenten feststecken und reviewe abgeschlossene Arbeit.

Zentrale Disziplin: Features müssen wirklich unabhängig sein. Wenn zwei Agenten dieselben Dateien ändern müssen, entstehen Merge-Konflikte, die den Produktivitätsgewinn zunichtemachen. Plane die Aufgabenzerlegung entsprechend.

Muster 3: Die Overnight Agent Factory

Mein Muster mit dem größten Hebel. Vor Feierabend:

1. Specs schreiben für 2-3 Features oder Aufgaben
2. Worktrees und Branches für jedes erstellen
3. Claude Code Sessions in tmux-Panes mit klaren Anweisungen starten
4. Schlafen gehen
5. Morgens reviewen: Ergebnisse bewerten, Probleme beheben, Gutes mergen

Was ich gelernt habe, damit das funktioniert:

• Umfassende Specs sind nicht verhandelbar. Vage Anweisungen produzieren vage Ergebnisse über Nacht ohne Chance auf Rückfragen.
• Test-Suites sind essenziell. Agenten brauchen automatisierte Validierung zur Selbstkorrektur. Hat das Projekt gute Tests, können Agenten iterieren bis grün. Hat es keine, bekommt man ungetesteten Code.
• Abgegrenzte Aufgaben funktionieren am besten. “Implementiere diesen API-Endpunkt mit diesen 5 Tests” klappt über Nacht. “Redesigne die Architektur” nicht.
• 70-80% Trefferquote erwarten. Vielleicht 2 von 3 Overnight-Tasks produzieren versandfertigen Code. Der dritte braucht Nacharbeit. Das ist trotzdem enormer Hebel.

Muster 4: Agenten-unterstütztes Code Review

Einen Agenten implementieren lassen, einen anderen reviewen lassen:

1. Feature-Agent implementiert eine Änderung
2. Review-Agent liest den Diff und die Spezifikation
3. Review-Agent identifiziert Probleme: fehlende Randfälle, Inkonsistenzen mit Codebase-Patterns, potenzielle Bugs
4. Feature-Agent bearbeitet das Feedback

Das schafft eine Form von KI-Pair-Programming, bei dem Meinungsverschiedenheiten zwischen Agenten oft echte Design-Probleme aufdecken. Es ist nicht perfekt — beide Agenten können dieselben blinden Flecken haben — aber es fängt überraschend viele reale Probleme ab.

Muster 5: Progressive Delegation

Nicht alles sollte agentengesteuert sein. Meine Hierarchie:

Aufgabentyp	Ansatz	Tool
Architekturentscheidungen	Mensch-gesteuert, KI-beraten	Whiteboard + Claude Chat
Komplexe Business-Logik	Mensch-gesteuert, Agent-implementiert	Claude Code mit detaillierter Spec
Standard-Features	Agent-gesteuert, Mensch-reviewed	Claude Code autonom
Boilerplate / CRUD	Agent-gesteuert, leichtes Review	Claude Code oder Cursor Agent
Tests aus bestehendem Code	Agent-gesteuert, Bestehen verifizieren	Claude Code
Dokumentation	Agent-gesteuert, minimales Review	Claude Code
Refactoring	Agent-gesteuert, Diff-Review	Cursor Agent Mode

Die zentrale Erkenntnis: Den Grad der menschlichen Beteiligung an den Grad des benötigten Urteilsvermögens anpassen. Verschwende keine Zeit mit dem Handschreiben von CRUD-Endpunkten. Delegiere Sicherheitsarchitektur nicht an einen Agenten.

Muster 6: CLAUDE.md als lebende Dokumentation

Die CLAUDE.md ist kein einmaliges Artefakt — sie entwickelt sich mit dem Projekt:

• Tag 1: Grundlegende Projektübersicht, Tech Stack, Dateistruktur
• Woche 1: Coding-Konventionen aus frühem Agent-Output ergänzen (“Keine Default Exports”, “Immer Named Functions verwenden”)
• Monat 1: Gängige Patterns, Architekturentscheidungen und zu vermeidende Anti-Patterns aufnehmen
• Fortlaufend: Aktualisieren bei neuen Libraries, geänderten Patterns oder Lernen aus Agent-Fehlern

Jede Korrektur am Agent-Output sollte als Regel in die CLAUDE.md zurückfließen. Mit der Zeit machen Agenten weniger Fehler, weil die Spec besser wird. Es ist ein Schwungrad.

Was funktioniert und was nicht

Agenten glänzen bei

• Boilerplate und CRUD: Generieren von Standardmustern, API-Endpunkten, Datenbankschemata, Formular-Komponenten
• Testgenerierung: Schreiben von Unit- und Integrationstests aus bestehendem Code
• Refactoring: Umbenennen, Umstrukturieren, konsistente Patterns über eine Codebase anwenden
• Formatkonvertierung: Migration zwischen Frameworks, API-Versionen aktualisieren, Sprachkonvertierung
• Dokumentation: Docs aus Code generieren, README-Dateien, API-Dokumentation
• Implementierung gut spezifizierter Features: Bei klarer Spec liefern Agenten zuverlässig
• Neue Frameworks lernen: Agent + Docs = schnellerer Einstieg als Docs selbst lesen

Agenten tun sich schwer mit

• Neuartige Architekturentscheidungen: Sie können Patterns implementieren, sollten sie aber nicht wählen
• Unklare Anforderungen: Garbage in, garbage out — vage Specs produzieren vage Implementierungen
• Tiefe Domain-Logik: Geschäftsregeln, die Organisationskontext und Stakeholder-Empathie erfordern
• Performance-Optimierung: Sie optimieren auf Korrektheit, nicht immer auf Effizienz
• Sicherheit: Agent-generiertem Code für sicherheitskritische Pfade niemals ohne gründliches Review vertrauen
• Großflächige Koordination: Multi-Service-Änderungen mit komplexen Abhängigkeiten brauchen weiterhin menschliche Orchestrierung

Die Produktivitätsrealität

Für erfahrene Entwickler, die in das Erlernen dieser Muster investieren, ist der Multiplikator real:

• Implementierungsgeschwindigkeit: 5-10x für gut spezifizierte Features
• Testabdeckung: 3-5x mehr Tests, weil die Grenzkosten gegen null gehen
• Code-Konsistenz: Höher, weil Agenten CLAUDE.md-Konventionen zuverlässiger befolgen als Menschen Style Guides
• Gesamtdurchsatz: Ein einzelner Entwickler mit Agenten-Tooling entspricht dem Output eines 3-4-Personen-Teams für viele Workloads

Aber der Multiplikator hängt komplett von der Spezifikationsqualität und der Projektinfrastruktur ab (Tests, CI, klare Architektur). Ein Agent in einer gut strukturierten Codebase mit guten Specs und Tests bringt 10x. Ein Agent in einer chaotischen Codebase ohne Specs und ohne Tests bringt 1x — oder weniger, weil man Agent-generierten Spaghetti-Code debuggt.

Die sich wandelnde Rolle des Entwicklers

Die Messlatte ist gestiegen, nicht gefallen. Man muss ein besserer Engineer sein, um KI-Agenten effektiv zu steuern, als um Code manuell zu schreiben:

• Besser in Spezifikation: Klare Specs produzieren klaren Code
• Besser in Architektur: Agenten implementieren dein Design; das Design muss trotzdem gut sein
• Besser im Code Review: Man reviewed mehr Code, schneller, mit höheren Einsätzen
• Besser in Zerlegung: Arbeit in agentengerechte, unabhängige Teile zu zerlegen ist eine Fähigkeit
• Besser in Qualitätsbeurteilung: “Gut genug” von “braucht mehr Arbeit” unterscheiden beim Review von Agent-Output

Die Entwickler, die mit agentenbasierten Tools kämpfen, sind oft diejenigen, die den Spezifikationsschritt überspringen, Agent-Output nicht sorgfältig reviewen oder Agenten für Aufgaben einsetzen, die tiefes Urteilsvermögen erfordern. Diejenigen, die damit aufblühen, behandeln Agenten als extrem fähige Junior-Entwickler, die klare Anweisungen und gründliches Code Review brauchen.