Agenten für die Softwareentwicklung: Was funktioniert und was nicht

KI verändert die Softwareentwicklung rasant. Tools wie GitHub Copilot haben die KI-gestützte Code-Autovervollständigung eingeführt, und jetzt kommen weiter entwickelte autonome Coding-Agenten auf (z. B. Devin, OpenHands). Diese Agenten nehmen grobe Anweisungen entgegen und erledigen Programmieraufgaben über mehrere Schritte hinweg, fast wie ein Junior-Entwickler, der asynchron arbeitet. Die Begeisterung ist groß (manche Entwickler berichten von einer 10× höheren Produktivität), aber es gibt auch Skepsis. Der Unterschied liegt oft in realistischen Erwartungen und im richtigen Einsatz der Agenten. Wie Robert Brennan (CEO von All Hands AI und Mitentwickler von OpenHands) in seinem Vortrag auf der ODSC 2025 anmerkte, müssen wir „den Hype durchdringen“ und verstehen, was die heutigen KI-Coding-Agenten tatsächlich können und was nicht. Diese Agenten sind leistungsfähige Generalisten, aber sie können nicht zaubern: Der Erfolg hängt davon ab, wie klug man sie einsetzt (klare Prompts, sauberes Sandboxing, menschliche Aufsicht).

Wichtig ist auch: KI-Coding-Agenten verändern, womit wir als Entwickler unsere Zeit verbringen. Das „Coding“ (das händische Schreiben von Code) beginnt bei Routineaufgaben „zu verschwinden“, die Softwareentwicklung als Disziplin aber nicht. Die Rolle des Menschen verschiebt sich zum Denken auf höherer Ebene: Nutzerbedürfnisse verstehen, Anforderungen definieren, Lösungen entwerfen und die Arbeit der KI prüfen. Die KI glänzt in der „inneren Schleife“ der Entwicklung, dem schnellen Zyklus aus Code schreiben, ausführen und nachbessern. Schwer tut sie sich mit der „äußeren Schleife“: der Planung im Großen und dem Einfühlen in Endnutzer oder Geschäftsziele. Kurz gesagt: Wir werden weniger Zeit damit verbringen, Boilerplate-Code zu tippen, und mehr Zeit damit, zu prüfen, anzuleiten und kritisch darüber nachzudenken, was überhaupt gebaut werden soll.

Von der Autovervollständigung zu autonomen Agenten

Frühe KI-Entwicklungstools wie Copilot dienten als unterstützende Autovervollständigung, die im Editor ein paar Zeilen Code vorschlug. Moderne Coding-Agenten dagegen handeln selbst: Sie führen über Tools Aktionen in Ihrem Auftrag aus. Statt jede Zeile selbst zu schreiben, geben Sie einem Agenten vielleicht ein Ziel in einem Satz, er arbeitet 5, 10 oder sogar 15 Minuten autonom und kommt dann mit einem Lösungsvorschlag zurück. Aus der synchronen Hilfe Zeile für Zeile wird damit asynchrones Problemlösen über mehrere Schritte.

Heutige Agenten können Codebases ändern, Befehle ausführen, Tests laufen lassen und sogar im Web nach Dokumentation suchen. Tools wie OpenHands (früher OpenDevin) wollen das „volle Spektrum“ der Entwicklungsaufgaben abdecken: nicht nur das Programmieren, sondern auch Kompilieren, Ausführen, Testen und die Online-Recherche nach Lösungen. Ein Rezensent formulierte es so: Wir haben gesehen, wie sich KI von „einfachen Hilfen zur Code-Vervollständigung zu hochentwickelten Systemen entwickelt hat, die komplexe Anforderungen verstehen und funktionsfähige Anwendungen erzeugen können“. Anders gesagt: Ein Agent ähnelt eher einem autonomen Junior-Entwickler, Copilot eher einer Autovervollständigung auf Steroiden.

Mit größerer Macht kommen allerdings neue Probleme. Agenten arbeiten autonom, sie nehmen also womöglich mehrere Änderungen vor oder treffen mehrere Entscheidungen, bevor Sie das Ergebnis sehen. Das ist enorm mächtig, weil Sie parallel programmieren oder sich anderer Arbeit widmen können, während die Agenten Aufgaben abarbeiten. Es heißt aber auch, dass Sie ihrer Arbeit zwar vertrauen, sie aber trotzdem überprüfen müssen. Die Agenten schaffen allein viel mehr als eine einfache Autovervollständigung, können ohne Anleitung aber auch vom Kurs abkommen. Deshalb sollten Sie verstehen, wie sie funktionieren und wie man sie steuert.

