Fundierte Artikel über Technologien, die das Kommende formen.

KI-Coding-Assistenten: 5 Mythen im Test

KI-Coding-Assistenten beschleunigen das Tippen, nicht die Softwarequalität. Fünf Mythen im Test gegen die echten Engpässe: Design, Verifikation und Komplexität.

Ein Roboterarm überschwemmt einen Fabrikboden mit leuchtenden Ziegeln, die sich vor einem einzigen schmalen Prüftor stapeln.
Die Erzeugung ist schnell geworden. Die Prüfung nicht – und der Durchsatz wird von der langsamsten Stufe bestimmt.

Jonathan Blow – der Designer hinter Braid und The Witness, und ein Mann, stur genug, um ein Jahrzehnt in seine eigene Programmiersprache zu investieren – hat kürzlich eine Frage gestellt, die jeden Anbieter von KI-Coding-Assistenten wehtun sollte: Wenn KI das Programmieren gelöst hat, warum ist meine Software dann immer noch dieselbe? Dieselben Abstürze. Dieselben aufgeblähten Updates. Dieselben jahrzehntealten Klagen, dass Apps RAM fressen und dabei weniger können als die Tools, die sie ersetzt haben. Der übliche Einwand – warte einfach sechs Monate – greift nicht wirklich, und ich finde nicht, dass Blow unrecht hat, wenn er an dieser wunden Stelle bohrt.

Hier meine Position, nach Jahren im Bau von ML-Systemen und dem Beobachten, wie diese Tools in echten Teams ankommen: KI-Coding-Assistenten sind inzwischen wirklich gut, und sie haben die Software, die du und ich jeden Tag benutzen, trotzdem kaum verbessert. Beides stimmt gleichzeitig, und der Grund ist, dass die Tools nie auf den eigentlichen Engpass gezielt haben. Am klarsten wird das, wenn man die fünf Annahmen, die ich am häufigsten höre, einzeln überprüft.

Mythos 1: Tippen ist der Engpass bei der Softwareentwicklung

Die Argumentation liegt auf der Hand: Programmieren heißt, Code zu produzieren. Eine Maschine, die Code zehnmal schneller produziert, macht Software also zehnmal schneller. Ein sauberer Syllogismus mit einem Haken – kaum jemandes Arbeit sieht so aus. Es gibt eine alte Faustregel, bekannt geworden durch Clean Code, nach der Entwickler deutlich mehr als zehnmal so lange Code lesen wie schreiben. Dieses Verhältnis ist fünfzehn Jahre älter als LLMs, aber jede ernsthafte Untersuchung, wie Ingenieurstunden verbraucht werden, landet am selben Punkt: Das bestehende System verstehen, sich mit anderen Menschen abstimmen, auf Entscheidungen warten. Die Anschläge auf der Tastatur sind eine Rundungsdifferenz.

Das spürt man in der eigenen Woche. Autovervollständigung spart echte Minuten – ich würde sie nie wieder hergeben –, aber meine harten Tage waren nie hart, weil ich nicht schnell genug tippen konnte. Sie waren hart, weil der Payment-Service eine Invariante hatte, die niemand aufgeschrieben hat, oder weil sich drei Teams uneins waren, was die API eigentlich versprechen soll. Die Stufe zu beschleunigen, die gar nicht der langsame Teil war, bringt für den Gesamtdurchsatz fast nichts. Eine Fabrik, die Teile schneller stanzt, als die Prüflinie sie abarbeiten kann, liefert nicht mehr Produkt aus. Sie produziert nur einen größeren Stapel Teile.

Es gibt eine Stelle, an der Tippen tatsächlich der Engpass ist: Greenfield-Arbeit ohne bestehendes System, das man respektieren muss. Boilerplate, Prototypen, Wegwerfskripte, die erste Version von allem. Genau deshalb wirken die Demos wie Magie – Demos sind immer Greenfield. Produktive Softwareentwicklung ist fast durchweg Brownfield, und Brownfield-Arbeit ist Lesearbeit.

Mythos 2: KI-generierter Code kommt bereits verifiziert

