Die 5 Stufen des Agentic Coding
KI-gestützte Softwareentwicklung ist eine erlernbare Fähigkeit — so baust du sie systematisch auf.
Der Inhalt dieses Artikels ist auch als Erklär-Video verfügbar (Bild-Link führt zu YouTube).
Seit November 2025 hat sich in der KI-gestützten Softwareentwicklung etwas fundamental verschoben. Es ist inzwischen tatsächlich möglich, produktiven Code für große Systeme zu entwickeln, ohne selbst eine einzige Zeile zu schreiben. Boris Cherny, Development Lead von Claude Code, einem der führenden Coding Agents, hat öffentlich gesagt, dass er seit November 2025 selbst keinen Code mehr schreibt. Stattdessen werden Features routinemäßig vollständig mit KI-Unterstützung entwickelt.
Das klingt erstaunlich — und die häufigste Reaktion, wenn ich das Kolleginnen und Kollegen erzähle, ist: „Bei mir kommt da doch meistens nur Müll raus. Wie geht das?“
Die ehrliche Antwort: Wer erwartet, einfach ein paar Ideen hinzuschreiben und dann läuft die KI los und baut etwas Brauchbares — der hat Vibe Coding vor Augen, nicht Agentic Coding. Der Unterschied ist erheblich.
Was ist Agentic Coding?
Agentic Coding ist kein Software-Feature, das man herunterladen kann. Es ist eine Fähigkeit — eine komplexe, zusammengesetzte Fähigkeit, die man nicht über Nacht erwirbt. Sie besteht aus eigenem konzeptionellen Verständnis, aus dem sicheren Umgang mit Tools, Prompts und Konfigurationen, aus entwickelten Workflows und Herangehensweisen und — unerlässlich — aus eigener Erfahrung.
Es gibt inzwischen verschiedene Frameworks und Modelle, die versuchen, diese Fähigkeit zu strukturieren: fertige Frameworks wie die BMAD-Methode™ (Breakthrough Method of Agile AI-Driven Development) oder das GitHub Spec Kit. Phasenmodelle wie Dan Shapiros „Five Levels of Agentic Coding“ oder Simon Scrapes „Seven Phases of Pilot Code Mastery“.
Das Modell, das für mich persönlich am überzeugendsten ist und das inzwischen meine zentrale Referenz geworden ist, wenn ich über Agentic Coding nachdenke oder mich mit anderen darüber unterhalte, ist die „Agentic-Coding-Leiter“ von Jo Van Eyck. Was sie auszeichnet: Die Stufen sind nicht abstrakt — sie sind praktisch erreichbar, wenn man die vorherige Stufe wirklich gemeistert hat. Und jede Stufe verändert die Art, wie man arbeitet.
Lesetipps: KI im Arbeitsalltag
Die KI-Leadership-Crew: Wie mir virtuelle KI-Crews Feedback und neue Impulse geben (von Leiv Braun)
Von Hype zu Hebel: KI braucht keine neuen Methoden – sie braucht bewährte agile Prinzipien (von Fabian Biebl)
KI für Scrum Master: Die Kunst des guten Prompts (von Bastian Kröckel)
Die Leiter: Sprosse für Sprosse
Die Metapher der Leiter ist bewusst gewählt. Man steigt sie Sprosse für Sprosse hoch. Man lässt keine Stufe aus. Jede Stufe stellt eine neue Art zu arbeiten dar, erfordert neue Fähigkeiten, bringt neue Erfahrungen mit sich — und zeigt irgendwann ihre eigenen Grenzen. Genau diese Grenzen motivieren dann, den nächsten Schritt zu wagen.
Stufe 1: Chatbot
Ein separates LLM als Hilfsmittel neben dem eigenen Editor.
Code wird selbst geschrieben, KI liefert Ideen und Snippets per Copy-Paste.
Stufe 2: Enhanced Autocomplete
Das LLM ist direkt in den Editor integriert. Es schlägt Zeilen, Blöcke und Änderungen vor — man akzeptiert oder verwirft.
Stufe 3: Agentic Coding „In the Loop“
Man übergibt dem Agent eine Aufgabe und bleibt eng dabei — beobachtend, korrigierend, eingreifend.
Stufe 4: Agentic Coding „On the Loop“
Agents laufen parallel und weitgehend autonom. Man prüft Ergebnisse asynchron, delegiert statt zu beobachten.
Stufe 5: Multi Agent Orchestration
Man baut und steuert ein System, in dem Agents sich selbst koordinieren. Man selbst gibt nur noch Richtung, Constraints und Architektur vor — keine Einzelfeatures mehr.
Stufe 1: Chatbot
Die erste Stufe kennen die meisten: Man hat einen separaten Chatbot — ChatGPT, Claude.ai oder ähnliches — neben dem eigenen Editor offen. Man fragt nach Ideen, nach Lösungsansätzen, lässt sich Code-Snippets generieren und kopiert Brauchbares in die eigene IDE. Ähnlich wie früher Stack Overflow, nur mit generiertem statt kuratiertem Inhalt.
Was auf dieser Stufe wirklich gelernt wird, ist mehr, als es zunächst scheint: Wie funktioniert ein LLM? Was ist Kontext, und warum ist er so entscheidend? Wie prompte ich so, dass ich konsistent brauchbare Ergebnisse bekomme? Wie erkenne ich, ob der Output korrekt ist — oder nur überzeugend klingt?
Diese Grundlagen des Prompt Engineerings und des Kontext-Verständnisses sind keine Kleinigkeit. Wer sie nicht verinnerlicht hat, wird auf den höheren Stufen immer wieder scheitern.
Limit dieser Stufe:
Das ständige Hin-und-Her-Kopieren. Die KI ist zu weit weg vom Code.
Stufe 2: Enhanced Autocomplete
Der nächste Schritt: Das LLM zieht in den Editor ein. Tools wie Cursor ermöglichen, dass die KI direkt im eigenen Workflow sitzt — sie schlägt die nächste Zeile vor, vervollständigt Funktionen, setzt Kommentare und Pseudo-Code in echten Code um.
Man schreibt z.B. einen Kommentar wie „Parse das JSON-Input und extrahiere die User-ID“ — und die KI setzt das um. Man nimmt den Vorschlag an oder verwirft ihn. Das Tempo steigt spürbar.
Was auf dieser Stufe gelernt wird: wie man den eigenen Workflow so anpasst, dass KI-Unterstützung nahtlos integriert ist — kein separater Schritt mehr, sondern natürlicher Teil des Codings. Und: Wie kann ich die KI dabei unterstützen, besseren Code zu schreiben? Starke Typen, eingebundene Dokumentation, klare Signaturen — all das verbessert die Qualität der Vorschläge erheblich. Wer das verstanden hat, nutzt KI nicht passiv, sondern steuert sie aktiv.
Wichtig ist auch, sich nicht anzugewöhnen, Vorschläge blind zu akzeptieren. Kritisches Bewerten gehört zu dieser Stufe dazu.
Limit dieser Stufe:
Jede einzelne Zeile muss durch die eigenen Hände. Die eigene Aufmerksamkeit ist der Flaschenhals.
Stufe 3: Agentic Coding „In the Loop“
Hier verändert sich die Arbeitsweise grundlegend. Man übergibt dem Agent ein Feature oder eine größere Aufgabe — und er erledigt sie. Der Agent konzipiert, schreibt Code, schreibt Tests, führt sie aus, korrigiert sich. Typische Tools auf dieser Stufe: Claude Code, Cursor im Agent Mode, OpenAI Codex.
Man schreibt selbst keinen Code mehr. Man gibt Aufgaben. Und man bleibt dabei — ganz eng, beobachtend, korrigierend, eingreifend. Daher: in the loop.
Ein wesentlicher Teil von In-the-Loop-Coding mit Agent ist: Man wird auch beobachten, wie der Agent scheitert.
Genau das ist der Lernstoff dieser Stufe: Woran scheitert der Agent? Was braucht er, um erfolgreich zu sein? Drei Kernfähigkeiten greifen dabei ineinander:
Wegweiser entwickeln
Man kann sich vorstellen, dass der Agent am Steuer eines Autos sitzt. Damit er dort ankommt, wo wir ihn haben wollen, ist es wichtig, eindeutige Verkehrsschilder und Wegweiser aufzustellen.
- Aufgaben richtig formulieren — Größe, Granularität, Vorgehensweise
- Rollen, Kontext und Regeln mitgeben
- Skills schreiben, Agents definieren, Slash Commands bereitstellen
- Konnektoren zu externer Software aufbauen (MCP Server, Custom CLI Tools)
Leitplanken setzen
Grüne Tests reichen nicht. Das Feature muss vollständig, sicher und architekturkonform sein.
- Harte Checks, die dem Agent Feedback geben, wenn er Regeln bricht
- Hooks, automatische Reviews, automatisierte Tests an kritischen Stellen
- Sicherheitsrichtlinien und Codequalität als prüfbare Kriterien
Ownership behalten
Man schreibt nicht — aber man verantwortet.
- Ein mentales Modell der entstehenden Lösung behalten
- Auf unterschiedlichen Verständnisebenen arbeiten können
- Die zentrale Frage: Wie verantworte ich Code, den ich nicht selbst geschrieben habe?
Diese Stufe dauert typischerweise länger als die ersten beiden. Das System muss aufgebaut werden, das Tooling muss verstanden und zusammengesteckt werden — und das braucht viele Feedbackschleifen.
Limit dieser Stufe:
Man muss trotzdem die ganze Zeit dabei sein. Die eigene Aufmerksamkeit bleibt das Limit.
Stufe 4: Agentic Coding „On the Loop“
Das ist die Stufe, die Boris Cherny beschreibt, wenn er sagt, dass er morgens mehrere Agents startet und dann in Ruhe frühstücken geht. Man startet eine Aufgabe — und widmet sich dann etwas anderem. Die Ergebnisse werden asynchron geprüft. Mehrere Agents laufen parallel.
Die Devise heißt: Trust but verify.
Man macht nicht mehr von allem ein Review. Man entwickelt eine Intuition: Wo lohnt es sich hinzuschauen? Wo muss man auf die Detailebene gehen, weil es ein kritischer Knackpunkt ist? Wo reicht die Architektur-Ebene?
Auf dieser Stufe werden mehrere Fähigkeiten gleichzeitig ausgebaut:
Aufgabendesign
- Aufgaben so formulieren, dass die KI sie ohne Rückfragen lösen kann
- Aufgaben so schneiden, dass verschiedene Agents sie parallel und unabhängig umsetzen können
- Den relevanten Kontext vollständig mitliefern — man ist ja nicht mehr live verfügbar
Parallelisierung
- Mehrere Agents gleichzeitig managen — wie viele kann man tatsächlich im Kopf behalten? Drei? Fünf? Zehn?
- Den eigenen Workflow grundlegend umstrukturieren
- Den neu entstandenen Freiraum sinnvoll nutzen
Ownership ohne Authorship
Eine neue Situation für viele Entwicklerinnen und Entwickler — für Führungskräfte längst normal.
- Verantwortung für Ergebnisse übernehmen, die man nicht selbst erzeugt hat
- Den flexiblen Ebenenwechsel beherrschen: von der Architektur bis zum Detail
- Einen Agent Harness perfektionieren: Quality Gates, automatisierte Reviews, Monitoring für Loops und Wiederholungen
- Loslassen: Es muss nicht immer genau so gebaut werden, wie man es selbst gemacht hätte
Man beherrscht diese Stufe, wenn man Agents startet und sich guten Gewissens anderen Dingen widmen kann — wenn parallele Agents Routine sind und kein Stress mehr, und wenn man eine verlässliche Intuition dafür entwickelt hat, wo sich Probleme verbergen könnten.
Limit dieser Stufe:
Jedes Feature muss einzeln formuliert, gestartet und gereviewt werden. Der Flaschenhals ist jetzt die eigene kognitive Kapazität — und irgendwann stellt sich die Frage, ob auch diese Koordination an die KI delegiert werden kann.
Stufe 5: Multi Agent Orchestration
Auf Stufe 5 baut und steuert man ein System, in dem Agents sich selbst koordinieren. Als Mensch gibt man Richtung, Constraints und Architektur vor — keine Einzelaufgaben mehr. Das System erkennt eigenständig Aufgaben, teilt sie auf, führt sie aus, integriert Ergebnisse. Agents reviewen sich gegenseitig.
Was genau diese Stufe vollständig ausmacht, kristallisiert sich gerade erst heraus — wir alle lernen hier noch gemeinsam. Was sich abzeichnet:
- Multi-Agent-Systeme so entwerfen, dass sie sich selbst koordinieren
- Intent formulieren statt Aufgaben — Richtung geben statt Schritte vorgeben
- Constraints setzen, die das Gesamtsystem auf Kurs halten
- Eingreifen, ohne das System zu destabilisieren oder auf Stufe 3 zurückzufallen
- Mit emergentem Verhalten umgehen: Das System trifft Entscheidungen, die man nicht einzeln vorhergesehen hat — und das ist mal gut und mal problematisch
Spannung auf dieser Stufe:
Autonomie vs. Kontrolle. Wie viel kann man dem System überlassen? Wann muss man eingreifen?
Wo stehst du gerade?
Die fünf Stufen sind kein Wettbewerb. Sie sind ein Navigationsmittel — eine Möglichkeit, ehrlich einzuschätzen, wo man steht, was fehlt und was der nächste sinnvolle Schritt ist. Besonders die Stufen 3, 4 und 5 sind ein aktives Lernfeld, das sich gerade in Echtzeit weiterentwickelt.
Was sind deine Erfahrungen? Wo stößt du an Grenzen? Wo hast du Durchbrüche erlebt?
Ich freue mich sehr, wenn du deine Perspektive teilst — wir alle lernen hier noch. Lass gerne deine Gedanken im Kommentar da oder komm über eine persönliche Nachricht auf mich zu.
