Vom Assistenten zum Agenten: KI-Coding-Agenten in der Legacy-Modernisierung gezielt einsetzen, ohne die Kontrolle zu verlieren

Das Wichtigste in Kürze KI in der Softwareentwicklung ist über die Autovervollständigung hinausgewachsen. Agenten übernehmen ganze Aufgaben: Sie planen die Schritte, ändern zahlreiche Dateien, führen Tests aus und legen am Ende einen fertigen Pull Request vor. Für Unternehmen, die seit Jahren auf großen Altsystemen sitzen, klingt das nach der Lösung für eine immer wieder verschobene Modernisierung. Die ersten Daten zeichnen ein differenzierteres Bild. Teams mit intensiver KI-Nutzung produzieren deutlich mehr Code, doch ihre Pull Requests werden größer, enthalten mehr Fehler und brauchen erheblich länger im Review. Analysten rechnen damit, dass ein großer Teil der Projekte mit KI-Agenten wegen unklaren Nutzens, steigender Kosten und mangelnder Steuerung eingestellt wird. Agenten können die Modernisierung tatsächlich beschleunigen, aber nur, wenn die Aufgaben sauber beschrieben, durch Tests abgesichert, in kleine Schritte zerlegt und von Menschen geprüft werden, die das System verstehen. Dieser Beitrag zeigt, wofür sich Agenten im Legacy-Code eignen, wo sie scheitern, welche Leitplanken nötig sind und wo Sie am besten anfangen.

Was sich ändert, wenn aus dem Assistenten ein Agent wird

Ein Coding-Assistent schlägt die nächste Zeile oder Funktion vor, während jemand programmiert. Ein Agent bearbeitet dagegen eine Aufgabe. Er liest die relevanten Teile der Codebasis, entscheidet, welche Dateien er ändert, schreibt den Code, führt die Tests aus, wertet die Ergebnisse aus und arbeitet so lange weiter, bis er die Aufgabe für erledigt hält.

Gartner beschreibt das als Übergang von der KI-gestützten zur agentenbasierten Softwareentwicklung, die von der Planung über die Umsetzung bis zum Review reicht. Nach Einschätzung des Analysehauses werden bis 2027 die meisten Entwicklungsteams, die mit Agenten arbeiten, die klassische Entwicklungsumgebung als optional betrachten und Steuerung, Governance und Prüfung auf automatisierte Plattformen verlagern.

Für die Modernisierung von Altsystemen ist dieser Unterschied in zweierlei Hinsicht bedeutsam. Agenten können wiederkehrende Änderungen über viele Dateien hinweg erledigen, für die ein Team sonst Wochen bräuchte, etwa ein Framework-Update in Hunderten von Modulen. Gleichzeitig können sie in sehr kurzer Zeit sehr viele Änderungen in einem System vornehmen, das niemand mehr vollständig überblickt, und genau dort sind Fehler am teuersten.

Was die Daten bisher zeigen

Die Verbreitung ist hoch, die Ergebnisse sind gemischt. Eine Analyse von Faros AI mit mehr als 10.000 Entwicklerinnen und Entwicklern ergab, dass Teams mit hoher KI-Nutzung rund 21 % mehr Aufgaben erledigen und nahezu doppelt so viele Pull Requests zusammenführen. Die Daten aus 2026 zeigen jedoch auch: In diesen Teams wurden Pull Requests um 51 % größer, die Zahl der Fehler pro Pull Request stieg um 28 %, und die Review-Dauer verfünffachte sich.

Auf strategischer Ebene schätzt Gartner, dass bis 2027 mehr als 40 % der Projekte mit KI-Agenten eingestellt werden könnten, weil der Nutzen unklar bleibt, die Kosten steigen und die Steuerung fehlt.

Das Muster ist eindeutig: Agenten steigern den Output, aber Output ist nicht dasselbe wie Fortschritt. In Altsystemen, in denen versteckte Abhängigkeiten und undokumentiertes Verhalten die Regel sind, wird ungesteuerter Output schnell zu Nacharbeit, Review-Stau und Störungen in der Produktion.

