Agentic Coding verändert die Rolle des Entwicklers. Du schreibst nicht mehr jede Zeile selbst. Stattdessen beschreibst Du ein Ziel, gibst dem Agenten Kontext und lässt ihn analysieren, planen, implementieren, testen und verbessern.

Damit das funktioniert, reicht ein guter Coding Agent allein nicht aus. Entscheidend ist der Workflow.

Die folgenden Prinzipien gelten weitgehend unabhängig davon, ob Du Cursor, Claude Code, Codex, GitHub Copilot, OpenCode, Amp oder einen anderen Agenten verwendest.

I. Den Agenten nicht wie ChatGPT behandeln

Der größte Fehler beim Agentic Coding ist ein zu enger Chatbot-Workflow:

„Schreib mir eine Login-Funktion.“

Besser ist:

„Implementiere einen sicheren Login für unsere Next.js-Anwendung. Nutze das bestehende Auth-System. Halte Dich an die vorhandenen Patterns. Prüfe anschließend Typen und Tests und behebe auftretende Fehler.“

Der Unterschied ist entscheidend.

Ein klassischer Coding Assistant soll Dir Code liefern.

Ein Coding Agent soll eine Aufgabe erledigen.

Dafür braucht er:

• ein klares Ziel

• relevante Rahmenbedingungen

• Zugriff auf den Code

• Werkzeuge

• Erfolgskriterien

• Möglichkeiten zur Überprüfung

OpenAI empfiehlt beispielsweise, komplexe Aufgaben zunächst als Plan zu formulieren und Prompts ähnlich wie ein gutes GitHub Issue aufzubauen.

II. Beschreibe das Ergebnis, nicht jeden einzelnen Arbeitsschritt

Versuche nicht, den Agenten wie einen Junior-Entwickler mit jedem einzelnen Befehl zu steuern.

Schlecht:

Öffne Datei X. Ändere Funktion Y. Erstelle Datei Z. Importiere A. Danach ändere B.

Besser:

Implementiere Feature X. Nutze dafür das bestehende Pattern aus components/.... Die API soll Y unterstützen. Die Implementierung muss Z erfüllen. Führe anschließend die relevanten Tests aus.

Der Agent kann dann selbst entscheiden:

1. welche Dateien relevant sind

2. welche Architektur bereits existiert

3. welche Änderungen notwendig sind

4. welche Tools er benötigt

5. wie er die Lösung überprüft

Du definierst das „Was“ und die Grenzen. Der Agent entscheidet möglichst oft über das „Wie“.

III. Große Aufgaben zuerst analysieren lassen

Bei größeren Änderungen solltest Du nicht sofort „Code schreiben“ lassen.

Nutze einen Dreischritt:

1. Explore
      ↓
2. Plan
      ↓
3. Implement
      ↓
4. Verify

1. Explore

„Analysiere die bestehende Authentifizierungsarchitektur. Noch keine Änderungen vornehmen.“

2. Plan

„Erstelle einen Implementierungsplan für die gewünschte Änderung. Nenne betroffene Dateien, Risiken und notwendige Tests.“

3. Implement

„Setze den Plan um.“

4. Verify

„Führe die relevanten Tests, Typechecks und Builds aus. Behebe Fehler und wiederhole die Prüfung.“

Dieser Ablauf reduziert Fehlentscheidungen, weil der Agent nicht gleichzeitig Codebase verstehen und implementieren muss.

Anthropic empfiehlt ebenfalls, bei komplexeren Aufgaben zunächst zu explorieren und zu planen. OpenAI beschreibt für Codex einen vergleichbaren Ask-Mode → Code-Mode-Workflow.

IV. Die wichtigste Regel: Der Agent muss seine Arbeit überprüfen können

Das ist wahrscheinlich der wichtigste Tipp für Agentic Coding überhaupt.

Ein Agent kann Code schreiben, der plausibel aussieht und trotzdem falsch ist.

Deshalb solltest Du nicht nur sagen:

„Implementiere Feature X.“

Sondern:

„Implementiere Feature X und überprüfe anschließend die Implementierung mit Tests, Typecheck und Build.“

Noch besser:

„Die Aufgabe ist erst abgeschlossen, wenn alle folgenden Kriterien erfüllt sind: ...“

Anthropic bezeichnet die Möglichkeit zur Selbstüberprüfung als den wirkungsvollsten Hebel beim Agentic Coding. Tests, Screenshots und erwartete Ausgaben geben dem Agenten eine Feedback-Schleife.

