KI-generierte Software: Wenn die Architektur auf den zweiten Blick bröckelt
Eine plausible Paketstruktur sagt wenig über die Wartbarkeit aus: Konkrete Beispiele mit OpenAPI, Request-Headern und Schichtgrenzen zeigen, worauf es bei KI-generierter Software ankommt.
Warum funktionierende Anwendungen nicht automatisch gut wartbar sind — und welche Herausforderungen bei ihrer Weiterentwicklung entstehen.
KI-gestützte Softwareentwicklung verändert, wie schnell Anwendungen entstehen. In kurzer Zeit lassen sich Prototypen entwickeln, fachliche Anforderungen umsetzen und komplexe technische Strukturen aufbauen, teilweise erheblich schneller als früher.
Das Tempo wirft aber eine andere Frage auf: Wie stellt man sicher, dass die entstandene Software nicht nur funktioniert, sondern auch langfristig zuverlässig weiterentwickelt werden kann? Sie stellt sich vor allem dann, wenn ein Entwicklungsteam eine zunächst KI-generierte Anwendung übernehmen, erweitern und für den produktiven Einsatz vorbereiten soll.
Eine plausible Architektur ist noch keine tragfähige Architektur
In einem aktuellen Entwicklungsprojekt arbeite ich an einer Anwendung mit, deren erster Prototyp weitgehend KI-gestützt entstanden ist. Auf den ersten Blick machte die Codebasis einen durchaus vernünftigen Eindruck. Die Paketstruktur folgte einer nachvollziehbaren Aufteilung, Controller, Services und Persistenzkomponenten waren vorhanden, und auch die Benennung der Klassen ließ eine bewusste Architektur erkennen.
Bei der eigentlichen Entwicklungsarbeit zeigte sich jedoch ein anderes Bild.
Die äußerlich erkennbare Trennung der Verantwortlichkeiten setzte sich innerhalb der Implementierung nicht konsequent fort. Mal wurden Data Transfer Objects (DTOs) bis in die Serviceschicht durchgereicht, an anderen Stellen gelangten Persistenz-Entities bis zur REST-Schnittstelle. Für einen Teil der Fachlichkeit wurden eigene Business Objects generiert, für andere fachliche Bereiche fehlten sie dagegen.
Auch die Struktur der Benutzeroberfläche beeinflusste die darunterliegenden Anwendungsschichten und reichte teilweise bis in die Persistenzmodelle hinein. Damit verschwammen die Grenzen zwischen Darstellung, fachlicher Verarbeitung und Datenhaltung.
Das Problem liegt nicht darin, dass DTOs, Business Objects und Entities grundsätzlich immer strikt getrennt werden müssten. Je nach Anwendungsfall und Komplexität können vereinfachte Strukturen durchaus sinnvoll sein. Problematisch wird es aber, wenn vergleichbare Abläufe unterschiedlichen Regeln folgen, ohne dass dafür ein erkennbarer architektonischer Grund existiert.
Bei einer Änderung muss dann zunächst nachvollzogen werden, welche Schichten im jeweiligen Fall tatsächlich beteiligt sind, wo Daten transformiert werden und welche Abhängigkeiten bestehen.
Was auf Paketebene zunächst übersichtlich erscheint, erweist sich innerhalb der Implementierung als deutlich weniger konsistent.
Die Qualität einer Architektur zeigt sich nicht allein an ihrer äußeren Struktur, sondern vor allem daran, wie gut sie die Weiterentwicklung des Systems unterstützt.
Solche Unstimmigkeiten beschränken sich nicht auf die interne Struktur des Codes. Sie zeigen sich auch an den Schnittstellen einer Anwendung, wie das folgende Beispiel aus der Praxis verdeutlicht.
Ein Request-Header, den die API-Spezifikation nicht vorsieht
Die Anwendung verwendet OpenAPI-Spezifikationen, um ihre REST-Schnittstellen zu beschreiben. Darin sind unter anderem Endpunkte, HTTP-Methoden, Parameter und Datenstrukturen definiert.
Bei der Überprüfung zweier REST-Operationen fiel eine Abweichung zwischen der Spezifikation und dem KI-generierten Java-Code auf.
Die folgenden Codebeispiele sind aus einem realen Praxisfall abgeleitet und für diesen Artikel vereinfacht und anonymisiert.
Operation 1 — Aktualisierung einer Bestellposition
Die OpenAPI-Spezifikation definiert für diese Operation zwei Pfadparameter, orderId und positionId, sowie einen Request-Body:
paths:
/api/v1/orders/{orderId}/position/{positionId}:
patch:
operationId: updateOrderPosition
parameters:
- $ref: "#/components/parameters/OrderId"
- $ref: "#/components/parameters/PositionId"
requestBody:
required: true
content:
application/json:
schema:
$ref: "#/components/schemas/OrderPositionUpdateRequest"
Operation 2 — Stornierung einer Bestellposition
Die zweite Operation verwendet dieselben Pfadparameter. Zusätzlich ist in der OpenAPI-Spezifikation ein verpflichtender HTTP-Header namens If-Match definiert:
paths:
/api/v1/orders/{orderId}/position/{positionId}/stornieren:
post:
operationId: storniereOrderPosition
parameters:
- $ref: "#/components/parameters/OrderId"
- $ref: "#/components/parameters/PositionId"
- name: If-Match
in: header
required: true
schema:
type: string
Die Abweichung im Java-Code
Im KI-generierten Java-Code enthielten jedoch beide API-Methoden den verpflichtenden If-Match-Header:
@PatchMapping(
value = "/api/v1/orders/{orderId}/position/{positionId}",
consumes = MediaType.APPLICATION_JSON_VALUE,
produces = MediaType.APPLICATION_JSON_VALUE)
ResponseEntity<OrderPositionResponse> updateOrderPosition(
@PathVariable("orderId") UUID orderId,
@PathVariable("positionId") UUID positionId,
@RequestHeader("If-Match") String ifMatch,
@Valid @RequestBody OrderPositionUpdateRequest request);
@PostMapping(
value = "/api/v1/orders/{orderId}/position/{positionId}/stornieren",
produces = MediaType.APPLICATION_JSON_VALUE)
ResponseEntity<OrderPositionResponse> storniereOrderPosition(
@PathVariable("orderId") UUID orderId,
@PathVariable("positionId") UUID positionId,
@RequestHeader("If-Match") String ifMatch);
Für die Stornierungsoperation entsprach dies der Spezifikation. Bei der Update-Operation war der Parameter dagegen nicht vorgesehen.
Eine mögliche Erklärung ist, dass die KI aufgrund des gemeinsamen URL-Präfixes und der ähnlichen Parameterstruktur den Header auch auf die andere Operation übertragen hat. Ob dies tatsächlich die Ursache war, lässt sich rückblickend nicht sicher feststellen.
Die Abweichung vom API-Vertrag ist dagegen eindeutig.
Interessant ist, dass der Fehler auf den ersten Blick nicht besonders auffällig wirkt. Die Methodensignatur ist gültig, die Spring-Annotation korrekt verwendet und der Java-Code grundsätzlich kompilierbar.
Die Konsequenz kann dennoch erheblich sein.
In Spring MVC ist ein mit @RequestHeader deklarierter Parameter standardmäßig verpflichtend. Ein Client, der sich an die OpenAPI-Spezifikation hält und die Update-Operation ohne If-Match aufruft, kann dadurch eine HTTP-400-Antwort erhalten, obwohl sein Request dem dokumentierten Schnittstellenvertrag entspricht.
Es handelt sich somit nicht nur um eine stilistische Auffälligkeit, sondern um eine potenziell funktionale Abweichung zwischen Spezifikation und Implementierung.
Erkennbar wird sie erst durch den Abgleich mit dem definierten API-Vertrag oder durch entsprechend ausgelegte Schnittstellentests.
Warum die KI etwas generieren lassen, das ein Generator bereits beherrscht?
Der Fall führt zu einer weiteren Beobachtung aus demselben Zusammenhang.
Obwohl OpenAPI-Spezifikationen vorhanden waren, wurden die API-Schnittstellen, ihre Implementierungen und die zugehörigen DTOs von der KI generiert. Für die Schnittstellen und DTOs hätte stattdessen ein etabliertes Werkzeug wie der OpenAPI Generator eingesetzt werden können.
Natürlich kann eine KI aus einer OpenAPI-Beschreibung Java-Klassen, Controller-Schnittstellen und DTOs ableiten. Allerdings besteht ein grundlegender Unterschied zwischen generativer Codeerstellung und spezifikationsbasierter Codegenerierung.
Ein OpenAPI Generator verarbeitet eine definierte Spezifikation nach festgelegten Generierungsregeln. Bei unveränderter Spezifikation, Generatorversion und Konfiguration ist das Ergebnis reproduzierbar. Die generative KI erstellt dagegen eine Implementierung auf Basis ihrer Interpretation der Vorgaben.
Dabei können zusätzliche Annahmen entstehen oder Details der Spezifikation abweichend umgesetzt werden.
Ein Beispiel dafür betrifft die Validierung eines DTO-Feldes. In der OpenAPI-Spezifikation war das Feld itemName als verpflichtend definiert. Vereinfacht sah die entsprechende Definition so aus:
components:
schemas:
OrderPositionUpdateRequest:
type: object
required:
- itemName
properties:
itemName:
type: string
Die KI erzeugte dafür jedoch eine Java-Implementierung mit der zusätzlichen Validierungsregel @NotBlank:
@NotBlank
private String itemName;
Bei einer späteren Generierung mit dem OpenAPI Generator wurde dagegen keine entsprechende @NotBlank, sondern eine @NotNull-Annotation erzeugt.
Der Unterschied ist fachlich relevant.
Ein als required definiertes Feld muss in der beschriebenen Objektstruktur vorhanden sein. Daraus folgt jedoch nicht automatisch, dass eine Zeichenkette nicht leer sein oder ausschließlich aus Leerzeichen bestehen darf.
Die ursprüngliche Spezifikation erlaubt beispielsweise auch einen leeren String ("") oder einen Wert, der ausschließlich aus Leerzeichen besteht. Die zusätzliche @NotBlank-Annotation würde solche Werte bei aktivierter Bean Validation dagegen zurückweisen.
Soll diese Einschränkung tatsächlich gelten, müsste sie ausdrücklich in der OpenAPI-Spezifikation beschrieben werden, beispielsweise so:
itemName:
type: string
minLength: 1
pattern: '.*\S.*'
Die KI hatte offenbar eine zusätzliche Validierungsregel angenommen, die so nicht aus der Spezifikation hervorging.
Das muss nicht bedeuten, dass die fachliche Absicht falsch erkannt wurde. Möglicherweise war die zusätzliche Validierung sogar erwünscht. Entscheidend ist jedoch, dass der erzeugte Code eine Anforderung enthielt, die im formalen Schnittstellenvertrag nicht entsprechend beschrieben war.
Ein klassischer Codegenerator ist dabei ebenfalls kein Garant für eine fachlich korrekte Implementierung. Er kann nur die Informationen umsetzen, die in der Spezifikation enthalten sind und von seiner jeweiligen Konfiguration unterstützt werden.
Sein Vorteil besteht vor allem in der Nachvollziehbarkeit und Reproduzierbarkeit. Abweichungen können gezielt auf die Spezifikation, die Generierungsregeln oder die Konfiguration zurückgeführt werden.
Die entscheidende Frage ist deshalb nicht, ob eine KI eine solche Implementierung erstellen kann, sondern ob sie dafür das geeignete Werkzeug ist.
KI-gestützte Entwicklung und etablierte Codegeneratoren müssen keine Gegensätze sein. Die KI kann beispielsweise bei der fachlichen Implementierung, bei der Analyse bestehender Schnittstellen oder bei der Weiterentwicklung helfen, während formale API-Verträge weiterhin durch spezialisierte Werkzeuge umgesetzt und überprüft werden.
Ein weiterer Vorteil liegt in der automatisierten Validierung. Etablierte Werkzeuge können anhand der OpenAPI-Spezifikation deterministisch prüfen, ob Schnittstellen und Datenmodelle dem definierten Vertrag entsprechen. Bei entsprechender Integration lassen sich auch eingehende Anfragen auf Pflichtfelder, Datentypen und zulässige Formate prüfen. Fehlen solche Prüfungen, können Abweichungen zwischen Spezifikation und Implementierung unbemerkt bleiben und fehlerhafte Daten verarbeitet werden.
Wenn ähnliche Anforderungen unterschiedlich umgesetzt werden
Neben den konkreten Schnittstellenabweichungen zeigte sich in der Codebasis ein weiteres Muster: Vergleichbare Anforderungen waren teilweise auf unterschiedliche Weise implementiert.
Methoden mit ähnlichen Aufgaben unterschieden sich in ihrer Konstruktion und Parametrierung. Datenübertragungen zwischen Objekten wurden durch die KI generiert, obwohl sich dafür etablierte Mapping-Werkzeuge wie MapStruct anbieten. An anderer Stelle fehlten klare Regeln dafür, wann DTOs, Business Objects oder Persistenz-Entities eingesetzt werden sollten.
Keine dieser Entscheidungen ist isoliert betrachtet zwingend falsch. Manuelles Mapping kann bei einfachen Datenstrukturen sinnvoll sein. Auch eine zusätzliche Abstraktionsschicht ist nicht automatisch ein Qualitätsgewinn.
Schwieriger wird es, wenn sich kein einheitliches Konzept erkennen lässt.
Wer eine neue Funktion ergänzt, kann sich dann nicht ohne Weiteres an vorhandenen Implementierungen orientieren. Zunächst muss untersucht werden, ob die jeweilige Struktur bewusst gewählt wurde oder lediglich eine von mehreren entstandenen Varianten darstellt.
Die Auswirkungen zeigen sich besonders bei der Weiterentwicklung: Zusätzliche Fallunterscheidungen, unterschiedliche Transformationen und uneinheitliche Verantwortlichkeiten erhöhen den Aufwand für Änderungen und Tests.
An diesem Punkt wird aus einer Sammlung kleiner technischer Auffälligkeiten ein Architekturproblem.
Denn Architektur besteht nicht nur aus der Entscheidung, welche Pakete, Klassen und Komponenten existieren. Sie legt auch fest, wie diese zusammenarbeiten, welche Abhängigkeiten erlaubt sind und welche Regeln innerhalb des Systems konsistent gelten sollen.
Wie es zu diesen Unterschieden kam, lässt sich im Nachhinein nicht eindeutig beurteilen. Die Anwendung wurde von einem anderen Team über viele einzelne KI-gestützte Entwicklungsschritte hinweg aufgebaut. Möglicherweise standen zunächst die schnelle Umsetzung fachlicher Anforderungen und andere Prioritäten im Vordergrund. Ebenso denkbar ist, dass mit zunehmendem Umfang der Überblick über bereits getroffene Architekturentscheidungen verloren ging oder das notwendige technische Detailwissen fehlte.
Unabhängig von den Ursachen bleibt das Ergebnis: Ähnliche Anforderungen wurden unterschiedlich umgesetzt. Für die spätere Wartung und Weiterentwicklung bedeutet das zusätzlichen Aufwand, weil bestehende Implementierungen zunächst verstanden und miteinander abgeglichen werden müssen.
Wie viel Raum diese Arbeit im Entwicklungsprozess erhält, hängt allerdings auch davon ab, welche Ziele im Projekt Vorrang haben.
Zwei Geschwindigkeiten innerhalb desselben Projekts
Neben den technischen Schwächen spielt ein weiterer Aspekt eine wichtige Rolle: die Priorisierung unterschiedlicher Qualitätsziele.
Aus Produktsicht stehen zunächst häufig die fachliche Vollständigkeit, Informationssicherheit sowie die betrieblichen und organisatorischen Voraussetzungen im Vordergrund. Die Anwendung soll möglichst zeitnah produktiv eingesetzt werden und den vorgesehenen Nutzen erfüllen.
Aus Sicht der Softwarearchitektur kommen weitere Ziele hinzu, beispielsweise Qualitätsmerkmale wie Wartbarkeit, Änderbarkeit und Testbarkeit. Klare Verantwortlichkeiten und eine langfristig tragfähige Struktur unterstützen dabei, diese Ziele zu erreichen.
Beide Perspektiven sind berechtigt. Die Schwierigkeit entsteht, wenn diese Ziele innerhalb desselben Projekts unterschiedlich stark priorisiert werden.
Während neue Funktionen ergänzt, Fehler behoben und die Voraussetzungen für den Produktivbetrieb geschaffen werden, müssen bestehende technische Strukturen gleichzeitig konsolidiert werden.
So entstehen gewissermaßen zwei parallele Entwicklungsgeschwindigkeiten.
Die fachliche Weiterentwicklung orientiert sich an unmittelbar sichtbaren Ergebnissen. Architekturverbesserungen beanspruchen dagegen häufig Entwicklungszeit, ohne sofort eine neue Funktion bereitzustellen.
Besonders schwierig wird die Situation, wenn Änderungen auf einer bereits inkonsistenten Grundlage erfolgen. Die Umsetzung neuer Anforderungen kann weitere Abhängigkeiten schaffen, während die notwendige Bereinigung der bestehenden Strukturen immer aufwendiger wird.
Damit wächst die Differenz zwischen dem fachlichen Fortschritt und der technischen Konsolidierung.
Dieser Zielkonflikt ist nicht neu und betrifft keineswegs ausschließlich KI-generierte Software. Allerdings kann sich die Dynamik verändern, wenn neue Funktionen mithilfe generativer KI wesentlich schneller entstehen, während ihre technische Integration, Prüfung und langfristige Absicherung weiterhin entsprechende Entwicklungsarbeit erfordern.
Problematisch wird es, wenn den Projektverantwortlichen dieses Ungleichgewicht nicht ausreichend bewusst ist und es deshalb bei der Planung und Priorisierung unberücksichtigt bleibt.
Wenn technische Schulden dauerhaft auf später verschoben werden
Das Zurückstellen technischer Verbesserungen ist zunächst eine normale Entscheidung in der Softwareentwicklung.
Nicht jede Unsauberkeit muss unmittelbar beseitigt werden. Unter Zeit- und Budgetdruck kann es sinnvoll sein, zunächst eine fachlich notwendige Funktion fertigzustellen und eine technische Verbesserung für einen späteren Zeitpunkt vorzusehen.
In der Praxis begegnet einem deshalb häufig die Argumentation, technische Schulden nach Abschluss des Projekts gezielt abzubauen.
Diese Vorstellung setzt allerdings voraus, dass anschließend tatsächlich Zeit und Kapazität dafür bereitgestellt werden.
Genau das ist keineswegs selbstverständlich.
Mit dem Produktivstart endet die fachliche Weiterentwicklung einer Anwendung selten. Häufig warten bereits weitere Anforderungen, ein neues Projekt oder die nächste Idee, die möglichst schnell umgesetzt werden soll.
Die ursprünglich vorgesehene Konsolidierungsphase wird damit erneut verschoben. Neue Funktionen entstehen auf derselben technischen Grundlage, die eigentlich überarbeitet werden sollte.
Daraus kann sich ein dauerhaft wiederkehrender Kreislauf entwickeln.
Mit jeder weiteren Änderung besteht das Risiko, zusätzliche Komplexität aufzubauen. Abhängigkeiten nehmen zu, Anpassungen werden schwieriger und die Wahrscheinlichkeit unerwarteter Nebenwirkungen kann steigen.
Die anfänglich eingesparte Entwicklungszeit wird dadurch bei späteren Änderungen möglicherweise teilweise oder sogar vollständig wieder aufgebraucht.
Besonders problematisch ist dabei, dass Architekturarbeit oft erst dann wieder größere Aufmerksamkeit erhält, wenn die technischen Einschränkungen bereits deutlich spürbar werden — etwa durch längere Entwicklungszeiten, aufwendigere Fehleranalysen oder steigenden Testaufwand.
Zu diesem Zeitpunkt ist eine Bereinigung häufig deutlich schwieriger, als sie es zu einem früheren Zeitpunkt gewesen wäre.
Die wirtschaftliche Konsequenz ist bemerkenswert: Eine Priorisierung, die kurzfristig Entwicklungszeit und Kosten sparen soll, kann langfristig genau das Gegenteil bewirken.
Bei KI-gestützter Entwicklung kann dieser Effekt zusätzlich an Bedeutung gewinnen. Wenn neue Funktionen schneller erzeugt werden können, steigt möglicherweise auch die Erwartung, dass die fachliche Weiterentwicklung kontinuierlich in diesem Tempo erfolgt.
Die technische Konsolidierung konkurriert dann mit einem stetig wachsenden Umfang neuer Anforderungen.
Technische Schulden werden nicht allein dadurch beherrschbar, dass ihr späterer Abbau vorgesehen ist. Entscheidend ist, ob dieser Abbau tatsächlich in der Priorisierung und Entwicklungsplanung berücksichtigt wird.
Das bedeutet nicht, sämtliche Architekturprobleme vor einem Produktivstart beseitigen zu müssen. Vielmehr sollten technische Schwächen hinsichtlich ihrer Auswirkungen bewertet und notwendige Verbesserungen als fester Bestandteil der Weiterentwicklung behandelt werden.
Die Arbeit an der inneren Qualität einer Anwendung darf nicht dauerhaft hinter der Umsetzung neuer Funktionen zurückstehen. Andernfalls besteht die Gefahr, dass die kurzfristig gewonnene Entwicklungsgeschwindigkeit langfristig durch steigenden Wartungs- und Änderungsaufwand wieder verloren geht.
Die Bewährungsprobe beginnt bei der Weiterentwicklung
Die beschriebenen Beobachtungen zeigen nicht, dass KI-generierte Software grundsätzlich von schlechter Qualität ist. Auch lassen sich aus einem einzelnen Entwicklungszusammenhang keine allgemeingültigen Aussagen über die Leistungsfähigkeit generativer KI ableiten.
Sie zeigen jedoch, welche Herausforderungen entstehen können, wenn eine umfangreiche Implementierung schneller wächst, als ihre technischen Entscheidungen überprüft, vereinheitlicht und abgesichert werden.
Eine Anwendung kann fachlich weitgehend vollständig sein, eine überzeugende äußere Architektur besitzen und dennoch erhebliche Inkonsistenzen in ihrer inneren Struktur aufweisen.
Gerade die Beispiele aus der OpenAPI-Implementierung verdeutlichen, dass nicht jede plausible technische Lösung automatisch dem vorgesehenen Vertrag entspricht. Und die unterschiedlichen Umgangsweisen mit DTOs, Entities und Anwendungsschichten zeigen, wie schnell sich lokale Implementierungsentscheidungen zu übergreifenden Architekturproblemen entwickeln können.
Für die langfristige Qualität eines Systems ist deshalb nicht allein entscheidend, wie schnell ein erster Prototyp entsteht.
Entscheidend ist auch, wie zuverlässig, nachvollziehbar und wirtschaftlich sich die Anwendung anschließend betreiben und verändern lässt.
Die eigentliche Bewährungsprobe KI-generierter Software beginnt dort, wo aus einem funktionierenden Prototyp eine dauerhaft verantwortete Anwendung werden soll.
Damit stellt sich eine weiterführende Frage: Wie lässt sich die technische Qualität einer KI-generierten Anwendung systematisch bewerten und so absichern, dass ein Unternehmen Verantwortung für ihren produktiven Betrieb und ihre zukünftige Weiterentwicklung übernehmen kann?