KI-Agenten in der Softwareentwicklung: So gelingt die Zusammenarbeit mit Copilot

KI-Agenten verändern die Softwareentwicklung. Sie unterstützen bei der Analyse von Codebasen, übernehmen Implementierungsaufgaben und automatisieren wiederkehrende Arbeitsschritte. Ihr produktiver Einsatz erfordert jedoch einen durchdachten Entwicklungsworkflow: Aufgaben sollten sinnvoll aufgeteilt, Ergebnisse überprüft und die Codequalität konsequent gesichert werden. Entscheidend ist dabei, die Verantwortung für Architektur, fachliche Entscheidungen und Wartbarkeit nicht an den Agenten abzugeben. Der folgende Beitrag zeigt, wie sich GitHub Copilot in bestehende Entwicklungsprozesse integrieren lässt, welche Rolle Instructions, Skills und Prompts spielen und warum menschliche Kontrolle insbesondere bei produktiven Anwendungen unverzichtbar bleibt.

Der Einsatz von Coding-Agenten bedeutet nicht zwangsläufig, den gesamten Entwicklungsprozess neu aufzubauen. Häufig bleiben die grundlegenden Schritte bestehen – von der Aufgabenklärung über die Planung und Implementierung bis hin zu Review und Abnahme. Was sich verändert, ist die Unterstützung innerhalb dieser Schritte.

Ein sinnvoller Einstiegspunkt ist die Analyse der Codebasis. KI-Agenten können relevante Dateien und Codestellen identifizieren, Zusammenhänge erschließen und bei der Vorbereitung einer Implementierung helfen. Die fachliche Einordnung des Problems und die grundlegenden technischen Entscheidungen sollten jedoch weiterhin bei den Entwicklern liegen.

Für die Umsetzung empfiehlt es sich, größere Aufgaben in kleinere, klar abgegrenzte Teilaufgaben zu zerlegen. Diese lassen sich gezielt an den Agenten übergeben und anschließend einzeln überprüfen. Kleine Änderungen erleichtern die Kontrolle und machen es einfacher, Fehler oder unerwünschte Auswirkungen zu erkennen.

Eine praktische Orientierung aus der Entwicklungspraxis sind Änderungen und Pull Requests mit einem Umfang von etwa 200 Zeilen. Das ist kein allgemeingültiger Grenzwert. Entscheidend ist, dass der Umfang überschaubar bleibt und sich die Änderungen noch konzentriert nachvollziehen lassen.

Nach der Implementierung sollte ein Review folgen. Bei Bedarf kann der Agent auf Basis des Feedbacks nachbessern. Erst wenn die Akzeptanzkriterien erfüllt und die Änderungen geprüft sind, sollten sie übernommen werden. Auch bei der Erstellung von Commit Messages und Pull-Request-Beschreibungen kann KI unterstützen. Die Ergebnisse sollten allerdings nicht ungeprüft übernommen werden.

Spec-Driven Development (SDD) kann helfen, komplexe Aufgaben strukturiert zu beschreiben und die Umsetzung durch KI-Agenten zu steuern. Allerdings ist nicht für jede Änderung eine umfangreiche Spezifikation notwendig.

Gerade bei kleineren Aufgaben kann zusätzlicher Dokumentations- und Abstimmungsaufwand den eigentlichen Entwicklungsprozess verlangsamen. Außerdem garantiert eine detaillierte Spezifikation noch keine korrekte Implementierung. Entscheidend ist letztlich der Code, der tatsächlich ausgeführt wird.

Ein pragmatischer Ansatz besteht deshalb darin, den Umfang der Vorgaben an die Komplexität der Aufgabe anzupassen. Kleine Änderungen benötigen häufig nur eine klare Aufgabenbeschreibung und definierte Akzeptanzkriterien. Bei komplexeren Vorhaben können zusätzliche Spezifikationen und Planungsschritte sinnvoll sein.

Wichtig bleibt in jedem Fall, nicht nur zu prüfen, ob die formulierten Anforderungen erfüllt wurden. Auch Architektur, Erweiterbarkeit und Wartbarkeit müssen berücksichtigt werden. Eine Lösung kann funktional korrekt sein und trotzdem technische Schulden verursachen.