V. Definiere eine klare Definition of Done

Eine gute Aufgabe endet nicht mit:

„Code ist geschrieben.“

Sondern mit:

„Diese Bedingungen müssen erfüllt sein.“

Zum Beispiel:

Definition of Done

- Feature X funktioniert
- TypeScript enthält keine Fehler
- bestehende Tests bleiben grün
- neue Funktionalität besitzt Tests
- keine bestehende API wird unnötig verändert
- npm run lint läuft erfolgreich
- npm run build läuft erfolgreich

Das verändert das Verhalten des Agenten erheblich.

Denn plötzlich hat er ein messbares Ziel.

VI. Gib dem Agenten echte Tests statt nur Beschreibungen

„Validiere die E-Mail-Adresse“ ist relativ abstrakt.

Besser:

user@example.com → gültig
john@test.de → gültig
invalid → ungültig
user@ → ungültig
@test.de → ungültig

Damit kann der Agent seine Implementierung selbst testen.

Noch besser ist ein vorhandenes Test-Framework:

Implementiere die Funktion.
Schreibe Tests für die genannten Fälle.
Führe die Tests aus.
Behebe Fehler.

So entsteht eine Feedback-Schleife:

Aufgabe
  ↓
Agent implementiert
  ↓
Test
  ↓
Fehler
  ↓
Agent korrigiert
  ↓
Test
  ↓
Erfolg

Genau diese Schleife macht Agentic Coding leistungsfähig.

VII. Bei UI immer visuell überprüfen

Frontend-Entwicklung ist ein Sonderfall.

Ein Typecheck kann erfolgreich sein, obwohl das UI schlecht aussieht.

Deshalb sollte ein Agent bei UI-Aufgaben möglichst:

1. implementieren

2. Anwendung starten

3. Browser öffnen

4. Screenshot erstellen

5. Screenshot mit Vorgabe vergleichen

6. Abweichungen erkennen

7. korrigieren

8. erneut prüfen

Statt:

„Mach das Dashboard schöner.“

besser:

„Setze dieses Design um. Prüfe anschließend die Darstellung bei 390px, 768px und 1440px. Vergleiche die Ergebnisse mit dem Ausgangsdesign und korrigiere Abweichungen.“

Gerade für React-/Next.js-Projekte ist das ein großer Produktivitätsgewinn.

Anthropic empfiehlt explizit Screenshots und visuelle Vergleiche als Teil der Verifikation von UI-Änderungen.

VIII. Baue eine gute Projektanleitung

Coding Agents müssen Dinge wissen, die sie nicht zuverlässig aus dem Code ableiten können.

Zum Beispiel:

• verwendete Package Manager

• Build-Befehle

• Test-Befehle

• Architekturregeln

• wichtige Verzeichnisse

• Coding-Konventionen

• bekannte Fallstricke

• Deployment-Regeln

• wichtige technische Entscheidungen

Dafür eignen sich Dateien wie:

AGENTS.md
CLAUDE.md

je nach verwendetem Agenten.

OpenAI empfiehlt beispielsweise AGENTS.md für projektspezifischen Kontext. Claude Code nutzt CLAUDE.md. (OpenAI)

Aber: Nicht alles hineinschreiben

Eine schlechte Agentenanweisung kann mehrere hundert Zeilen lang sein.

Das ist kontraproduktiv.

Anthropic empfiehlt ausdrücklich, diese Dateien kurz zu halten und nur Informationen aufzunehmen, deren Fehlen tatsächlich zu Fehlern führt.

Eine gute Regel lautet:

Was kann der Agent aus dem Code herausfinden, muss nicht in die Projektanweisung.

IX. Kontext ist wichtiger als Prompt Engineering

Viele Entwickler versuchen, den perfekten Prompt zu schreiben.

Bei Agentic Coding ist aber oft etwas anderes wichtiger:

der richtige Kontext.

Der Agent braucht beispielsweise:

• relevante Dateien

• bestehende Architektur

• Tests

• Fehlermeldungen

• Screenshots

• API-Dokumentation

• Produktanforderungen

Ein schlechter Prompt mit gutem Kontext kann funktionieren.

Ein perfekter Prompt ohne relevanten Kontext oft nicht.

Deshalb:

Nicht möglichst viel Kontext geben. Sondern möglichst relevanten Kontext.

OpenAI empfiehlt ebenfalls schlanke Prompts und nur die Werkzeuge und Informationen bereitzustellen, die für die Aufgabe relevant sind.

X. Vermeide riesige Aufgaben