Die optimistische Version des Workflows geht so: Aufgabe beschreiben, das Modell schreibt den Code, die Tests laufen durch, mergen. Der Haken steckt in der Mitte. Tests laufen durch sagt nur, dass die Tests, die dir eingefallen sind, mit dem Code übereinstimmen, den sich das Modell ausgedacht hat. Beide können in dieselbe falsche Richtung danebenliegen, und bei LLM-Output passiert das oft – das Modell liefert flüssigen, idiomatischen, selbstsicheren Code, und genau diese Flüssigkeit entwaffnet das Review.

Ein kleines Beispiel, das ich in freier Wildbahn gesehen habe, sinngemäß, wenn auch nicht wortwörtlich. Bittet man um einen monatlichen Job-Scheduler, bekommt man etwa Folgendes:

from datetime import datetime
def next_monthly_run(day: int, hour: int = 9) -> datetime:
"""Next run time for a job that fires monthly on `day`."""
now = datetime.now()
candidate = now.replace(day=day, hour=hour, minute=0, second=0, microsecond=0)
if candidate <= now:
# Roll forward one month
month = now.month % 12 + 1
year = now.year + (1 if now.month == 12 else 0)
candidate = candidate.replace(year=year, month=month)
return candidate

Lies es so, wie du den Pull Request eines Kollegen liest. Es ist idiomatisch. Es behandelt den Jahreswechsel. Der Docstring stimmt sogar. Jetzt führe es am 15. April mit day=31 aus: now.replace(day=31) wirft ValueError, weil der April keinen 31. hat. Die Funktion stürzt ausgerechnet bei der häufigsten Scheduling-Anforderung ab – Monatsende – und nur in kürzeren Monaten. Sie kann also wochenlang gesund in der Produktion laufen, bevor jemand etwas merkt. Ein Test, der ein ganzes Jahr an now-Werten durchläuft, findet das in Sekunden. Ein sorgfältiger menschlicher Reviewer findet es vielleicht in der Hälfte der Fälle. Diese Lücke ist das Verifikationsproblem im Kleinen.

Deshalb argumentiere ich immer wieder, dass in einem KI-lastigen Workflow die Wahl zwischen Verständnisprüfungen und Tests keine akademische Frage ist – sie ist der ganze Kern. Code zu lesen, den man nicht selbst geschrieben hat, ist schon schwerer als ihn zu schreiben. Code zu lesen, den kein Mensch geschrieben hat, und das in dem Umfang, den diese Tools produzieren, stellt die Ökonomie des Reviews komplett auf den Kopf. Die Teams, mit denen ich spreche, haben keinen Mangel mehr an Code. Ihnen fehlen Leute, die verstehen, was der Code tut, und bereit sind, mit ihrem Namen dafür geradezustehen.

Eine Lupe macht einen haarfeinen Riss quer über eine polierte Marmorplatte sichtbar.
Plausibler Code versagt wie Marmor: entlang eines Risses, den man nur sieht, wenn man genau hinschaut.

Mythos 3: Billigerer Code macht Softwaredesign billig

Eine subtilere Annahme: Wenn Code fast nichts kostet, ist Architektur weniger wichtig, denn wir können immer neu schreiben. Schlechte Abstraktion? Neu generieren. Falsches Datenmodell? Das generieren wir auch neu. Ich habe erfahrene Ingenieure das mit ernster Miene sagen hören, und es verwechselt die Kosten für das Ändern von Text mit den Kosten für das Ändern von Entscheidungen.

Der schwierige Teil von Software war nie der Code. Es geht darum zu entscheiden, was es überhaupt wert ist, gebaut zu werden, eine chaotische menschliche Domäne in etwas zu modellieren, das eine Maschine ausführen kann, und architektonische Wetten einzugehen, die nicht zusammenbrechen, wenn sich Anforderungen ändern – und das tun sie immer. Das sind Probleme der Absicht und der Werte, nicht der Mustervervollständigung. Ein Modell, das auf dem Korpus bestehender Software trainiert wurde, kann dir sagen, wie Systeme wie deines üblicherweise aussehen. Es kann dir nicht sagen, wie deines aussehen sollte, denn diese Antwort steckt in deinen Nutzern, deinen Randbedingungen und der Risikobereitschaft deiner Organisation. Hier sind wir praktisch nicht vorangekommen, und ich würde behaupten, dass es keine Fähigkeitslücke ist, die man durch Skalierung schließt. Es ist ein Kategorienfehler.