Wo Agenten bei der Modernisierung helfen

Am meisten bringen Agenten dort, wo die Aufgabe klar umrissen ist, die Änderung einem erkennbaren Muster folgt und sich das Ergebnis automatisch überprüfen lässt.

Die besten Ergebnisse entstehen, wenn Menschen festlegen, was sich ändern soll, und Agenten das Wie umsetzen.

Wo Agenten scheitern

Fehlender Kontext. In Altsystemen steckt Wissen, das nicht im Code steht: vor Jahren vereinbarte Geschäftsregeln, Sonderlösungen für einzelne Kunden, nirgends dokumentierte Schnittstellen. Was ein Agent nicht sieht, kann er nicht berücksichtigen.

Zu große Änderungen. Bekommt ein Agent eine breit gefasste Aufgabe, ändert er womöglich Dutzende Dateien auf einmal. Große Änderungen sind schwerer zu prüfen und schwerer zurückzurollen, und genau dann rutschen Fehler durch.

Plausibler, aber falscher Code. Der Output von Agenten wirkt meist sauber und stimmig. Gerade deshalb fallen subtile Fehler wie eine geänderte Rundungsregel oder eine fehlende Null-Prüfung leichter durch das Raster.

Schwache Tests. Fehlen Tests oder prüfen sie nur oberflächlich, kann ein Agent sie zum Bestehen bringen, ohne das relevante Verhalten zu erhalten. Im Legacy-Code ist das die häufigste Ursache für unbemerkte Regressionen.

Ausufernde Kosten. Agenten, die bei komplexen Aufgaben viele Durchläufe brauchen, verbrauchen erhebliche Rechenleistung. Ohne Obergrenzen und Messung steigen die Kosten schneller als der Nutzen.

Leitplanken für einen sicheren Einsatz

1. Den Code zuerst mit Tests absichern. Bevor ein Agent Legacy-Code verändert, sollte das aktuelle Verhalten der betroffenen Module in Charakterisierungstests festgehalten sein. Das ist die wichtigste Voraussetzung überhaupt. Ein Agent ohne verlässliche Tests arbeitet im Blindflug.

2. Aufgaben präzise beschreiben. Eine gute Aufgabe hat einen klaren Umfang, ausdrückliche Vorgaben und eine Definition of Done: welche Module geändert werden dürfen, welche Schnittstellen stabil bleiben müssen, welche Tests bestehen müssen. Die Qualität der Beschreibung bestimmt maßgeblich die Qualität des Ergebnisses.

3. Änderungen klein halten. Zerlegen Sie die Modernisierung in kleine, einzeln prüfbare Schritte. Begrenzen Sie den Umfang der Pull Requests, die Agenten öffnen dürfen, und setzen Sie lieber auf eine Folge kleiner Änderungen als auf eine große Umstellung.

4. Menschen im Review behalten. Jede von einem Agenten erzeugte Änderung durchläuft denselben Review- und Freigabeprozess wie von Menschen geschriebener Code. Reviewer sollten wissen, welche Änderungen von einem Agenten stammen, und sich auf das Verhalten konzentrieren, nicht auf die Formatierung.

5. Berechtigungen einschränken. Agenten sollten in isolierten Umgebungen arbeiten und nur auf die Repositories und Ressourcen zugreifen, die sie tatsächlich brauchen. Direkter Zugriff auf Produktivsysteme, Produktivdaten oder Zugangsdaten ist tabu.

6. Prüfungen automatisieren. Builds, Tests, statische Analyse und Sicherheitsscans sollten bei jeder Änderung laufen und alles blockieren, was durchfällt. Eine Pipeline, die auf ausgereiften DevOps- und Cloud-Praktiken aufbaut, macht diese Prüfungen zu einer verlässlichen Absicherung statt zu einem nachträglichen Gedanken.

