Die Demo funktioniert immer

Jede KI-Coding-Demo folgt demselben Ablauf. Jemand promptet ein Modell. Eine funktionierende App materialisiert sich. Das Publikum ist beeindruckt.

Und das sollte es auch sein. Die Geschwindigkeit ist real. Die Fähigkeit ist real. Version Eins wird mit KI in der Schleife tatsächlich schneller ausgeliefert.

Das Problem ist, dass Version Eins nie der schwierige Teil war.

Wo die Kosten tatsächlich liegen

Die Kosten der Softwareentwicklung konzentrieren sich nicht bei der initialen Erstellung. Sie konzentrieren sich bei Iteration Vier, Fünf und Sechs:

  • Der Auth-Provider muss gewechselt werden, weil sich die Preisgestaltung geändert hat.
  • Analytics muss umziehen, weil der Anbieter übernommen wurde.
  • Ein Feature muss hinzugefügt werden, das drei Screens berührt, die bei der ursprünglichen Generierung nie vorgesehen waren.
  • Ein Styling-System muss ersetzt werden, weil der Designer die Richtung geändert hat.
  • Eine Zahlungsintegration muss getauscht werden, weil das Produkt in einen neuen Markt expandiert hat.

Nichts davon sind Fehler der initialen Generierung. All das ist normale Produktentwicklung. Die Frage ist, ob die Codebase diese Änderungen günstig oder teuer macht.

Die KI-generierte Codebase unter Änderungsdruck

Die meisten KI-generierten Codebases bewältigen die erste Änderung problemlos. Die zweite Änderung ist unbequem. Bei der vierten Änderung berichten Teams von denselben Symptomen:

  • „Wir haben die KI gebeten, den Auth-Provider zu tauschen, aber es hat 14 Dateien berührt.”
  • „Der Refactor hat Tests in Modulen gebrochen, die eigentlich unzusammenhängend sein sollten.”
  • „Wir können nicht erkennen, welche Teile des Systems vom Analytics-SDK abhängen.”
  • „Jede Änderung erfordert, die gesamte Codebase neu zu verstehen.”

Diese Symptome sind keine Modellfehler. Es sind Architekturfehler. Das Modell hat ein System ohne Grenzen generiert, und nun hat jede Änderung einen unvorhersehbaren Wirkungsradius.

Warum KI-Codebases schneller degenerieren

Traditionelle Codebases degenerieren auch. Aber KI-generierte Codebases degenerieren aus spezifischen Gründen schneller:

Kein gemeinsames mentales Modell. Ein menschliches Team baut über Monate strukturelle Intuition auf. Eine KI generiert Code ohne Erinnerung daran, warum frühere Entscheidungen getroffen wurden.

Optimierung für den unmittelbaren Prompt. Modelle lösen die aktuelle Anfrage. Sie optimieren nicht für die nächsten fünf Anfragen. Jede Generierung trifft lokal korrekte Entscheidungen, die global inkohärent sind.

Volumen verstärkt Kopplung. KI generiert mehr Code schneller. Mehr Code mit schwachen Grenzen bedeutet mehr Kopplung, schneller. Der Geschwindigkeitsvorteil wird zum Degradationsbeschleuniger.

Refactoring erfordert globalen Kontext. Modelle haben Schwierigkeiten mit Refactors, die die gesamte Codebase umspannen, weil Kontextfenster endlich und architektonische Absichten implizit sind.

Die eigentliche technische Herausforderung

Die eigentliche technische Herausforderung in der AI-native-Entwicklung ist nicht „Wie generiere ich besseren Code?”

Sie ist „Wie strukturiere ich das System so, dass KI-generierte Teile unabhängig geändert werden können?”

Das bedeutet:

  • Grenzen, die den Wirkungsradius vorhersagbar machen.
  • Interfaces, die entkoppeln, was sich ändert, von dem, was bleibt.
  • Composition Roots, die Abhängigkeitsgraphen explizit machen.
  • Contract Tests, die Integration verifizieren, ohne das gesamte System zu erfordern.
  • Die Fähigkeit, jeden generierten Teil isoliert zu löschen und neu zu generieren, ohne kaskadierende Fehler.

Langfristige Wartung ist ein strukturelles Problem

Kein noch so gutes Prompting repariert eine Codebase, in der Teile des Systems direkt in andere Module greifen. Man kann sich nicht mit Prompts aus architektonischer Kopplung herausarbeiten.

Langfristige Wartung von KI-Codebases erfordert dieselbe Disziplin, die sie schon immer erfordert hat: Grenzen, Contracts und Isolation. Der Unterschied ist, dass KI-Geschwindigkeit das Fehlen dieser Disziplinen schneller sichtbar macht. Ein Team, das zwei Jahre gebraucht hätte, um einen unwartbaren Monolithen zu erzeugen, kann das jetzt in zwei Monaten schaffen.

Die Geschwindigkeit ist ein Geschenk und eine Falle. Ohne Struktur bedeutet sie nur, dass man schneller bei der Wartungskrise ankommt.

Die Verbindung zu AI-native-Architektur

Dies ist das Kernargument, das ich in Stanford CS146S Is Right About AI Coding — The Missing Subject Is Architecture vorgebracht habe: Werkzeugkompetenz ohne architektonische Disziplin erzeugt Codebases, die schnell zu erstellen und teuer zu warten sind.

Der moderne Softwareentwickler braucht beides. Die KI-Werkzeuge, um schnell auszuliefern. Die architektonische Disziplin, um nach Version Eins weiterhin schnell auszuliefern.

Version Eins war nie das Problem. Das Problem ist, ob Version Fünf immer noch günstig ist.

FAQ

Warum werden KI-generierte Codebases schwer wartbar?

KI-Modelle optimieren für den unmittelbaren Prompt, nicht für zukünftige Änderungen. Das erzeugt Code, der funktioniert, aber die Grenzen vermissen lässt, die für unabhängige Modifikation nötig sind. Ohne explizite architektonische Einschränkungen akkumuliert Kopplung schneller als in handgeschriebenen Codebases, weil KI mehr Code schneller generiert.

Wie verhindert man die Degradation einer KI-Codebase über die Zeit?

Drei strukturelle Praktiken: Grenzen zwischen Modulen mit Interfaces durchsetzen, die der Anwendung gehören, Abhängigkeitsverdrahtung in einem Composition Root zentralisieren und Contract Tests ausführen, die Integrationspunkte unabhängig verifizieren. Diese machen Änderungskosten vorhersagbar, unabhängig davon, wie der Code generiert wurde.

Ist KI-generierter Code schwerer zu refactoren als menschlich geschriebener Code?

Nicht grundsätzlich. Aber KI-generierter Code hat mit höherer Wahrscheinlichkeit keine strukturellen Grenzen, die Refactoring sicher machen, weil Modelle nicht spontan für zukünftige Änderungen optimieren. Die Lösung besteht darin, diese Grenzen vor der Generierung aufzuerlegen, anstatt zu hoffen, dass das Modell sie von selbst erzeugt.

Was ist das größte Risiko von KI-Coding für langfristige Projekte?

Das größte Risiko ist die Geschwindigkeitsfalle: So schnell in der frühen Phase auszuliefern, dass sich Architekturschulden ansammeln, bevor das Team es bemerkt. Wenn die Wartung teuer wird, ist die Codebase zu stark gekoppelt, um sie inkrementell zu reparieren.