Umbauen ist auch nicht kostenlos. Der größte Teil des Ingenieurbudgets fließt in Änderungen an bestehenden Systemen, und eine Änderung erfordert zuerst, die Absicht zu rekonstruieren, die im System steckt – die nie dokumentierten Invarianten, den Edge Case, der sich als tragend für einen wichtigen Kunden herausstellt. Das Modell kennt diese Absicht nicht. Oft kennt sie auch das Team nicht. Das ist die Lücke zwischen Spezifikation und Implementierung, in der Bugs tatsächlich leben, und mehr Implementierung zu erzeugen vergrößert sie, solange niemand die Spezifikation eng im Griff hat.

Fred Brooks hatte einen Begriff dafür, was Software kohärent macht: konzeptionelle Integrität – das Gefühl, dass ein Geist oder einige wenige abgestimmte Köpfe die Entscheidungen getroffen haben. Flüssige Codegenerierung bringt uns dem nicht näher. Im Gegenteil: Sie macht tausend unabgestimmte Mikroentscheidungen billiger, und genau so entstehen Systeme, die designt aussehen und sich zusammengesteckt anfühlen.

Mythos 4: Unveränderte Software beweist, dass KI-Coding gescheitert ist

Jetzt das Gegenargument, denn Blows Rahmung ist auch nicht unangreifbar. Schaut man über kommerzielle Massensoftware hinaus, bewegt sich durchaus etwas. Die Indie-Spieleszene hat Strategiespiele mit eigenen Engines hervorgebracht – von winzigen Teams –, für die man vor einem Jahrzehnt Blizzards Personalstärke gebraucht hätte. Noch auffälliger finde ich den stillen Aufstieg persönlicher Software: Leute bauen sich ihre eigenen E-Mail-Clients, Kalender-Apps, Finanz-Tracker und Git-Frontends, genau zugeschnitten auf die Art, wie sie denken. Diese Tools sind roh und würden es nie schaffen, an zehntausend Fremde ausgeliefert zu werden. Aber sie existieren, sie werden täglich benutzt, und vorher hätte sich ihr Bau schlicht nicht gelohnt.

Auch Institutionen verändern sich auf eine Weise, die die Schlagzeilen-Metrik übersieht. Ich kenne Organisationen, deren Modernisierungsplan im Kern lautet: das Legacy-System über vernünftige APIs freilegen und die Mitarbeitenden mit einem agentischen Coding-Tool eigene Endpunkte und Oberflächen darauf bauen lassen. Das ist nicht »meine Software sieht gleich aus«. Das ist Software, die in etwas Persönlicheres aufgeht – unsichtbar, wenn man nur auf die App-Store-Charts schaut.

Der tiefere Grund, warum Blows Beobachtung sich richtig anfühlt, ist aber organisatorisch, nicht technisch. Kommerzielle Software wird davon geprägt, was Unternehmen optimieren – Engagement, Lock-in, Release-Rhythmus, Supportkosten –, und KI liefert dir mehr von dem, was du ohnehin willst, und das schneller. Sie ändert nicht, was du willst. Ein Unternehmen, das aufgeblähte Software ausgeliefert hat, weil Bloat nicht auf seiner Kostenliste stand, wird nun aufgeblähte Software in kürzeren Entwicklungszyklen ausliefern. Die Qualitätslatte für Software, die Tausende Nutzer erreicht, wird durch Anreize, Testdisziplin und Geschmack gesetzt – und nichts davon ist eine Modellausgabe.