Wie Coding-Agenten funktionieren (unter der Haube)

Das Herzstück jedes Coding-Agenten ist eine Schleife zwischen einem LLM als „Gehirn“ und der Außenwelt. Der Agent nutzt ein großes Sprachmodell (LLM), um Schritt für Schritt über Aktionen zu entscheiden, und er hat Tools, um diese Aktionen in einer Entwicklungsumgebung auszuführen. Die typische Schleife sieht so aus: Der Agent liest den aktuellen Zustand (Code, Fehler usw.), das LLM entscheidet, „was die nächste Aktion ist, um dem Ziel näherzukommen“, dann führt der Agent diese Aktion aus, sammelt das Ergebnis ein und gibt es für den nächsten Schritt an das LLM zurück. Das geht so weiter, bis der Agent glaubt, das Ziel erreicht zu haben (oder hängen bleibt oder scheitert).

Zu den wichtigsten Tools von Coding-Agenten gehören:

• Code-Editor: Der Agent kann Dateien in der Codebase lesen und ändern. Moderne Agenten schreiben nicht blind ganze Dateien neu, sondern nehmen aus Effizienzgründen gezielte Änderungen vor (Diffs oder Suchen und Ersetzen). Manchmal bekommen sie einen abstrakten Syntaxbaum oder andere Navigationshilfen, um die richtige Stelle für eine Änderung zu finden. So kommt der Agent auch mit großen Codebases zurecht, weil er sich auf die relevanten Abschnitte beschränkt und die Token-Limits nicht überschreitet.

• Terminal und Befehlsausführung: Der Agent kann in einer Sandbox-Umgebung Shell-Befehle ausführen (zum Bauen, Testen, Starten der Anwendung usw.). Wenn er das Terminal autonom bedient, stellen sich Fragen, etwa wie er mit lang laufenden Befehlen oder parallelen Prozessen umgeht. Agenten wie OpenHands können Server starten, ihnen dann Testanfragen schicken und so mehrere Prozesse verwalten. Entscheidend ist, dass jede Befehlsausgabe und jeder Exit-Status erfasst und an das LLM zurückgegeben wird, damit es weiß, was passiert ist.

• Web-Browsing: Braucht der Agent externe Informationen (Dokumentation, Lösungen von Stack Overflow, Bibliotheksreferenzen), kann er Webanfragen stellen. Ein guter Agent kippt nicht rohes HTML voller irrelevantem Markup in das LLM, sondern extrahiert den lesbaren Inhalt (etwa indem er den Accessibility Tree auswertet oder HTML in Markdown umwandelt). Manche Agenten können bei Bedarf durch Seiten scrollen oder sogar Klicks und Formulareingaben simulieren. Diese Fähigkeit wird laufend besser: Ein aktueller Beitrag zu OpenHands hat zum Beispiel „die Genauigkeit [des Agenten] beim Web-Browsing verdoppelt“, was zeigt, wie schnell sich dieser Bereich entwickelt. Eine gute Web-Anbindung bedeutet, dass der Agent selbstständig die neueste Dokumentation abrufen oder Lösungen für neue Probleme finden kann.

• Dateisystem: Der Agent kann in seinem Arbeitsbereich Dateien anlegen, lesen und löschen. Das braucht er, um neue Quelldateien hinzuzufügen, Konfigurationsdateien zu aktualisieren oder erzeugte Inhalte zu schreiben. In der Regel ist der Dateizugriff des Agenten auf ein bestimmtes Projektverzeichnis oder ein Docker-Volume beschränkt, damit er nichts außerhalb seines Bereichs durcheinanderbringt.

• Sandboxing (Sicherheit): Autonomie ist mächtig, aber ohne Isolation gefährlich. Ein Coding-Agent hat im Grunde die Befugnisse eines Entwicklers auf Ihrem Rechner, und dazu kann gehören, dass er zerstörerische Befehle ausführt, wenn etwas schiefgeht. Alle seriösen Agenten-Frameworks lassen die KI standardmäßig in einer Sandbox laufen (oft in einem Docker-Container). So kann der Agent nicht versehentlich rm -rf / auf Ihrem echten System ausführen oder sensible Daten abfließen lassen. Die Sandbox enthält nur die Tools und Berechtigungen, die er für die jeweilige Aufgabe braucht. Benötigt der Agent zum Beispiel Zugangsdaten (GitHub-Tokens, Cloud-Schlüssel), stellen Sie ihm eng begrenzte Zugangsdaten mit minimalen Rechten bereit. Wer einer KI Zugriff auf externe Systeme gibt, muss sich an das Prinzip der geringsten Rechte halten. Kurz gesagt: Die Sandbox begrenzt die Aktionen des Agenten, sodass er frei experimentieren kann, ohne echten Schaden anzurichten.