Ein Agent kann inzwischen erstaunlich große Aufgaben erledigen.

Das bedeutet aber nicht, dass Du ihm gleich ein komplettes Produkt übergeben solltest.

Schlecht:

„Baue die komplette SaaS-Anwendung.“

Besser:

1. Erstelle Datenmodell
2. Implementiere Authentifizierung
3. Implementiere Dashboard
4. Implementiere Kernfunktion
5. Implementiere Abrechnung
6. Schreibe Tests
7. Integriere alles

Noch besser:

Feature
  ↓
Plan
  ↓
Implementierung
  ↓
Test
  ↓
Review
  ↓
nächstes Feature

OpenAI empfiehlt für Codex aktuell besonders Aufgaben, die ungefähr einer Stunde Arbeit oder einigen hundert Zeilen Code entsprechen.

Mit leistungsfähigeren Modellen verschiebt sich diese Grenze zwar nach oben. Das Prinzip bleibt trotzdem sinnvoll:

Teile nach sinnvollen fachlichen Einheiten auf.

XI. Gib dem Agenten nicht zu früh zu viel Autonomie

Autonomie ist ein Vorteil.

Aber:

Autonomie × falsche Richtung = schneller falscher Code.

Bei unbekannten Codebases ist deshalb folgende Reihenfolge sinnvoll:

Lesen
 ↓
Verstehen
 ↓
Plan
 ↓
Freigabe
 ↓
Implementieren
 ↓
Testen

Bei einfachen Aufgaben kannst Du dagegen direkt delegieren:

Task
 ↓
Agent
 ↓
Test

Die Kunst besteht darin, die richtige Autonomiestufe für die Aufgabe zu wählen.

XII. Verwende Git als Sicherheitsnetz

Agentic Coding macht Git wichtiger, nicht unwichtiger.

Vor größeren Änderungen:

git status
git checkout -b feature/xyz

Danach:

git diff
git status

Bei riskanteren Änderungen sollte der Agent nicht direkt auf einem produktiven Branch arbeiten.

Noch besser:

Issue
 ↓
Branch
 ↓
Agent
 ↓
Tests
 ↓
Diff Review
 ↓
Pull Request
 ↓
Merge

Der Agent darf autonom arbeiten.

Die Integration bleibt kontrolliert.

XIII. Prüfe den Diff statt den Chat

Ein häufiger Fehler:

Der Entwickler liest 200 Nachrichten Agenten-Output und denkt:

„Sieht gut aus.“

Entscheidend ist aber:

Was wurde tatsächlich verändert?

Deshalb:

git diff

prüfen.

Achte insbesondere auf:

• unerwartete Dateien

• unnötige Refactorings

• API-Änderungen

• entfernte Validierungen

• Sicherheitsprobleme

• neue Dependencies

• Änderungen außerhalb des Scopes

Der Chat erklärt Dir, was der Agent behauptet getan zu haben.

Der Diff zeigt Dir, was tatsächlich passiert ist.

XIV. Begrenze den Scope

Ein Agent neigt dazu, angrenzende Probleme zu entdecken.

Das kann hilfreich sein.

Es kann aber auch dazu führen, dass aus:

„Fix Button“

plötzlich wird:

„Ich habe 14 Komponenten refaktoriert.“

Definiere deshalb Grenzen:

„Ändere nur die für das Feature notwendigen Dateien. Keine allgemeine Refaktorierung.“

Oder:

„Wenn Du weitere Probleme findest, liste sie auf. Behebe sie nicht automatisch.“

Das ist besonders wichtig in großen Codebases.

XV. Nutze unterschiedliche Agenten für unterschiedliche Aufgaben

Du musst nicht jedem Agenten dieselbe Arbeit geben.

Ein sinnvoller Workflow kann beispielsweise so aussehen:

Der entscheidende Gedanke:

Der beste Coding Agent ist aufgabenabhängig.

XVI. Nutze Subagents für Recherche

Ein Agent sollte nicht immer selbst jede Frage beantworten.

Bei größeren Aufgaben kannst Du Teilprobleme auslagern:

Hauptagent
   │
   ├── Agent: Architektur untersuchen
   ├── Agent: Tests analysieren
   ├── Agent: Security prüfen
   └── Agent: ähnliche Implementierungen suchen

Der Hauptagent erhält anschließend die Ergebnisse.

Das reduziert den Kontextdruck und ermöglicht parallele Untersuchungen.

Claude Code unterstützt beispielsweise explizit Subagents für solche Aufgaben. (Claude)