7. Ergebnisse messen, nicht Output. Erfassen Sie Durchlaufzeit, Change Failure Rate, Review-Dauer und Nacharbeit zusammen mit Nutzung und Kosten der Agenten. Führt mehr Code zu mehr Störungen, muss der Prozess angepasst werden, nicht die Zahl der Agenten erhöht.

So gelingt der Einstieg

Erst analysieren, dann automatisieren. Nicht jeder Teil eines Altsystems ist für Agenten geeignet. Manche Module sind ordentlich strukturiert und ausreichend getestet, andere eng verflochten, kaum verstanden und geschäftskritisch. Ein AI Refactoring Assessment bildet die Codebasis ab, zeigt, wo Agenten die Arbeit gefahrlos beschleunigen können und wo eine von Menschen geführte Neugestaltung nötig ist, und liefert eine priorisierte Modernisierungs-Roadmap.

Mit einer überschaubaren, gut verstandenen Aufgabe beginnen. Ein Framework-Update in einem unkritischen Modul oder die Testerzeugung für einen einzelnen Service eignet sich gut als erster Schritt. Er zeigt, wie sich Agenten in Ihrer Codebasis verhalten, welchen Review-Aufwand sie verursachen und was sie tatsächlich kosten.

Den Arbeitsablauf gestalten, nicht nur das Werkzeug auswählen. Aufgabenvorlagen, Review-Richtlinien, Berechtigungskonzepte und Kennzahlen sind wichtiger als die Wahl des Agenten. Erst wenn diese Elemente fest im Entwicklungsprozess verankert sind, wie wir es auf unserer Seite zur KI-gestützten Softwareentwicklung beschreiben, wird aus einem Pilotprojekt eine wiederholbare Praxis.

Schrittweise ausweiten. Weiten Sie den Einsatz von Agenten erst dann auf weitere Module aus, wenn die Kennzahlen bestätigen, dass Qualität und Stabilität gehalten werden.

Bei einem Anbieter von Industriesoftware aus dem deutschsprachigen Mittelstand floss der Großteil der Entwicklungszeit in die Pflege von Altmodulen; für Modernisierung blieb kaum Kapazität. Eine schrittweise Einführung von KI-Werkzeugen, priorisiert nach Risiko und Wirkung und begleitet von praxisnaher Befähigung des Teams, setzte spürbar Entwicklungskapazität frei, verkürzte die Durchlaufzeit von Änderungen und machte Releases besser planbar. Der Gewinn entstand durch die richtige Reihenfolge und konsequente Disziplin, nicht dadurch, dass man den Agenten freie Hand ließ.

Agenten ersetzen kein technisches Urteilsvermögen

Agenten verändern die Wirtschaftlichkeit der Legacy-Modernisierung. Arbeiten, die bisher zu mühsam oder zu teuer waren, etwa Abhängigkeiten in Hunderten von Modulen zu aktualisieren oder vernachlässigten Code mit Tests abzusichern, werden realistisch. Die Verantwortung dafür, das System zu verstehen, über Änderungen zu entscheiden und zu prüfen, ob alles weiterhin funktioniert, bleibt jedoch beim Menschen.

Unternehmen, die Agenten mit klaren Vorgaben, belastbaren Tests, kleinen Schritten und sorgfältigem Review verbinden, modernisieren schneller und mit geringerem Risiko. Wer einem Agenten ein Altsystem überlässt und auf das Beste hofft, bekommt mehr Code und mehr Probleme. Wenn Sie herausfinden möchten, wo Agenten die Modernisierung Ihrer Systeme sicher beschleunigen können, erfahren Sie auf unserer Seite zur Produkt- und Anwendungsentwicklung, wie unsere Teams das gemeinsam mit Ihnen planen und umsetzen. Für Investoren wird dieselbe Disziplin übrigens zunehmend in der technischen Due Diligence sichtbar: Ein kontrollierter KI-Einsatz gilt dort als Zeichen technischer Reife.