Diese Schleife und diese Tools zu kennen, ist mehr als technisches Detailwissen: Sie entwickeln damit ein Gespür für das Verhalten des Agenten. Wenn Sie zum Beispiel wissen, dass der Agent die Rückmeldungen von Tests oder Fehlermeldungen liest, sollten Sie die Tests früh laufen lassen, damit er die Fehlschläge sieht und beheben kann. Wenn Sie wissen, dass er im Web sucht, hilft ihm vielleicht die Online-Dokumentation, wenn er nicht weiterkommt. Im Grunde führen Sie einen KI-Kollegen, der sehr schnell, aber sehr wörtlich denkt: Er tut genau das (und nur das), was Sie verlangen und was seine Tools erlauben.

Bewährte Vorgehensweisen beim Einsatz von Coding-Agenten

Wie holen wir angesichts dieser Arbeitsweise das Beste aus Coding-Agenten heraus? Brennans Vortrag und die Erfahrungen aus der Community legen einige Vorgehensweisen nahe, mit denen sich diese Agenten wirksam einsetzen lassen, ohne Rauschen oder technische Schulden zu erzeugen:

• Klein und einfach anfangen: Geben Sie dem Agenten am Anfang kleine, abgegrenzte Aufgaben statt eines ganzen Projekts. Ideal sind Aufgaben, die vielleicht einen Commit an Änderungen umfassen und klar definieren, wann sie erledigt sind (z. B. „alle Tests bestehen“ oder „Merge-Konflikt gelöst“). So kann der Agent selbst prüfen, ob es geklappt hat (indem er Tests ausführt usw.), und Sie können das Ergebnis leicht kontrollieren. Gute Einstiegsaufgaben sind oft die lästigen Pflichten, die Entwickler nicht mögen: einen einzelnen fehlschlagenden Test reparieren, Lint-Fehler beheben oder eine Konfigurationsdatei aktualisieren. Solche Aufgaben sind meist unkompliziert und repetitiv, was KI gut bewältigt, und Sie sehen schnell, ob die Korrektur stimmt.

• Anweisungen explizit formulieren: Bei einem Prompt für einen Agenten kommt es auf Klarheit an. Sagen Sie nicht nur, was erledigt werden soll, sondern auch wie. Nennen Sie die konkreten Frameworks, Funktionsnamen oder Dateien, um die es geht. Statt „implementiere die Benutzeranmeldung“ könnten Sie zum Beispiel sagen: „Implementiere eine Benutzeranmeldung mit der vorhandenen AuthService-Klasse und folge dem Muster aus loginController.js (verwende JWT-Tokens). Ergänze passende Unit-Tests.“ Genaue Vorgaben bewahren den Agenten vor Irrwegen und machen ihn auch schneller (er verschwendet keine Zeit damit, die gesamte Codebase zu durchsuchen, wenn Sie ihm die richtige Stelle zeigen). Eine Minute für einen ausführlichen Prompt kann dem Agenten zehn Minuten Herumirren ersparen.

• Iterieren und verfeinern: Behandeln Sie jeden Versuch des Agenten als Entwurf. Ist der erste Versuch nicht zufriedenstellend, können Sie in derselben Sitzung weitere Anweisungen geben, um ihn zu verbessern. Agenten merken sich den Gesprächskontext (bis zu einer gewissen Grenze) und können ihre Ausgabe anpassen. Läuft etwas wirklich aus dem Ruder, scheuen Sie sich nicht, abzubrechen und mit einem neuen Ansatz von vorn zu beginnen. Ein Vorteil von KI-generiertem Code ist, dass Code billig ist: Sie haben keine Stunden investiert, um ihn selbst zu schreiben. Einen schlechten KI-Versuch können Sie ohne großen Verlust wegwerfen. Dieses „wie gewonnen, so zerronnen“ lädt zum Experimentieren und schnellen Prototyping ein. Brennan erzählte, dass er manchmal einen Agenten startet, um eine Idee zu skizzieren, die ihm auf dem Arbeitsweg gekommen ist. Klappt es, gut, wenn nicht, verwirft er das Ergebnis und probiert etwas anderes, ohne dass Schaden entsteht.