XVII. Nutze MCP gezielt

MCP kann aus einem Coding Agent einen wesentlich mächtigeren Arbeitsassistenten machen.

Der Agent kann dadurch beispielsweise auf:

• Datenbanken

• GitHub

• Browser

• Dokumentation

• Tickets

• APIs

• Monitoring

• Design-Systeme

zugreifen.

Aber:

Nicht jedes verfügbare Tool sollte automatisch verfügbar sein.

Je mehr irrelevante Tools vorhanden sind, desto größer wird der Kontext und desto schwerer wird die Tool-Auswahl.

OpenAI empfiehlt ebenfalls, nur für die jeweilige Aufgabe relevante Tools bereitzustellen. (OpenAI Developers)

XVIII. Automatisiere wiederkehrende Prüfungen

Wenn Du immer wieder dasselbe überprüfst, sollte der Agent diese Prüfung selbst durchführen können.

Beispiel:

Implementierung
 ↓
npm run typecheck
 ↓
npm run lint
 ↓
npm test
 ↓
npm run build

Noch besser:

Agent
 ↓
Änderung
 ↓
automatischer Verification Loop
 ↓
Fehler?
 ├─ Ja → korrigieren
 └─ Nein → fertig

Anthropic beschreibt genau dieses Prinzip als Verification Loop und zeigt, wie man manuelle Prüfungen in wiederverwendbare Agenten-Workflows überführen kann. (Claude)

XIX. Lass den Agenten Fehler selbst untersuchen

Wenn ein Build fehlschlägt, solltest Du nicht sofort selbst eingreifen.

Statt:

„Der Build funktioniert nicht.“

besser:

„Der Build ist fehlgeschlagen. Analysiere die Ursache. Behebe die Root Cause und führe den Build anschließend erneut aus. Unterdrücke den Fehler nicht.“

Der Unterschied zwischen Symptom beseitigen und Ursache beheben ist beim Agentic Coding besonders wichtig.

XX. Starte nach wiederholten Fehlversuchen neu

Ein überraschend wichtiger Tipp:

Wenn ein Agent zweimal oder dreimal in die falsche Richtung läuft, solltest Du nicht endlos weiterkorrigieren.

Warum?

Der bisherige Kontext enthält dann:

• falsche Annahmen

• gescheiterte Lösungsversuche

• widersprüchliche Anweisungen

• unnötige Details

Dadurch wird der Agent nicht unbedingt besser.

Besser:

Stop
 ↓
Zusammenfassung des Problems
 ↓
neuer Kontext
 ↓
neuer Plan
 ↓
neuer Versuch

Anthropic empfiehlt genau dieses Vorgehen nach wiederholten Fehlversuchen. (Claude)

XXI. Vermeide den „Kitchen-Sink Prompt“

Ein Prompt wie:

„Baue Feature X, behebe außerdem den Login-Bug, optimiere die Performance, aktualisiere die Dokumentation und schau noch nach dem alten API-Problem.“

ist gefährlich.

Der Agent verliert den Fokus.

Besser:

Task 1 → Feature X
Task 2 → Login Bug
Task 3 → Performance
Task 4 → Dokumentation

Oder bewusst mehrere unabhängige Agenten:

Agent A → Feature
Agent B → Bug
Agent C → Analyse

XXII. Verwende Prompts mit fünf Bausteinen

Für komplexere Aufgaben funktioniert dieses Schema sehr gut:

1. Ziel

Was soll entstehen?

2. Kontext

Was muss der Agent wissen?

3. Constraints

Was darf er nicht verändern?

4. Erfolgskriterien

Woran erkennt er, dass die Aufgabe erledigt ist?

5. Verification

Wie soll er seine Arbeit überprüfen?

Beispiel:

Ziel:
Implementiere eine Filterfunktion für das Dashboard.

Kontext:
Das Dashboard verwendet React Server Components.
Die bestehenden Filter befinden sich in components/filters.

Constraints:
Keine neue Dependency.
Bestehende API nicht verändern.

Erfolgskriterien:
- Filter funktioniert für alle vorhandenen Kategorien.
- URL enthält den aktuellen Filter.
- Navigation funktioniert ohne Full Page Reload.

Verification:
- Unit Tests ausführen.
- Typecheck ausführen.
- relevante E2E-Tests ausführen.
- Build ausführen.

Das ist wesentlich robuster als ein langer „Superprompt“.

XXIII. Weniger Prompting kann besser sein

