KI-Engineering-Kompetenzkarte: Einsatz von Coding-Agents

Eine zentrale Fähigkeit im KI-Engineering ist der Einsatz von Coding-Agents. Deine Fähigkeit, sie sowohl beim Schreiben von Code als auch bei Nicht-Code-Aufgaben wie der Datenanalyse oder der Verwaltung von Systemabläufen zu steuern, ermöglicht es dir, wesentlich mehr zu erreichen.

Das schnelle Entwicklungstempo von Coding-Agents bedeutet, dass auch diese Fähigkeit rasant evolviert – schneller als andere übergeordnete KI-Engineering-Fähigkeiten. Proprietäre Agents (wie Claude Code, Codex und Cursor) und offene Agents (wie OpenCode und Pi) machen durch Verbesserungen sowohl an der Steuerungsebene (Harness) als auch an den Modellen selbst große Fortschritte. Daher erfordert es einen kontinuierlichen Prozess des Experimentierens, Bauens und Lernens, um mit der Nutzung von Coding-Agents Schritt zu halten.

In Gesprächen mit Dutzenden von Top-KI-Ingenieuren und durch die Reflexion über den Einsatz von Coding-Agents in unserem eigenen Team haben wir einen konsistenten übergeordneten Workflow für die Softwareentwicklung mit ihnen identifiziert. Die wichtigsten Schritte sind:

• Planung. Dies umfasst (i) das Brainstorming, das Recherche, Experimente und das Verständnis der bestehenden Codebasis (falls vorhanden) beinhalten kann, und (ii) das Schreiben eines Lastenhefts (Spec), das Anforderungen, technisches Design und Architektur festhält, gefolgt von der Erstellung eines Ausführungsplans. Du solltest den Plan auch überprüfen, um wichtige Annahmen zu hinterfragen und auf Sicherheitslücken, Overengineering und andere Schwachstellen zu prüfen.
• Ausführung, bei der du baust, testest und verifizierst, mit der richtigen Balance zwischen Agentenautonomie und menschlicher Aufsicht. Dies beinhaltet (i) das Bauen der Software durch den Agenten mit einem kalibrierten Grad an Autonomie und (ii) die Verifizierung seiner Ausgabe durch automatisierte und/oder manuelle Prüfungen.
• Bereitstellung und Überwachung, bei der du (i) bereitstellst, möglicherweise gesteuert durch eine CI/CD-Pipeline oder zusätzliche manuelle Freigabeschritte, und (ii) Agents einsetzt, um Logs zu überwachen, Probleme aufzuzeigen sowie Verbesserungen vorzuschlagen und umzusetzen.

Dieser übergeordnete Workflow ähnelt dem, der typischerweise vor dem Aufkommen von Coding-Agents für die Softwareentwicklung verwendet wurde. Heute liegt der Fokus viel weniger auf dem Code selbst, sondern vielmehr auf der Entscheidung, was gebaut werden soll, dem Entwurf der Architektur, dem Schreiben des Lastenhefts und der Verifizierung der Ergebnisse.

Die Dauer der einzelnen Schritte kann zwischen Projekten stark variieren, und Schritte können auch ganz wegfallen. Zum Beispiel könnte das Lastenheft für einen Greenfield-Prototypen (von Grund auf neu gebaut) lose in einem schnell geschriebenen Prompt beschrieben sein, während das Lastenheft für ein bestehendes Brownfield-Projekt (mit vielen Nutzern) deutlich mehr Aufwand beim Schreiben und Verifizieren erfordern kann. Darüber hinaus ist der Workflow stark iterativ, und erfahrene Entwickler wissen, wann das Feedback aus einem späteren Schritt sie zurück zu einem früheren führen sollte. Wenn beispielsweise die Verifizierung fehlschlägt, wissen sie, wie sie den Agenten zum Neubau und zur Fehlerbehebung anleiten; oder wenn die Überwachung Probleme aufdeckt, wie sie Agents beauftragen, das System zu aktualisieren und neu bereitzustellen.

Um Coding-Agents in diesem Workflow effektiv einzusetzen, sind die wichtigsten Fähigkeiten:

• Den Workflow steuern
• Agentenautonomie ermöglichen
• Die Arbeit überprüfen
• Den Agenten und seine Umgebung anpassen
• Grundlagen der Coding-Agents

Den Workflow steuern. Du weißt, wie du jeden Schritt des oben beschriebenen Workflows navigierst. Dies beinhaltet die Entscheidung, wie viel menschlichen und wie viel Agentenaufwand du in jeden Schritt investierst und wann du zu einem früheren Schritt zurückkehren solltest, um zu iterieren. Es erfordert ein tiefes Verständnis der Abwägungen zwischen Geschwindigkeit, Kosten, technischem Risiko und menschlichem Aufwand, damit du entscheiden kannst, wie viel Vorab-Recherche und -Planung nötig ist, wann die menschliche Verantwortung für kritische Arbeiten erhalten bleiben sollte, wie die Architektur zu wählen ist, wie detailliert Planungsartefakte (wie ein Lastenheft) sein müssen und wie die Arbeit in verifizierbare Schritte zerlegt werden kann.

Agentenautonomie ermöglichen. Wenn du einen Coding-Agent auf die Schritte des Workflows anwendest, wählst du den Autonomiegrad: Beobachtest du ihn und gehst interaktiv hin und her, oder delegierst du ein größeres Arbeitspaket an ihn? Und wann setzt du ein klares Ziel und lässt ihn in einer Schleife laufen, bis er es erreicht hat? Zusätzlich musst du den Kontext für den Agenten sorgfältig verwalten. Während der Build durch verschiedene Phasen läuft, kalibrierst du, wann sichergestellt wird, dass wichtige Erkenntnisse, Benutzerfeedback und Annahmen – einschließlich Annahmen, die sich während des Builds geändert haben – für den späteren Gebrauch durch den Agenten festgehalten werden. Außerdem entscheidest du, wann viele Agents parallel an einer Zerlegung der Aufgabe arbeiten sollen – entweder durch Orchestrierung durch einen Menschen oder einen übergeordneten Agenten – und wie die menschliche Aufmerksamkeit über gleichzeitige Agentensitzungen hinweg verwaltet wird. Du weißt auch, wie du Agents sicher ausführst, indem du Berechtigungen und Aktionen angemessen setzt, um die Entwicklung schnell voranzutreiben und gleichzeitig das Risiko von Lecks, Datenverlust oder anderen Schäden zu begrenzen.

Die Arbeit überprüfen. Die Ausgabe eines Coding-Agents ist unsicher. Wir wissen im Voraus nicht, welche guten Ideen er haben oder welche Fehler er einbauen wird. Die Überprüfung und Verifizierung der Ausgabe ist ein entscheidender Schritt, um sicherzustellen, dass du das gewünschte Ergebnis erhältst, und um den Agenten gegebenenfalls umzulenken. Du wirst Tests und Validierungen entwerfen, die auf die Aufgabe abgestimmt sind, und dabei bei Bedarf sowohl verhaltensorientierte als auch funktionale Verifizierung anwenden. Du könntest auch Benutzerabläufe testen, vielleicht indem ein Agent Screenshots als Beleg für Erfolg oder Misserfolg liefert. Für qualitative/verhaltensorientierte Bewertungen können Evaluierungssets (Eval Sets) verwendet werden, möglicherweise mit einem LLM als Richter (LLM-as-a-Judge).

Du musst auch entscheiden, wie viele dieser Tests automatisiert werden sollen. In manchen Workflows sind alle Tests und Validierungen vollständig automatisiert, sodass der Agent seine Arbeit selbst überprüfen und wissen kann, wann er eine Aufgabe erfolgreich abgeschlossen hat. Du musst die Tests bewerten, um sicherzustellen, dass sie deinen Zielen entsprechen, und sie bei Bedarf weiterentwickeln. Darüber hinaus setzt du agentische Code-Reviews ein und führst KI-gestützte Sicherheits- und Architekturaudits durch. Wenn die KI-Überprüfung nicht ausreicht, fügst du gezielt menschliche Überprüfungen des Code-Verhaltens (und seltener auch des Codes selbst) ein, während du gleichzeitig erforschst, wie diese Überprüfung weiter automatisiert werden kann. Schließlich verifizierst du die Bereitstellung und kannst die Überwachung und das Incident-Management mit Agents operationalisieren.