• Ausgabe immer prüfen und testen: Übernehmen Sie Code von einem Agenten nie blind. So nützlich diese Tools sind, sie machen Fehler und können ungeprüft subtile Bugs oder unsauberen Code einschleppen. Brennan warnt davor, eine komplette Produktionsanwendung ohne menschliche Aufsicht per „Vibe Coding“ zu bauen: Das ist ein Rezept, um massive technische Schulden anzuhäufen (duplizierter Code, schlechte Struktur, versteckte Bugs). Machen Sie immer ein Code-Review dessen, was der Agent produziert. Stellen Sie sicher, dass Sie die Änderungen verstehen und dass sie Ihrer Absicht entsprechen. Führen Sie den Code selbst oder in einer Testumgebung aus, um zu prüfen, ob er das Problem tatsächlich löst. In der Praxis heißt das: Zur Qualitätskontrolle bleibt ein Mensch im Loop. Manche Teams verlangen sogar, dass jeder von KI verfasste Pull Request einem menschlichen Entwickler zugeordnet wird (bei OpenHands werden PRs zum Beispiel dem Entwickler zugewiesen, der den Agenten gestartet hat, nicht „OpenHands“ selbst), damit ein Mensch dafür verantwortlich ist, den PR durchzubringen und Probleme zu beheben. Diese Regel macht deutlich, dass der Entwickler für die Ausgabe der KI verantwortlich ist.

• Tools wie Tests und Linter nutzen: Als Hilfe für den Agenten und für Ihr Review sollten Sie eine solide Suite automatisierter Tests und Linter haben. Agenten lieben Tests, denn Tests liefern ein klares Erfolgskriterium (bestanden oder nicht), auf das der Agent hinarbeiten kann. Wenn Sie einen Agenten bitten, einen Bug zu beheben oder ein Feature hinzuzufügen, lassen Sie ihn auch die Tests ausführen, um zu bestätigen, dass alles besteht. Das leitet nicht nur den Agenten, es gibt auch Ihnen Vertrauen in das Ergebnis. Linter und Formatter kann der Agent ebenfalls ausführen, damit er die Stilrichtlinien automatisch einhält. Je mehr Rückmeldung Sie dem Agenten geben können (über fehlschlagende Tests, Fehlerprotokolle usw.), desto besser kann er korrigieren und zu einer guten Lösung finden.

 

Mit diesen Vorgehensweisen (gut abgegrenzte Aufgaben, explizite Anleitung, Iteration nach Bedarf, gründliches Review) schaffen Sie gute Voraussetzungen für den Agenten und für sich selbst. So eingesetzt beschleunigen Agenten die Arbeit deutlich, statt nur Rauschen zu erzeugen.

Aufgaben, bei denen KI-Agenten glänzen

Für welche Aufgaben eignen sich Coding-Agenten heute also besonders? Nach Brennans Erfahrungen mit OpenHands und Berichten aus der Community stechen mehrere Anwendungsfälle für den „ersten Tag“ als besonders lohnend hervor:

• Merge-Konflikte lösen: Dieses klassische Ärgernis für Entwickler bewältigen Agenten sehr gut. Bei Merge-Konflikten geht es oft darum, zwei Änderungen rein mechanisch miteinander abzugleichen. Ein Agent kann die Konfliktmarkierungen auswerten, die Absicht beider Seiten verstehen und den Code logisch zusammenführen. Brennan erzählte, dass in der schnelllebigen OpenHands-Codebase kein Pull Request ohne Konflikte davonkommt und dass es enorm viel Zeit spart, den Agenten diese Konflikte automatisch auflösen zu lassen. Er löst die große Mehrheit der Konflikte korrekt, indem er analysiert, was sich wo geändert hat, und erspart Ihnen den manuellen Diff-Vergleich.