Ein wesentliches Risiko beim Einsatz von Coding-Agenten liegt in der Qualität der erzeugten Implementierung. Nicht spezifizierte Details eröffnen Interpretationsspielräume. Der Agent kann die unmittelbaren Akzeptanzkriterien erfüllen, während die Lösung bei genauerer Betrachtung schwer wartbar oder nur eingeschränkt erweiterbar ist.

Ein interessanter Anhaltspunkt dazu ist SlopCodeBench. Die Untersuchung beschäftigt sich unter anderem damit, wie sich die Codequalität bei iterativer Arbeit mit Coding-Agenten entwickelt. Sie verdeutlicht, dass eine steigende Erfolgsquote bei der Problemlösung nicht automatisch bedeutet, dass auch die Codequalität besser wird. In den untersuchten Szenarien können Modelle Aufgaben zunehmend erfolgreich lösen, während bestimmte Qualitätsmetriken stagnieren oder sich verschlechtern.

Daraus ergibt sich eine wichtige Konsequenz für die Praxis: Coding-Agenten sollten bei längeren und wiederholten Änderungen nicht vollständig sich selbst überlassen werden. Die Ergebnisse müssen überprüft und an bestehende Architektur- und Qualitätsstandards angepasst werden.

KI-generierter Code muss dabei keineswegs automatisch schlechter sein. Richtig eingesetzt, können Agenten auch die Softwarequalität verbessern – etwa durch die Erstellung und Ausführung von Tests, die Pflege der Dokumentation, Security-Checks, Bug Hunting oder die Analyse von Logs. Gerade bei solchen Aufgaben können sie einen erheblichen Effizienzgewinn ermöglichen.

Damit Coding-Agenten konsistent arbeiten, benötigen sie ausreichend Kontext. Dieser lässt sich auf unterschiedlichen Ebenen bereitstellen.

Persönliche Instructions definieren individuelle Präferenzen für die Zusammenarbeit. Dazu gehören beispielsweise Vorgaben zur Code-Struktur, zu Clean-Code-Prinzipien, Kommentaren und zur Kommunikation. Klare Anweisungen helfen dabei, die Ergebnisse an die Arbeitsweise der Entwickler anzupassen und unnötig umfangreiche Antworten zu vermeiden.

Skills eignen sich für spezielles Wissen und wiederkehrende Abläufe. Sie können beispielsweise technische Besonderheiten, kundenspezifische Anforderungen oder bestimmte Lösungswege abbilden, die der Agent bei passenden Aufgaben berücksichtigen soll.

Prompts sind sinnvoll, wenn konkrete Aufgaben oder Workflows regelmäßig wiederholt werden. Statt wiederkehrende Anweisungen jedes Mal neu zu formulieren, können sie als wiederverwendbare Vorlagen bereitgestellt werden.

Auch auf Repository-Ebene sollte der Agent mit den notwendigen Informationen versorgt werden. Drei Elemente sind dabei besonders hilfreich:

• AGENTS.md: Beschreibt das Repository, seine Struktur, wichtige Konventionen und verfügbare Befehle. Die Datei gibt dem Agenten den notwendigen Projektkontext.
• REVIEW.md: Enthält zusätzliche Vorgaben für Code Reviews. Wiederkehrende Prüfungen und projektspezifische Qualitätsanforderungen lassen sich so systematisch berücksichtigen.
• Verifizierungsaufgaben: Der Agent sollte seine Implementierung selbst überprüfen können. Dazu gehören beispielsweise Tests, Linting und weitere projektbezogene Prüfungen. Was auch in einer CI-Pipeline kontrolliert wird, sollte möglichst bereits während der Implementierung überprüfbar sein.

Entscheidend ist, diese Hilfsmittel nicht von Anfang an übermäßig komplex aufzubauen. Sinnvoller ist es, wiederkehrende Anforderungen schrittweise zu identifizieren und daraus Instructions, Skills oder Prompts zu entwickeln. Diese sollten anschließend anhand der tatsächlichen Ergebnisse weiter verbessert werden.

Wie eine geeignete Projektstruktur für die Zusammenarbeit mit Coding-Agenten aussehen kann, zeigt auch der Ansatz einer AI-friendly Architektur.