Den Agenten und seine Umgebung anpassen. Deine Fähigkeit, sowohl den Agenten als auch die Umgebung, in der er arbeitet, zu aktualisieren, ermöglicht es deinen Agents, effizient den benötigten Kontext zu erhalten, auf Werkzeuge zuzugreifen und korrekt und effizient zu bauen. Du weißt, wie du Agent-Fähigkeiten, Plugins und MCP-Server integrierst. Gelegentlich wirst du sie entfernen, wenn sie nicht mehr notwendig sind (z. B. wenn ein neues Modell eine alte Fähigkeit überflüssig macht). Du kannst Hooks verwenden, um wiederholbare Teile des Entwicklungsprozesses zu automatisieren, wie das Auslösen automatisierter Code-Reviews oder CI/CD-Pipelines. Du kannst auch die Umgebung pflegen, in der der Agent arbeitet: den ständigen Kontext (wie AGENTS.md oder CLAUDE.md) mit Informationen über die Codebasis, wichtige Architekturannahmen, Codestil und Datenzugriffsmuster aktualisieren. Du weißt, wie du den Zustand über mehrere Sitzungen und über parallele Agents hinweg bewahrst und Agenten-Lerninhalte im Laufe der Zeit ansammelst, vielleicht durch Retrospektiven nach dem Durchlauf, um festzuhalten, was funktioniert hat und was nicht. Du weißt auch, wie du konsistente Konventionen und Strukturen einrichtest, um deine Codebasis für den Agenten navigierbar zu machen, und wie du gelegentlich agentengenerierte technische Schulden bereinigst. Wenn du im Team arbeitest, überlegst du, wie du den Kontext über die Agents verschiedener Entwickler hinweg koordinieren kannst.

Grundlagen der Coding-Agents. Schließlich hast du, um während des gesamten Prozesses gute Entscheidungen zu treffen, ein gutes Verständnis dafür, wie Coding-Agents funktionieren: wie sie die Codebasis durchsuchen/abrufen, wie sie ihre Kontextfenster verwalten, wie verschiedene Operationen (wie das Hinzufügen von Tool-Aufrufen, MCP-Servern usw.) den Kontext beeinflussen, wie Agents und Sub-Agents interagieren und wie der Agent durch die Kapselung eines LLMs in einer Steuerungsebene (Harness) aufgebaut ist. Dies macht den Agenten weniger zu einer Blackbox und hilft dir, Fehlermodi zu erkennen, wie z. B. das Überengineering einer einfachen Lösung, mangelnde Sorgfalt, weil dem Agenten ein expliziter Verifizierungsprozess fehlt, das vorzeitige Stoppen vor dem Ziel oder Agentenaktionen, die die Zerstörung von Dateien oder Produktionsdaten riskieren. Es hilft dir auch, über den Zustand des Agenten nachzudenken und ihn zu steuern, indem du ihm die richtige Anweisung oder den richtigen Kontext gibst. Und bei der Überwachung eines Durchlaufs ermöglicht dir dieses Verständnis, besser zu erkennen, wann der Agent vom Kurs abkommt und dein Eingreifen erfordert.

Ich finde, dass soziale Medien oft zu vereinfachte Beschreibungen liefern, wie man Coding-Agents einsetzt. Zum Beispiel ist es manchmal nützlich, Agents stundenlang autonom laufen zu lassen und dabei Millionen oder zig Millionen Tokens zu verbrauchen. Aber der praktische Nutzen von Aufgaben mit sehr langem Zeithorizont – insbesondere im Verhältnis zu ihren Kosten – wird derzeit über die Realität hinaus aufgebauscht. Stattdessen ist die effektivste Nutzung von Coding-Agents ein komplexer, hochgradig iterativer Prozess, und die Fähigkeit, mit fundiertem Urteilsvermögen einzugreifen, liefert deutlich bessere Ergebnisse.

Deine Fähigkeit im Umgang mit Coding-Agents wird dich zu einem effektiven Entwickler machen. Dies versetzt dich auch in die Lage, den gesamten Bauprozess zu steuern. In einem zukünftigen Artikel werde ich mehr dazu sagen.