Agentic Coding
Agentic Coding: wenn die KI den Code schreibt, testet und wieder verwirft, während du Kaffee holst.
Beim Vibecoding tippst du einen Prompt und die KI schlägt Code vor. Beim Context Engineering hast du gelernt, der KI strukturierte Informationen zu liefern, damit ihre Vorschläge treffsicher werden. Jetzt kommt der letzte Schritt: Du beschreibst ein Ziel, und die KI erledigt den Rest — Codebase lesen, Dateien schreiben, Tests ausführen, eigene Fehler korrigieren und das Ergebnis committen. Das ist Agentic Coding: eine KI, die nicht auf deine nächste Anweisung wartet, sondern ein Ziel autonom verfolgt. Dieser Artikel zeigt dir, wie der Agent Loop funktioniert, warum Tests der zuverlässigste Aufpasser des Agenten sind und wie du das richtige Maß an menschlicher Kontrolle für jede Situation wählst.
Der Agent Loop — Wie autonomes Coding funktioniert
Was unterscheidet einen Coding-Agenten fundamental von der Autovervollständigung, die du aus deinem Editor kennst? Ein Autocomplete-System sagt das wahrscheinlichste nächste Token vorher — es reagiert auf deine Eingabe, Zeile für Zeile, ohne eigenes Ziel. Ein Coding-Agent hingegen bekommt eine Aufgabe und arbeitet selbstständig an deren Lösung. Der Mechanismus dahinter ist der Agent Loop, ein sich selbst korrigierender Kreislauf aus fünf Phasen.
Definition
Agent Loop
Analogie
Beispiel
Definition
Wartet auf deine Eingabe und schlägt die nächsten Zeilen vor. Du steuerst, die KI assistiert. Aufwand: hoch (du schreibst und prüfst jeden Vorschlag).
Bekommt ein Ziel und arbeitet selbstständig darauf hin. Liest die Codebase, plant Änderungen, schreibt Code, führt Tests aus und korrigiert sich selbst. Aufwand: gering (du spezifizierst und reviewst das Ergebnis).
- 1. ObserveCodebase lesen, Aufgabe verstehen, relevante Dateien identifizieren
- 2. PlanÄnderungen entwerfen, Dateien und Tests planen
- 3. ActCode schreiben, Dateien erstellen, Terminal-Befehle ausführen
- 4. EvaluateTests ausführen, Compiler-Output und Linter prüfen
- 5. IterateBei Fehlern: analysieren, korrigieren, neuer Durchlauf ab Observe
Ein konkretes Beispiel: Du gibst deinem Terminal-Agenten die Anweisung:
"Baue eine Login-Sperre ein: Nach drei falschen Passwörtern soll sich der Nutzer 15 Minuten lang nicht einloggen können."
Der Agent liest die Projektstruktur und findet die Login-Datei. Er plant einen Fehlversuch-Zähler und einen Timer. Er schreibt den Code für die Sperre und erstellt drei Testfälle (ein falsches Passwort, drei falsche Passwörter, erneuter Versuch nach 15 Minuten). Beim Testlauf schlägt der dritte Test fehl — die Sperre wird nicht aufgehoben. Der Agent findet den Fehler (der Timer setzt den Zähler nicht zurück), korrigiert ihn und startet die Tests erneut. Alle drei Tests sind grün. Er committet die Änderungen. Dein Aufwand: ein Satz Spezifikation plus fünf Minuten Review.
Merke
Kernunterschied
Der fundamentale Unterschied ist Intentionalität: Ein Autocomplete-System sagt das wahrscheinlichste nächste Token vorher, ein Agent arbeitet von einem definierten Ziel rückwärts. Diese Zielorientierung macht den Agent Loop zum entscheidenden Mechanismus hinter autonomem Coding.
Interaktiv: Der Agent Loop als Animation
Der Agent Loop ist ein sich selbst korrigierender Kreislauf: Observe → Plan → Act → Evaluate → Iterate. Klicke auf Play und verfolge, wie der Agent von Phase zu Phase arbeitet — und bei Fehlern zum Anfang zurückkehrt.
Der 5-Phasen-Kreislauf als animiertes Diagramm. Jede Phase wird nacheinander aktiviert — inklusive der Rückkopplungsschleife von Iterate zurück zu Observe.
Klicke auf "Abspielen", um den Ablauf Schritt für Schritt zu sehen.
Der Agent Loop ist kein linearer Prozess. Er wiederholt sich, bis alle Tests bestehen oder der Agent feststellt, dass er nicht weiterkommt. Diese iterative Selbstkorrektur ist der Kern autonomen Codings.
Tests als Aufsicht — Warum der Red-Green-Loop zählt
Warum sind Tests für einen Coding-Agenten noch wichtiger als für einen menschlichen Entwickler? Ein menschlicher Entwickler hat Intuition und Domänenwissen — er merkt oft, wenn etwas nicht stimmt, auch ohne formalen Test. Ein Agent hat nur die Feedback-Schleife: Wenn kein Test fehlschlägt, nimmt der Agent an, dass alles funktioniert. Tests sind deshalb nicht nur Qualitätssicherung, sondern der primäre Aufsichtsmechanismus.
Definition
Test-Driven Generation
Analogie
Beispiel
Definition
Der Prozess folgt einer Spec-to-Code-Pipeline: Der Agent liest eine Spezifikation und generiert daraus Code und Tests. Die Tests durchlaufen dann den Red-Green-Loop — bei Fehlern analysiert der Agent den Output, passt den Code an und testet erneut. Entscheidend dabei: Wenn du dem Agenten zuerst Tests gibst und dann die Anweisung, Code zu schreiben, der diese Tests besteht, bekommst du messbar bessere Ergebnisse als mit vagen natürlichsprachlichen Beschreibungen. Tests liefern eindeutige, maschinell prüfbare Akzeptanzkriterien.
Der SWE-bench Benchmark demonstriert dieses Prinzip im großen Maßstab. Er umfasst 2.294 echte GitHub-Issues aus Produktions-Repositories, jeweils mit den zugehörigen Testfällen. Ein Agent bekommt nur den Issue-Text — keine Hinweise, keinen Lösungsweg. Er muss das Repository lesen, den Bug verstehen, einen Fix implementieren und die zugehörigen Tests bestehen.
Auf diesem vollständigen Satz kam der beste Eintrag der offiziellen Bestenliste Ende 2025 auf 52,6 %. Gebräuchlicher ist SWE-bench Verified, eine von Menschen geprüfte Auswahl von 500 Aufgaben. Dort melden Hersteller inzwischen über 90 %, doch der Wert gilt als ausgereizt: OpenAI berichtet seit Februar 2026 keine Verified-Ergebnisse mehr, weil Modelle Aufgaben samt Lösung schon aus dem Training kennen und manche Tests richtige Lösungen ablehnen. Empfohlen wird das schwerere SWE-bench Pro. In dessen unabhängiger Bestenliste löst das beste System rund 60 % der Aufgaben (Stand November 2026). Beim Rest findet der Agent die Ursache nicht, führt Regressionen ein oder produziert einen Fix, der das eigentliche Problem nicht behebt. Ich lese das so: Bei bekannten, gut abgegrenzten Aufgaben sind Agenten stark geworden, bei neuen und schweren scheitert noch ein großer Teil. Dafür bleibt menschliche Aufsicht unverzichtbar.
Devin: Der erste autonome KI-Software-Ingenieur
Der Anspruch: Softwareentwicklung vollständig einer KI zu übergeben. Am 12. März 2024 stellte Cognition Labs Devin vor – von der Firma vermarktet als „der erste KI-Software-Ingenieur“. Das System kann eigenständig planen, Repositories klonen, Code schreiben, debuggen, testen und sogar deployen. Auf dem anspruchsvollen SWE-Bench erreichte Devin 13,86% Erfolgsquote bei realen GitHub-Issues (gemessen auf einer Zufallsstichprobe von 570 der 2.294 Aufgaben) – ein gewaltiger Sprung gegenüber dem vorherigen Bestwert ohne Hilfestellung von 1,96%. Das Startup wurde in einer frühen Finanzierungsrunde mit rund 350 Millionen Dollar bewertet; im April 2024 folgte eine Runde über 175 Millionen Dollar bei rund 2 Milliarden Dollar Bewertung. Ein einmonatiger Praxistest von Answer.AI (veröffentlicht im Januar 2025) zeigte die Grenzen: Nur 3 von 20 Aufgaben wurden erfolgreich gelöst, oft mit unvorhersagbaren Ausfällen.
Achtung
Spezifikation entscheidet über Qualität
Ein Agent ohne klare Spezifikation ist wie eine Fabrik ohne Fertigungsauftrag — er wird etwas produzieren, aber wahrscheinlich nicht das, was du wolltest. Vage Anweisungen erzeugen vage Ergebnisse. Eine Kombination aus präziser Aufgabenbeschreibung und expliziten Tests ist der zuverlässigste Weg zu brauchbarem Output.
Human in the Loop — Dein Supervision Level wählen
Selbst der leistungsfähigste Agent braucht menschliche Aufsicht — die Frage ist nur, wie viel. Moderne Agentic-Coding-Tools implementieren ein Spektrum aus drei Supervision Levels. Die richtige Wahl hängt vom Risiko der Aufgabe ab.
Vollautonomer Modus
Der Agent erledigt alles selbstständig — vom Lesen der Codebase bis zum Commit. Geeignet für risikoarme Arbeit: Prototypen, Wegwerf-Scripts, interne Tools, bei denen ein Fehler in Minuten behoben ist.
Semi-autonomer Modus
Der Agent arbeitet frei für die meisten Operationen, pausiert aber an definierten Review-Punkten: Dateien schreiben, System-Befehle ausführen, Git-Push. Der Entwickler prüft Diffs und Architekturentscheidungen. Standard für Produktionscode.
Assistenz-Modus
Der Entwickler behält die volle Kontrolle. Der Agent hilft punktuell: eine Funktion generieren, einen Stack-Trace erklären, ein Refactoring vorschlagen. Jede Zeile wird manuell geprüft. Pflicht bei sicherheitskritischem Code und in regulierten Umgebungen.
Stell dir einen Kranführer auf einer Baustelle vor. Im vollautonomen Modus hat der Kran einen Autopiloten: Er liest den Bauplan, greift die richtigen Stahlträger und setzt sie ein. Das funktioniert für Routinearbeiten auf einer vertrauten Baustelle. Im semi-autonomen Modus folgt der Kranführer den Vorschlägen des Autopiloten, bestätigt aber jeden Hub: "Träger 7 an Position C-4 — bestätigen?" Er prüft Wind, Bodenstabilität und Nähe zu Arbeitern. Im Assistenz-Modus steuert der Kranführer den Kran manuell und fragt das System nur nach Gewichtsberechnungen. Wenn ein Kran neben einem Krankenhaus oder über einer öffentlichen Straße arbeitet, nutzt man immer den manuellen Modus — die Folgen eines Fehlers sind zu schwerwiegend für jeden Autopiloten.
Moderne Tools setzen dieses Spektrum über Permission-Systeme um: Lesezugriffe geschehen stillschweigend, Schreibzugriffe erfordern Bestätigung und riskante Aktionen (Git Push, Datenbankmigrationen, npm install) verlangen explizite Freigabe. Neuere Tools kennen einen Mittelweg: Im Auto-Modus, bei Claude Code inzwischen der Start-Modus im Terminal, prüft ein zweites KI-Modell die Aktionen an deiner Stelle. Das spart Klicks, aber dann beaufsichtigt eine KI die KI.
Ein Entwicklungsteam arbeitet an einer Web-Applikation. Aufgabe 1: "Generiere einen Placeholder-Ladebildschirm für das interne Admin-Panel." Risiko: minimal — drei Mitarbeiter nutzen es, ein kaputter Ladebildschirm ist in Minuten repariert. Entscheidung: vollautonomer Modus. Aufgabe 2: "Refactore das Zahlungsmodul für eine neue Währung." Risiko: erheblich — betrifft alle Kunden und ihre Zahlungen. Entscheidung: semi-autonomer Modus mit Review jeder geänderten Datei. Aufgabe 3: "Aktualisiere die Auth-Middleware für FIDO2-Security-Keys." Risiko: kritisch — Auth-Fehler kompromittieren alle Nutzerkonten. Entscheidung: Assistenz-Modus, jede Zeile Auth-Logik wird manuell geprüft.
Die Branche setzt bereits Multi-Agent-Systeme ein, in denen ein Agent plant, ein zweiter implementiert, ein dritter reviewed und ein vierter testet — doch das Prinzip der Supervision bleibt dasselbe.
Claude Code (Anthropic): Agent für Terminal, IDE, Desktop-App und Browser, arbeitet direkt in deinem Projekt mit Permission-System für kontrollierte Autonomie. Codex CLI (OpenAI): vergleichbarer Terminal-Agent mit sandboxed Execution. Gemini CLI (Google): quelloffener Terminal-Agent. GitHub Copilot: neben der Autovervollständigung seit 2025 auch ein Coding-Agent, der Aufgaben selbstständig im Hintergrund abarbeitet. Devin (Cognition): als erster "KI-Software-Ingenieur" vermarktet, operiert in einer isolierten Cloud-Umgebung mit eigenem Browser und Terminal. Dazu kommen Open-Source-Alternativen wie Aider, OpenHands und SWE-agent. Wichtig: Die Tools ändern sich quartalsweise — die Prinzipien (Agent Loop, Tests, Supervision) bleiben stabil.
Auf dem schweren SWE-bench Pro scheitert selbst das beste System der unabhängigen Bestenliste noch an rund 40 % der Aufgaben, und ältere Benchmarks überschätzen Agenten, weil ihre Aufgaben samt Lösung im Training gelandet sind. Besonders problematisch sind unbekannte Codebases mit unkonventionellen Architekturen und undokumentierten Patterns. Halluzinationsrisiko besteht, wenn Agenten plausibel aussehenden Code erzeugen, der nicht existierende APIs oder erfundene Funktionssignaturen nutzt. Zusammengesetzte Aufgaben mit Abhängigkeiten zwischen Schritten haben Erfolgsquoten, die mit jedem Schritt exponentiell sinken. Die ehrliche Einschätzung: Agentic Coding ist ein Produktivitätsmultiplikator für gut spezifizierte Aufgaben, kein Ersatz für Entwickler-Urteilsvermögen.
Merke
Takeaways
- Ein Coding-Agent ist kein klügeres Autocomplete — er verfolgt ein Ziel durch einen sich selbst korrigierenden Kreislauf aus Beobachten, Planen, Handeln, Evaluieren und Iterieren. Deine Aufgabe verschiebt sich vom Codetippen zum Spezifizieren und Reviewen.
- Tests sind der Aufpasser des Agenten: Eine umfassende Test-Suite macht den Agenten zuverlässiger als jedes Prompt Engineering allein, weil Tests objektive, wiederholbare Validierung liefern. Ohne Tests bleibt der Agent blind für seine eigenen Fehler.
- Das richtige Supervision Level hängt vom Risiko ab: vollautonomer Modus für Prototypen, semi-autonomer Modus mit Review für Produktionscode, strikter Assistenz-Modus für sicherheitskritische Systeme. Auch die besten Agenten scheitern noch an einem großen Teil schwerer, realer Aufgaben — menschliche Aufsicht bleibt unverzichtbar.
Prüfen
Checkpoint: Agentic Coding
Kannst du das in eigenen Worten erklären? Hake ab, was sitzt.
0 von 3 sitzen
Prüfen
Quiz: Agentic Coding
Was passiert in der "Evaluate"-Phase des Agent Loop?
Wähle eine Antwort
1. Was passiert in der "Evaluate"-Phase des Agent Loop?
2. Warum liefert ein Agent mit expliziten Testfällen bessere Ergebnisse als mit einer vagen natürlichsprachlichen Beschreibung?
3. Ein Team muss ein Zahlungsmodul refactoren, das echte Kundentransaktionen in mehreren Währungen verarbeitet. Welches Supervision Level ist am besten geeignet?
4. Ein Agentic-Coding-Tool meldet "alle Tests bestanden" nach der Implementierung eines neuen Features. Ein Entwickler entdeckt beim Review, dass der Agent keinen Test für einen kritischen Grenzfall (leere Eingabe) geschrieben hat. Was zeigt das über die Beziehung zwischen Testabdeckung und Code-Korrektheit?
5. Dein Startup baut ein internes Dashboard für fünf Mitarbeiter. Der Agent soll eine neue Statistik-Seite hinzufügen. Wie konfigurierst du die Supervision?
6. Ein Agent hat einen Bug-Fix implementiert und meldet Erfolg. Bei der Analyse stellst du fest, dass der Agent den fehlschlagenden Test gelöscht hat, anstatt den Code zu reparieren. Was zeigt dieses Verhalten über die Grenzen testbasierter Supervision?