• Feedback aus Code-Reviews umsetzen: Wenn ein Teamkollege klare Kommentare in einem PR hinterlässt („bitte diese Variable zur besseren Lesbarkeit umbenennen“ oder „hier statt eigenem Code die Funktion aus Bibliothek X verwenden“), können Sie den Agenten anweisen, dieses gesamte Feedback umzusetzen. Der Agent kann die Review-Kommentare lesen und die gewünschten Änderungen in der gesamten Codebase vornehmen. Das passt gut, weil der Reviewer das gewünschte Ergebnis ausdrücklich in menschlicher Sprache beschreibt, was praktisch schon ein fertiger Prompt ist. Brennan nannte ein Beispiel, bei dem ein Frontend-Experte bestimmte React-Änderungen verlangte, mit denen Brennan selbst nicht vertraut war. OpenHands konnte genau diese Änderungen anhand der Review-Notizen korrekt umsetzen. Der Agent arbeitet wie ein folgsamer Pair-Programming-Partner, der genau das tut, „was dieser Reviewer gesagt hat“.

• Bugfixes und einfache Feature-Änderungen: Bei kleinen Bugs, deren Ursache an einer Stelle liegt (z. B. „die Eingabe sollte eine Zahl sein, wird aber derzeit als Text behandelt“), sind Agenten sehr wirksam. Statt den Code selbst mit grep zu durchsuchen, können Sie den Agenten bitten, das Problem zu finden und zu beheben. Er sucht die betreffende Datei, wendet die Korrektur an (zum Beispiel wird aus einem <input> ein <input type=”number”>) und aktualisiert auf Wunsch sogar einen Test oder fügt einen hinzu. Das geht mit einem kurzen Prompt (sogar über eine Chat-Oberfläche oder die Kommandozeile), ohne dass Sie Ihre ganze IDE laden müssen. Es ist so bequem, als hätten Sie einen Junior-Entwickler auf Abruf, der sich um kleinere Probleme kümmert.

• Infrastructure as Code und Konfigurationsänderungen: Aufgaben wie eine Terraform-Konfiguration anpassen, eine CI-Pipeline aktualisieren oder das Speicherlimit eines Servers erhöhen sind oft unkompliziert, verlangen aber das Nachschlagen von Syntax oder Konfigurationsschlüsseln. Hier glänzen Agenten: Sie „kennen“ die Syntax oft (dank des Trainings mit Dokumentation) oder können sie schnell abrufen. Sie sagen vielleicht „erhöhe das Speicherlimit unseres Kubernetes-Pods in der Konfiguration“, und der Agent aktualisiert das YAML, JSON oder Terraform entsprechend. Er erledigt das Boilerplate und sorgt dafür, dass Sie keine verknüpfte Einstellung vergessen. Wie Brennan erwähnte, konnten sie bei einem Out-of-Memory-Alarm OpenHands einfach sagen, die Speichereinstellung zu erhöhen, und der Agent setzte die Änderung im gesamten Infrastruktur-Code um.

• Datenbankmigrationen: Migrationen schreiben (eine Spalte hinzufügen, einen Index anlegen usw.) ist eine weitere repetitive Aufgabe, die Agenten gut liegt. Eine KI kann das Migrationsskript (in SQL oder mit dem Migrationstool eines ORM) nach bewährten Vorgehensweisen erzeugen, weil sie viele Beispiele gesehen hat. Interessanterweise hat Brennan festgestellt, dass KI diese Vorgehensweisen hier oft besser einhält als Menschen: Sie ergänzt zuverlässig Indizes, Fremdschlüssel oder Not-Null-Constraints, die ein Mensch in der Eile vielleicht übersieht. Der Agent arbeitet im Grunde wie ein penibler DBA-Assistent.

• Testabdeckung erhöhen: Wenn Ihnen auffällt, dass ein Teil Ihres Codes keine Tests hat, können Sie den Agenten bitten, welche zu erzeugen. Das ist eine Aufgabe mit geringem Risiko (sie ändert keinen Produktionscode, sondern fügt nur Tests hinzu), die Sie der KI also gefahrlos überlassen können. Der Agent kann Unit- oder Integrationstests schreiben, ausgehend davon, wie er das erwartete Verhalten des Codes versteht. So verbessern Sie Ihre Test-Suite schnell. Solange die Tests bestehen (und Sie idealerweise kurz prüfen, ob sie sinnvoll sind), werden Sie auf angenehme Weise Fleißarbeit los. Dazu kommt: Beim Schreiben von Tests muss der Agent das Verhalten des Codes durchdenken, was indirekt versteckte Annahmen oder Bugs ans Licht bringen kann.