Vibe Coding, also die weitgehend autonome Umsetzung von Code durch KI-Agenten ohne kontinuierliche menschliche Kontrolle, kann für bestimmte Anwendungsfälle sinnvoll sein. Entscheidend sind vor allem das Risiko und die erwartete Lebensdauer des Codes.

Für kleine, risikoarme Aufgaben bietet sich dieser Ansatz beispielsweise bei Prototypen, Proofs of Concept oder einmaligen Hilfsskripten an. Wenn der Code nur einen begrenzten Zweck erfüllt und anschließend nicht langfristig gewartet werden muss, kann eine weitgehend autonome Umsetzung Zeit sparen.

Anders sieht es bei produktiven Anwendungen, sensiblen Daten oder geschäftskritischen Systemen aus. Je höher das Risiko und je größer der Umfang der Anwendung, desto genauer müssen Implementierung und Ergebnisse überprüft werden. Insbesondere bei langfristig weiterentwickelten Anwendungen ist es wichtig, dass Entwickler die Struktur und Funktionsweise des Codes verstehen.

Die Grenze zwischen Vibe Coding und klassischer, eng begleiteter Entwicklung ist dabei nicht binär. Sie hängt von der jeweiligen Aufgabe ab. Sobald der Code gelesen, verstanden und gegebenenfalls selbst angepasst wird, geht die Entwicklung über rein autonomes Vibe Coding hinaus. Für produktive Systeme sollte diese menschliche Nähe zum Code selbstverständlich sein.

Aus den Erfahrungen mit KI-gestützter Softwareentwicklung lassen sich fünf praktische Empfehlungen ableiten:

1. Aufgaben überschaubar halten

Größere Vorhaben sollten in kleinere, klar abgegrenzte Änderungen zerlegt werden. Das erleichtert die Kontrolle und reduziert das Risiko, dass Fehler unbemerkt in die Codebasis gelangen.

2. Automatisierung schrittweise aufbauen

Instructions, Skills und Prompts sollten aus konkreten Anforderungen des Entwicklungsalltags entstehen. Ein inkrementeller Aufbau verhindert unnötige Komplexität und ermöglicht es, die Hilfsmittel kontinuierlich zu verbessern.

3. Kontextwechsel reduzieren

Mehrere parallel arbeitende Agenten führen nicht automatisch zu höherer Produktivität. Auch bei KI-Agenten kostet jeder Wechsel zwischen Aufgaben Zeit und Aufmerksamkeit, weil der jeweilige Kontext erneut aufgenommen werden muss. Eine klare Fokussierung kann deshalb effizienter sein als die parallele Bearbeitung vieler Aufgaben.

4. Den Workflow an die eigene Arbeitsweise anpassen

Es gibt keinen universell richtigen Agenten-Workflow. Die eingesetzten Werkzeuge und Abläufe sollten sich an den Anforderungen des Projekts und der Arbeitsweise des Entwicklungsteams orientieren. Sinnvoll ist es, bestehende Prozesse gezielt weiterzuentwickeln, statt sie vollständig durch ein starres KI-Framework zu ersetzen.

5. Code verstehen, bevor er übernommen wird

Die Verantwortung für den Code bleibt bei den Entwicklern – unabhängig davon, ob er selbst geschrieben oder von einem Agenten generiert wurde. Wer Code committet, sollte nachvollziehen können, was er macht und warum die gewählte Lösung sinnvoll ist.

Coding-Agenten können die Softwareentwicklung erheblich beschleunigen. Ihr größter Nutzen liegt jedoch nicht darin, möglichst viel Code möglichst autonom erzeugen zu lassen. Entscheidend ist, sie gezielt in einen durchdachten Entwicklungsworkflow einzubinden.

Die Kombination aus klar abgegrenzten Aufgaben, geeignetem Projektkontext, automatisierter Verifizierung und menschlichem Review ermöglicht es, KI-Unterstützung produktiv zu nutzen, ohne die Codequalität aus dem Blick zu verlieren. Gerade bei größeren und geschäftskritischen Anwendungen bleibt die menschliche Verantwortung für Architektur, Sicherheit und Wartbarkeit unverzichtbar.

Ein guter Agenten-Workflow entsteht dabei nicht auf einmal. Er entwickelt sich schrittweise mit den eingesetzten Modellen, den Anforderungen der Projekte und den Erfahrungen der Entwicklungsteams weiter.