Dazu kommt ein schlichtes Verzögerungsargument. Verlässlich brauchbares KI-Coding ist vielleicht ein Jahr alt; davor war es wacklig, und davor war es ein Spielzeug. Produkte brauchen Jahre, um konzipiert, gebaut und ausgeliefert zu werden. Die Wirkung dieser Tools auf ausgelieferte Software jetzt zu beurteilen, ist, als würde man einen neuen Pflug nach der Ernte beurteilen, die einen Monat nach seiner Erfindung eingefahren wurde.

Mythos 5: Das nächste Modell schließt die Lücke

Die stärkste Form des optimistischen Arguments: Alle Einwände oben beschreiben die heutigen Modelle, und die heutigen Modelle sind die schlechtesten, die wir je nutzen werden. Teilweise stimmt das. Kontextfenster werden größer, halluzinierte APIs werden seltener, Agenten werden besser darin, ihre eigenen Tests auszuführen. Ich erwarte echte Fortschritte, besonders bei gut spezifizierten Aufgaben.

Aber schau, welche Engpässe Fähigkeitsprobleme sind und welche nicht. Verifikation wird leichter, wenn Modelle verlässlicher werden – das ist Fähigkeit. Entscheiden, was sich zu bauen lohnt, konzeptionelle Integrität halten, verändern, was eine Organisation optimiert – das steht auf keiner Modell-Roadmap, weil es keine Modellprobleme sind. Und sei vorsichtig, Benchmark-Fortschritte als Beleg zu nehmen: Benchmarks verfehlen den größten Teil dessen, wie echte Arbeit aussieht, und echte Arbeit ist genau die unterspezifizierte, absichtsgeladene Sorte.

Also hier meine Wette, schwarz auf weiß: Die Tools werden für einzelne Entwickler und kleine Teams mit gutem Geschmack dramatisch besser, und Massensoftware wird allenfalls marginal besser – weil dort der Engpass nie der Code war. Wenn das pessimistisch klingt, ist es das nicht. Es heißt, dass der Hebel in deinen Händen und in deinem Organigramm liegt, nicht im nächsten Release eines Labors.

Ein Gärtner schneidet an einer sonnigen Werkbank mit Handwerkzeug einen Bonsai zurecht.
Softwarequalität ist nach wie vor ein Pflegeproblem, kein Produktionsproblem.

Was die Softwarequalität tatsächlich verbessert

Wenn Erzeugung billig und Verifikation teuer ist, besteht die rationale Antwort darin, Investitionen zu verschieben. Konkret:

  • Tests und Typen als Produktionsinfrastruktur behandeln. Property-based Tests, Invariantenprüfungen und schnelles CI machen aus billiger Generierung billige korrekte Generierung. Plane dafür ein Budget ein, so wie du es für Rechenleistung tust.
  • Erst die Spezifikation schreiben, dann den Prompt. Die Spezifikation ist inzwischen das wirkungsvollste Artefakt, das ein Team hervorbringt, denn sie ist das, was das Modell nicht liefern kann, und das, woran Reviewer prüfen.
  • KI dort einsetzen, wo sie wirklich stark ist: Greenfield-Prototypen, Migrationen, Boilerplate, persönliche Werkzeuge, schnelles Erkunden eines Designraums. Sei misstrauisch in tragenden Legacy-Pfaden, in denen die Absicht undokumentiert ist.
  • Designzeit schützen. Wenn sich die Erzeugungsgeschwindigkeit verdreifacht, ist der Druck groß, die Roadmap dreimal zu füllen. Widerstehe dem. Das Entscheiden ist die Arbeit.

Der Engpass war nie das Tippen. Er war immer das Entscheiden – und das Beweisen.

Blows Frage hat eine Antwort, und wenn man sie richtig liest, ist sie eine hoffnungsvolle. Software sieht gleich aus, weil Softwarequalität schon immer vom Entscheiden, Verifizieren und Sorgfalt abhing – und KI-Coding-Assistenten beschleunigen bei aller echten Nützlichkeit den Teil, der nie langsam war. Die Werkzeuge, mit denen Software besser wird, sind deshalb dieselben wie immer: Geschmack, Spezifikation und die Disziplin, Dinge zu beweisen. Die Modelle haben es nur unmöglich gemacht, so zu tun, als wäre es anders.