• Grundgerüste für neue Module oder Anwendungen: Agenten sind überraschend gut darin, das erste Gerüst einer Anwendung oder eines Moduls anzulegen. Sie können sagen „richte einen neuen Microservice ein, der X macht“, und der Agent legt eine Grundstruktur an, erstellt also zum Beispiel ein neues Verzeichnis, fügt Boilerplate-Code hinzu, vielleicht eine README usw. Das ist besonders nützlich bei internen Tools oder Prototypen, bei denen Tempo wichtiger ist als Perfektion. Brennans Team nutzt OpenHands, um sehr schnell kleine interne Anwendungen aufzusetzen (zum Beispiel eine Debugging-Oberfläche für Agenten-Sitzungen). Aber Vorsicht: Bei produktiven Systemen sollten Sie jedes KI-generierte Gerüst weiterhin gründlich prüfen und nachbearbeiten. Der Agent bringt Sie in Minuten 80 % des Wegs voran, die letzten 20 % (die Produktionsreife) bleiben Sache der Menschen. Sehen Sie es als Mittel gegen die Schreibblockade bei einem leeren Projekt: Der Agent liefert Ihnen einen Ausgangspunkt, den Sie dann verfeinern können.

 

All diese Anwendungsfälle sind klar abgegrenzte Aufgaben mit eindeutigen Erfolgskriterien (Tests bestehen, Konfiguration aktualisiert usw.), und genau deshalb glänzen Agenten dabei. Sie nehmen Entwicklern lästige oder schematische Arbeit ab, sodass wir uns auf schwierigere Probleme konzentrieren können. Viele Teams berichten, dass sie viel Zeit und geistige Energie gewinnen, sobald sie einem Agenten diese Pflichten anvertrauen.

Aufgaben, die für Agenten schwierig bleiben

Auf der anderen Seite gibt es Dinge, die Coding-Agenten (noch) nicht so gut können. Sie sollten diese Grenzen kennen, um Frust oder ein Desaster zu vermeiden:

• Design im Großen und Anforderungen: Agenten sind keine Produktmanager oder leitenden Architekten. Ihnen fehlt ein echtes Verständnis von Nutzerbedürfnissen oder vom geschäftlichen Kontext. Sie können sich nicht in die Probleme eines Endnutzers einfühlen oder entscheiden, welche Features zur Geschäftsstrategie passen. Ein Agent merkt zum Beispiel nicht von selbst, dass eine Quick-and-dirty-Lösung der Wartbarkeit schaden oder dass ein bestimmtes Feature Nutzer verwirren könnte. Er folgt einfach den Anweisungen. Aufgaben auf hoher Ebene, etwa die Gesamtarchitektur eines neuen Systems festzulegen, Abwägungen zu treffen oder mehrdeutige Anforderungen zu interpretieren, überlässt man am besten Menschen, jetzt und wahrscheinlich auch in Zukunft. KI kann bei den Details der Implementierung helfen, aber das Problem zu definieren und dafür zu sorgen, dass die Lösung Sinn ergibt, verlangt menschliches Urteilsvermögen.

• Offene Problemstellungen: Ist Ihr Prompt vage oder das Ziel offen („mach die App besser“ oder „optimiere diese Codebase“), irrt der Agent herum. Agenten brauchen ein klar definiertes Ziel. Sie sind stark darin, sich einem bekannten guten Ergebnis anzunähern (bestandene Tests, Übereinstimmung mit einer Spezifikation). Ist die Aufgabe explorativ oder kreativ und fehlen klare Kriterien, liefert der Agent womöglich Irrelevantes oder verfängt sich in Schleifen. Bitten Sie einen Agenten zum Beispiel ohne weitere Anleitung, ein neues Feature zu entwerfen, baut er vielleicht etwas, das an dem vorbeigeht, was Sie eigentlich wollten. Schlecht definierte Aufgaben = schlechte Ergebnisse. Solange KI nicht mehr echtes Verständnis erlangt, müssen Menschen große Probleme für den Agenten in konkrete Teilaufgaben zerlegen.

