Im April 2000 veröffentlichte Stack-Overflow-Gründer Joel Spolsky einen Aufsatz mit dem Titel „Things You Should Never Do, Part I“. Anlass war die Entscheidung von Netscape, den Code des damaligen Browsers von Grund auf neu zu schreiben, statt den vorhandenen weiterzuentwickeln.
Golo Roden ist Gründer und CTO von the native web GmbH. Er beschäftigt sich mit der Konzeption und Entwicklung von Web- und Cloud-Anwendungen sowie -APIs, mit einem Schwerpunkt auf Event-getriebenen und Service-basierten verteilten Architekturen. Sein Leitsatz lautet, dass Softwareentwicklung kein Selbstzweck ist, sondern immer einer zugrundeliegenden Fachlichkeit folgen muss.
Spolskys These: Diese Entscheidung sei der schlimmste strategische Fehler, den eine Softwarefirma machen könne. Sie beruhe auf einem fundamentalen Missverständnis darüber, was Programmierarbeit eigentlich ist. Programmiererinnen und Programmierer schrieben lieber neu, weil das Lesen fremden Codes mühsam sei und sich das Schreiben produktiv anfühle. Doch dieser Eindruck täusche. Die Verlockung, neu anzufangen, sei eine der teuersten Versuchungen der Branche.
Über 25 Jahre später hat dieser Text nichts von seiner Aktualität verloren. Im Gegenteil. Mit dem Auftauchen von Large Language Models (LLM) hat sich die Asymmetrie zwischen Schreiben und Lesen so verschoben, dass die Frage akut wird, ob wir die eigentliche Senior-Disziplin der Softwareentwicklung systematisch unterschätzen. Das Tippen ist nicht das, was Teams in den nächsten Jahren ihren Atem rauben wird. Das Lesen ist es. In diesem Beitrag möchte ich zeigen, warum das so ist, woher die Asymmetrie kommt, wie sie sich durch generative KI verschärft und wie aus einer beiläufigen Begleitfähigkeit eine eigenständige Disziplin werden müsste.
Der eigene Code wird nach drei Wochen zu fremdem Code
Beim Schreiben hat man alles gleichzeitig im Kopf: die Anforderung, das Datenmodell, die geplante Architektur, die Stelle, an der man gerade arbeitet, die Annahmen, die man trifft, die Trade-offs, die man eingeht. Diese mentale Gesamtsicht macht das Schreiben schnell. Sie ist gleichzeitig das, was beim Lesen fehlt.
Wer drei Wochen später denselben Code wieder vor sich hat, ohne den Kontext mitzubringen, muss diese Gesamtsicht rekonstruieren. Variablennamen geben Hinweise, Tests sagen mehr, ein Pull-Request-Kommentar liefert im Bestfall den fachlichen Anlass, eine Commit-Message mit Glück die letzte Begründung. Die eigentliche Intention, das gedachte Modell, die verworfenen Alternativen, all das ist verloren. Rekonstruieren kostet Zeit und Konzentration, und beides ist teurer als das Schreiben.
Spolskys Anekdote ist deshalb so anschaulich, weil sie diese Asymmetrie auf Organisationsebene zeigt. Bei Netscape stand man vor einer alten Codebasis, die niemand mehr durchschauen wollte. Die Verlockung lag nahe, das Ganze einfach neu zu schreiben. Das Ergebnis ist bekannt: drei Jahre Stillstand, ein verlorener Browser-Markt, eine Firma im Niedergang. Der vermeintlich einfachere Weg war der teuerste.
Auf individueller Ebene zeigt sich dasselbe Muster täglich. Es zeigt sich in Stack-Overflow-Antworten, die statt der Frage einen anderen Lösungsansatz vorschlagen. Es zeigt sich in Kolleginnen und Kollegen, die Refactorings vorschlagen, ohne den vorhandenen Code wirklich verstanden zu haben. Es zeigt sich in der eigenen Versuchung, ein Modul lieber zu ersetzen als zu verbessern. Lesen ist und bleibt unbequem.
LLMs kippen die Bilanz endgültig
Ein modernes LLM erzeugt mehrere Hundert Zeilen Code in der Zeit, in der eine Person diese Zeilen einmal überfliegen kann. Generieren ist billig geworden. Token sind billig, Wartezeiten kurz, und das mentale Modell für die Aufgabe ist auf das Formulieren eines Prompts geschrumpft. Der Aufwand auf der Schreibseite ist faktisch zusammengebrochen.
Auf der Leseseite hat sich nichts geändert. Verstehen kostet noch immer das, was es immer gekostet hat: konzentrierte Aufmerksamkeit, Zeit, Geduld. Die menschliche Verarbeitungsgeschwindigkeit für Code liegt grob bei einigen Zeilen pro Minute, je nach Komplexität deutlich darunter. Diese Größenordnung lässt sich nicht durch Werkzeuge beschleunigen, weil sie an der menschlichen Kognition selbst hängt.
Das Resultat ist eine groteske Verschiebung. Wo früher eine Tagesarbeit etwa hundert Zeilen Code produzierte, die ein Reviewer in einer halben Stunde durchgehen konnte, kann heute eine Stunde Promptarbeit Tausende Zeilen erzeugen. Die zu verstehende Menge wächst dramatisch, die Geschwindigkeit des Verstehens bleibt konstant. Was früher ein Engpass beim Schreiben war, wird zum Engpass beim Verstehen.
Diese Verschiebung wird in vielen Diskussionen ignoriert. Man feiert die Produktivität auf der Generierungsseite und schweigt über die Bilanz, die sich auf der Leseseite auftut. Was nicht gelesen wird, wird nicht verstanden. Was nicht verstanden wird, wird nicht zuverlässig betrieben. Die Schulden verschieben sich nur in die Zukunft, sie verschwinden nicht.
Sichtbar wird das spätestens dort, wo Code-Review-Prozesse, die für die Geschwindigkeit der Vor-LLM-Ära konzipiert waren, plötzlich mit Pull-Requests konfrontiert sind, deren Umfang ein menschlicher Reviewer in einem ganzen Tag nicht durchdringen könnte. Die Reaktion ist meistens nicht eine vertiefte Auseinandersetzung, sondern ein verkürztes Daumen-hoch. Damit verlagert sich der Code-Review von einem inhaltlichen zu einem zeremoniellen Schritt, und genau in dieser Verlagerung entstehen die Probleme, die später teuer werden.
Die Abhängigkeitsspirale
Eine ambitionierte Schule propagiert, die Beschäftigung mit Code werde überflüssig: Mit genug Skills, Harness-Engineering und einer präzisen Markdown-Spezifikation lasse sich die Arbeit vollständig auf die Spec-Ebene verlagern. Der generierte Code sei eine Implementierungsfrage, die niemand mehr ansehen müsse. Diese Vorstellung wird mit Anlauf gegen eine Wand laufen.
Wer Code nur generiert, ohne ihn zu lesen, hat von Anfang an fremden Code vor sich. Reviewen geht nicht, Fehler suchen geht nicht, beides setzt Verstehen voraus. Mit jeder weiteren Generierung wächst die Codebasis schneller, als sie sich durchdringen lässt. Die Lücke zwischen „vorhanden“ und „verstanden“ öffnet sich in atemberaubender Geschwindigkeit, und mit ihr die Anzahl der Stellen, an denen man später fragen muss, was hier eigentlich passiert.
Die einzige verbliebene Instanz, die diesen Code noch erklären, prüfen oder reparieren kann, ist die KI selbst. Damit ist man ironischerweise auf genau das System angewiesen, das die Lage herbeigeführt hat. Aus einem Werkzeug wird eine Abhängigkeit, aus einer Beschleunigung eine Falle. Wer keine eigene Verstehenskompetenz aufbaut, hat nur noch eine externe und entscheidet über diese externe Kompetenz nicht mehr selbst.
Dieses Muster ist nicht neu, neu ist nur seine Geschwindigkeit. Ein Team besitzt eine unzugängliche Codebasis nicht mehr. Im klassischen Fall geschah die Unzugänglichkeit über Jahre, durch personelle Wechsel und unzureichende Dokumentation. Im KI-gestützten Fall kann das innerhalb weniger Monate geschehen, weil die Generierungsgeschwindigkeit die Aufnahmegeschwindigkeit hoffnungslos übersteigt.
Der typische Auslöser ist nicht spektakulär. Ein Bug taucht in Produktion auf, niemand im Team versteht den betroffenen Code, also befragt man die KI. Die KI liefert eine Erklärung und einen Fix, beides plausibel, beides ungeprüft. Im günstigen Fall stimmt es. Im weniger günstigen baut man neue Schulden auf alte und merkt es erst, wenn der nächste Bug genau in dieser Schicht entsteht. Aus Reparatur wird Übermalung.
Was zunächst wie eine Befreiung wirkt, ist also eine Verlagerung der Last. Statt selbst zu schreiben, formuliert man Prompts. Statt selbst zu verstehen, fragt man die KI. Beides scheint produktiv. Beides erodiert die Souveränität über die eigene Codebasis.
English (US) ·