Eine wichtige Entwicklung bei modernen Coding Agents:

Mehr Instruktionen bedeuten nicht automatisch bessere Ergebnisse.

OpenAI berichtet bei eigenen Coding-Agent-Evaluierungen, dass schlankere Prompts in bestimmten Setups sowohl die Leistung verbessern als auch Tokenverbrauch und Kosten reduzieren konnten. (OpenAI Developers)

Deshalb:

Schreibe nicht alles vor, was das Modell ohnehin zuverlässig kann.

Stattdessen solltest Du vor allem festlegen:

• Ziel

• wichtige Constraints

• Erfolgskriterien

• Sicherheitsgrenzen

• relevante Architekturentscheidungen

• Stop-Bedingungen

XXIV. Agentic Coding braucht mehr Engineering, nicht weniger

Das klingt zunächst paradox.

Wenn der Agent mehr Arbeit übernimmt, wird der Entwickler nicht überflüssig.

Seine Aufgaben verschieben sich.

Früher

Probleme verstehen
 ↓
Lösung entwerfen
 ↓
Code schreiben
 ↓
Debugging
 ↓
Tests

Mit Agentic Coding

Problem verstehen
 ↓
Aufgabe spezifizieren
 ↓
Agent steuern
 ↓
Architektur beurteilen
 ↓
Ergebnis überprüfen
 ↓
Agent korrigieren
 ↓
Code reviewen

Der Entwickler wird stärker zum:

Architekten + Reviewer + Orchestrator.

Das macht grundlegende Software-Engineering-Kenntnisse sogar wichtiger.

XXV. Die 10 wichtigsten Regeln als Kurzfassung

Wenn Du nur zehn Regeln mitnehmen möchtest:

1. Definiere das Ziel statt jeden Arbeitsschritt.

2. Lass große Aufgaben zuerst analysieren und planen.

3. Teile große Features in sinnvolle Einheiten.

4. Gib dem Agenten klare Erfolgskriterien.

5. Lass ihn seine Arbeit selbst testen.

6. Prüfe UI-Änderungen visuell.

7. Halte AGENTS.md / CLAUDE.md kurz und relevant.

8. Begrenze Scope und Berechtigungen.

9. Prüfe immer Diff und Tests statt nur den Agenten-Output.

10. Wenn der Agent mehrfach falsch liegt: Kontext bereinigen und neu starten.

XXVI. Der ideale Agentic-Coding-Workflow

Für anspruchsvolle Features würde ich heute diesen Ablauf empfehlen:

                 ANFORDERUNG
                      │
                      ▼
                ┌───────────┐
                │  EXPLORE  │
                └─────┬─────┘
                      │
                      ▼
                ┌───────────┐
                │   PLAN    │
                └─────┬─────┘
                      │
                Review / Freigabe
                      │
                      ▼
                ┌───────────┐
                │ IMPLEMENT │
                └─────┬─────┘
                      │
                      ▼
                ┌───────────┐
                │   TEST    │
                └─────┬─────┘
                      │
                 Fehler?
                 /     \
               Ja       Nein
               │          │
               ▼          ▼
           Korrigieren   REVIEW
               │          │
               └────┐     │
                    ▼     ▼
                 VERIFY
                    │
                    ▼
                  DIFF
                    │
                    ▼
                    PR

Das Entscheidende daran ist der geschlossene Kreislauf:

Aufgabe → Agent → Ergebnis → Prüfung → Feedback → Verbesserung

Genau daraus entsteht der Produktivitätsvorteil von Agentic Coding.

XXVII. Das wichtigste Prinzip

Agentic Coding wird oft als bessere Form von „AI Coding“ verstanden.

Das greift zu kurz.

Der eigentliche Fortschritt liegt darin, dass der Entwickler nicht mehr primär Code produziert, sondern Arbeit spezifiziert und überprüft.

Ein schwacher Workflow lautet:

„Schreib Code.“

Ein guter Workflow lautet:

„Hier ist das Problem. Das ist der relevante Kontext. Das darfst Du nicht verändern. Daran erkennst Du eine erfolgreiche Lösung. Implementiere es, überprüfe Deine Arbeit und korrigiere Fehler selbst.“

Der Unterschied liegt nicht nur im Prompt.

Er liegt im gesamten Entwicklungsprozess.

Die wichtigste Fähigkeit beim Agentic Coding ist deshalb nicht Prompt Engineering. Es ist, gute Aufgaben zu formulieren und eine zuverlässige Feedback- und Verifikationsschleife zu bauen.