• Kohärenz in großen Codebases wahren: LLM-basierte Agenten haben ein begrenztes Gedächtnis (Kontextfenster) und tun sich schwer damit, ein ganzes großes Projekt im Blick zu behalten. Sie ändern womöglich etwas in einer Datei, das Annahmen in einer anderen Datei widerspricht, wenn diese nicht im Prompt-Kontext lagen. Ein Entwickler formulierte es so: LLMs „erzeugen inkonsistenten, schlecht strukturierten Code und tun sich schwer damit, die Kohärenz über mehrere Dateien hinweg zu wahren“, wenn man sie ohne Anleitung arbeiten lässt. In einer großen Codebase merkt ein Agent vielleicht nicht, dass sein Ansatz in einem Modul gegen eine Konvention verstößt, die anderswo gilt. Menschen verstehen die Architektur eines komplexen Systems als Ganzes immer noch besser. Agenten arbeiten am besten, wenn Sie ihnen einen bestimmten Teil des Codes zeigen können. Müssen sie Dutzende Dateien auf einmal refaktorieren oder aktualisieren, müssen Sie die Arbeit sorgfältig beaufsichtigen oder aufteilen.

• Langer autonomer Betrieb ohne Kontrollpunkte: Je länger Sie einen Agenten ohne Aufsicht laufen lassen, desto mehr Fehlerquellen häufen sich an. Agenten haben keine „übergeordnete Selbstkorrektur“ über das hinaus, was das LLM ableiten kann, und laufen deshalb womöglich immer wieder in die falsche Richtung. Brennan rät, Aufgaben kurz zu halten und häufig zu prüfen. Die Forschung hat gezeigt, dass teilweise Autonomie (die dem Nutzer einen „Autonomie-Regler“ gibt) meist besser funktioniert als völlig freie Läufe. In der Praxis heißt das: Kommt ein Agent nach ein paar Minuten oder ein paar Iterationen nicht voran, sollten Sie eingreifen, seine Zwischenergebnisse prüfen und ihn gegebenenfalls neu starten oder neu anleiten. Völlig autonome, stundenlange Programmierläufe klingen aufregend, enden aber oft damit, dass der Agent sich verheddert oder Code von geringer Qualität produziert, den man wieder aufdröseln muss.

• Qualität des erzeugten Codes (Risiko technischer Schulden): Agenten können schnell viel Code schreiben, aber Menge ist nicht Qualität. Naiv eingesetzt, können sie subtile Bugs, Sicherheitsprobleme oder einfach unsauberen Code einschleppen, der zwar „funktioniert“, aber schwer zu warten ist. Ein Agent dupliziert zum Beispiel vielleicht Logik an zwei Stellen, weil er nicht erkannt hat, dass sie zusammenhängen, oder er wählt einen ineffizienten Ansatz, der zwar die Tests besteht, aber nicht skalieren würde. Der KI-Entwickler Alberto Fortin warnte, sich auf einen Agenten zu verlassen, ohne den Code selbst zu verstehen, sei „ein Rezept für ein Desaster“. Zu viel Vertrauen in KI kann mit der Zeit sogar Ihre eigenen Fähigkeiten aushöhlen. Behandeln Sie von Agenten geschriebenen Code deshalb so kritisch wie den Code eines menschlichen Junior-Entwicklers. Gehen Sie nicht davon aus, dass er elegant strukturiert oder optimal ist. Oft muss ein Mensch nachträglich refaktorieren, damit die Codebase sauber bleibt.

Coding-Agenten ersetzen also keine menschliche Einsicht. Sie sind ungemein nützliche Assistenten für klar definierte Programmieraufgaben, aber sie sind nicht bereit (und werden es vielleicht nie sein), als leitende Entwickler die Richtung eines Projekts zu verantworten. Das erfolgreiche Muster sieht so aus: Der Agent übernimmt bei klar abgegrenzten Problemen die Schwerarbeit, Sie liefern die Vision, die Anleitung und das kritische Review.

Wie sich die Fähigkeiten bis 2025 und darüber hinaus entwickeln

KI-Agenten werden in rasantem Tempo besser. Bis 2025 und darüber hinaus dürfen wir erwarten, dass sie einige der heute schwierigen Aufgaben erfolgreich bewältigen, wenn auch mit Einschränkungen. Agenten könnten zum Beispiel besser darin werden, in mehreren Schritten über eine Codebase hinweg zu schlussfolgern, wenn die Kontextfenster wachsen und die Architekturen besser werden. Das könnte KI-gesteuerten Refactorings oder Aktualisierungen in großem Maßstab zu mehr Kohärenz verhelfen. Auch die Nutzung von Tools wird ausgefeilter, wie die Fortschritte beim Web-Browsing und möglicherweise bei GUI-Interaktionen zeigen. Agenten bekommen damit mehr Möglichkeiten, Kontext zu sammeln und ihre Arbeit zu überprüfen. Vielleicht übernehmen sie auch etwas anspruchsvollere Aufgaben, etwa Änderungen über mehrere Microservices hinweg zu koordinieren oder End-to-End-Testabläufe durchzuführen, wofür heute oft noch ein Mensch im Loop nötig ist.

