KI-generierter Code: Weniger Bugs, aber höhere Wartungskosten

Weniger Bugs, aber höhere Komplexität: Der KI-Code-Widerspruch

Der Widerspruch ist offensichtlich: Sprachmodelle generieren Code, der weniger Bugs enthält und weniger Aufwand zum Beheben erfordert – gleichzeitig weist derselbe Code eine um 34 Prozent höhere zyklomatische Komplexität auf als menschlich geschriebener Code. Beide Aussagen stammen aus empirischen Studien und widersprechen sich nur scheinbar. Sie betreffen unterschiedliche Qualitätsdimensionen: Die eine misst funktionale Korrektheit, die andere Wartbarkeit.

Eine Studie verglich LLM-generierte Python-Lösungen mit menschlichem Code über drei Schwierigkeitsgrade hinweg – Einführungs-, Interview- und Wettbewerbsniveau. Das Ergebnis: Der KI-Code weist weniger Bugs auf und erfordert insgesamt weniger Aufwand zum Fixen. Feingetunte Modelle reduzierten dabei hochgradige Probleme wie Blocker und kritische Bugs und verschoben sie zu niedrigeren Schweregraden – allerdings auf Kosten der Modell-Performance. Bei Wettbewerbsproblemen führten die LLM-Lösungen zudem manchmal strukturelle Probleme ein, die in menschlichem Code nicht vorhanden sind.

Eine separate Untersuchung mit 642 KI-generierten und 107 menschlichen Lösungen fand dagegen systematische Qualitätsfehler im KI-Code, darunter die genannte 34 Prozent höhere zyklomatische Komplexität. Diese Metrik misst die Anzahl unabhängiger Pfade durch den Code und gilt als Indikator für Testbarkeit und Wartungsaufwand. Der scheinbare Widerspruch löst sich auf, wenn man funktionale Korrektheit und langfristige Wartbarkeit als getrennte Dimensionen betrachtet: Ein Programm kann korrekt funktionieren und dennoch schwer zu warten sein.

Wartungsrealität: KI-Dateien werden seltener angefasst

Eine empirische Studie mit über 1.000 Dateien und rund 3.200 Änderungen aus 100 populären Repositories zeigt, wie sich KI-generierter Code in der Wartungspraxis verhält. Das Ergebnis: AI-generierte Dateien erhalten weniger häufige Wartung als menschlich erstellter Code. Wenn Updates erfolgen, betreffen sie nur einen kleinen Teil der Dateigröße – nicht die Datei als Ganzes.

Auffällig ist zudem die Art der Modifikationen. Die häufigsten Änderungen an KI-Code sind Feature-Erweiterungen, während menschliche Updates sich auf Bugfixes konzentrieren. Das deutet darauf hin, dass der generierte Code zunächst funktional ausreicht, aber bei neuen Anforderungen erweitert wird, ohne dass eine grundlegende Überarbeitung stattfindet.

Die große Mehrheit dieser Wartungsarbeiten führen menschliche Entwickler durch. Das Modell, das den Code erzeugt hat, übernimmt keine langfristige Verantwortung für seinen Output. Wartung und Haftung liegen beim Team – eine Besonderheit, die klassische Definitionen von Codequalität nicht abbilden.

Vier-Jahres-Trend: Refactoring sinkt, Duplikation steigt

Langzeitdaten über vier Jahre Code-Änderungen zeigen einen deutlichen Trend: Die Wartbarkeitssignale in Repositories mit KI-Unterstützung bewegen sich rückwärts. Cross-file function calls – ein Indikator für Wiederverwendung – sind um 35 Prozent gesunken. Refactoring line moves gingen um 70 Prozent zurück, long-term legacy maintenance um 74 Prozent im Vergleich zu 2022.

Gleichzeitig steigen die problematischen Muster. Within-commit copy/paste nahm um 41 Prozent zu, code block duplication um 81 Prozent, error-masking constructs um 47 Prozent und two-week code churn um 15 Prozent. Die Duplikation von Codeblöcken ist dabei das Signal, das die akademische Literatur am direktesten mit Defekten und propagierten Bugs in Verbindung bringt.

Der Durchsatz ist real, aber die technischen Schulden wachsen mit. Besonders betroffen sind Entwickler, die die Fehlermodi nicht erkennen, die die langfristige Wartbarkeit von Repositories gefährden. Refactoring-Aktivität ist inzwischen etwa fünfmal seltener als copy/paste – ein Verhältnis, das auf Repositories mit dauerhaften V1-Komponenten hindeutet.

Produktivitätsgewinne und die Rolle von GitHub Copilot

Rein quantitativ steigt die Produktivität von Entwicklerteams mit KI, wie zahlreiche unabhängige Studien belegen. Moderne Sprachmodelle schreiben beeindruckenden Code – oft korrekt und produktivitätssteigernd, aber mit erhöhtem Risiko für Wartbarkeits- und Sicherheitsprobleme.

Laut GitHub war Copilot das weltweit erste generative KI-Coding-Tool, das in großem Maßstab eingesetzt wurde – also nicht nur als Forschungsprojekt, sondern als kommerziell verfügbares Produkt für eine breite Entwicklerbasis. Es startete als technische Vorschau im Juni 2021 und wurde im Juni 2022 allgemein verfügbar. Nach Angaben von GitHub schreibt Copilot inzwischen 46 Prozent des Codes und hilft Entwicklern, bis zu 55 Prozent schneller zu coden. Das Unternehmen spricht von einem neuen Zeitalter der Softwareentwicklung – eine Einschätzung, die subjektiv ist und sich nicht objektiv messen lässt.

Für GitHub Copilot Pro Nutzer gilt: Deren Code wird nicht zum Training von KI-Modellen verwendet. Diese Einstellung ist standardmäßig deaktiviert und kann nicht aktiviert werden.

Langfristige Folgen für Entwickler und Unternehmen

Die Studienlage zeichnet ein klares Bild: Kurzfristige Produktivitätsgewinne durch KI-generierten Code stehen langfristigen Wartungskosten und technischen Schulden gegenüber. Die Codekomplexität nimmt bei KI-Einsatz langfristig zu und kann anfängliche Produktivitätsgewinne durch mehr Codezeilen schmälern.

Menschliche Entwickler bleiben für einen Großteil der Wartung von KI-generiertem Code zuständig. Sie müssen zusätzliche Aufwände für Refactoring und Qualitätssicherung einplanen, da der generierte Code seltener überarbeitet wird und Duplikationen zunehmen. Die hohe Varianz zwischen einzelnen Generierungen bei gleichem Prompt erschwert die Qualitätssicherung zusätzlich.

Für technische Leiter bedeutet das: Sie müssen Best Practices einführen, um die Durchsatzgewinne der KI zu erhalten und gleichzeitig die Wartbarkeitskosten zu begrenzen. Klassische Metriken zur Codequalität müssen erweitert werden, um die spezifischen Risiken von KI-generiertem Code zu erfassen. Die Kernfrage ist nicht, ob das Modell Code schreiben kann, sondern wie Teams den LLM-Code so integrieren, dass Effizienzgewinne nicht in technischen Schulden enden.