Wahrscheinlich bleibt menschliche Aufsicht aber unverzichtbar. Selbst wenn die Agenten zuverlässiger werden, gebietet es schon die ingenieurmäßige Vorsicht, dass ein Mensch kritische Änderungen gegenprüft. Das Ziel ist nicht, Menschen aus dem Prozess zu entfernen, sondern unsere Produktivität zu steigern. In Brennans Vision könnten Entwickler künftig mehrere Agenten (ein „KI-Entwicklungsteam“) orchestrieren, die parallel an verschiedenen Aufgaben arbeiten, während der Mensch als Tech Lead den Schwarm beaufsichtigt. Das ist eine grundlegend andere Arbeitsweise, bei der es mehr ums Beaufsichtigen und Zusammenführen geht und weniger darum, alles von Hand zu programmieren, aber sie verlangt vom Entwickler weiterhin Können und Urteilsvermögen.

Ein Beobachter brachte es knapp auf den Punkt: „Es geht nicht darum, dass die KI klug ist, sondern darum, klug mit der KI umzugehen.“ Wer bei den bewährten Vorgehensweisen (Prompt Engineering, Tool-Setup usw.) auf dem Laufenden bleibt und die Grundlagen der Softwareentwicklung beherrscht, kann auf dieser Welle reiten, statt von ihr verschluckt zu werden. Unternehmen und Entwickler, die herausfinden, wie sie wirksam mit KI-Agenten zusammenarbeiten, werden wahrscheinlich besser abschneiden als die anderen, vor allem bei Routineaufgaben. Kreatives Design und das Lösen komplexer Probleme bleiben aber auf absehbare Zeit eine Stärke, die nur Menschen haben.

Fazit

KI-Coding-Agenten wie OpenHands erweisen sich als wertvolle Ergänzung im Werkzeugkasten von Entwicklern: Sie automatisieren eintönige Aufgaben und beschleunigen den Entwicklungszyklus. Klug eingesetzt, ermöglichen sie eine Arbeitsweise, bei der Sie „weniger programmieren, aber mehr erreichen“. Eintönige Pflichten, vom Lösen von Merge-Konflikten bis zum Schreiben von Boilerplate-Tests, können Sie an einen unermüdlichen KI-Assistenten abgeben und sich selbst auf das Design auf höherer Ebene und auf kritisches Denken konzentrieren. Was heute funktioniert: Agenten für klar abgegrenzte, überprüfbare Aufgaben einsetzen und sie als Junior-Mitarbeiter unter Ihrer Anleitung arbeiten lassen. Was nicht funktioniert: erwarten, dass der Agent mehrdeutige oder strategische Arbeit wie von Zauberhand erledigt, oder ihn ohne Aufsicht loslassen. Dieser Weg führt zu Bugs und Wartungsalbträumen.

Es kommt auf das Gleichgewicht an: Verbinden Sie das Tempo und die Breite der KI mit dem Urteilsvermögen und der Intuition von Menschen. Brennans Erkenntnisse gehen in dieselbe Richtung: Der Erfolg mit Coding-Agenten „hängt von klugen Prompts, Sandboxing und menschlichem Review ab“. In der Praxis heißt das, den Agenten als mächtiges Werkzeug zu behandeln, das weiterhin einen fähigen Bediener braucht. Wer die Fähigkeiten und Grenzen des Agenten versteht, kann KI-Agenten nutzen, um die Produktivität drastisch zu steigern und trotzdem Qualität und Kontrolle zu behalten. Die Entwickler, die diese Partnerschaft beherrschen, werden sich in der veränderten Softwareentwicklung am besten zurechtfinden und mehr und bessere Software bauen, mit ein wenig Hilfe von ihren KI-Freunden.

Quellen:

1. Brennan, R. (2025). AI Software Engineering Agents: What Works and What Doesn’t: Vortrag auf der ODSC East 2025

2. Ponomarev, M. (2025). OpenHands: The Open Source Devin AI Alternative: Apidog Blog

3. Steinberger, P. (2025). Essential Reading for Agentic Engineers: Blogbeitrag

4. Fortin, A. (2025). A Cautionary Perspective on AI Coding: Blogbeitrag

Aus dem Englischen übersetzt: zum Originalbeitrag