Programmierer im Zeitalter der AI: Vom Code-Generieren zur Kontrolle von Nichtdeterminismus

Zusammenfassung

• Während AI einen erheblichen Teil der Code-Erstellung automatisiert, verlagert sich die Kernrolle von Entwicklern von der direkten Implementierung hin zu Entwurf, Verifikation und Kontrolle.
• Das Wesen des Programmierers besteht nicht darin, viel Code einzugeben, sondern darin, die Details unklarer Anforderungen auszuarbeiten und in eine wiederverwendbare Form zu abstrahieren.
• Statt der AI detaillierte Implementierungsmethoden vorzugeben, ist es effektiver, Ziele und Kontext zu vermitteln und ihr die Beurteilung zu überlassen.
• AI-Arbeit sollte nicht in einem einzigen Durchgang erledigt werden; die Qualität steigt, wenn Ergebnisse in Spezifikation, Tests, Implementierung, Refactoring und Verifikation getrennt werden.
• Da die Ausgaben von AI nichtdeterministisch sind, braucht es deterministische Harnesses wie Tests, Compiler, Linter und Verifikations-Gates.
• Künftige Entwickler werden voraussichtlich weniger reine Code-Schreiber sein als vielmehr Systemdesigner und Harness-Ingenieure, die AI-Agenten und Verifikationssysteme miteinander verbinden.

---

Einleitung

Die von AI erschütterte Identität des Entwicklers

• Da AI allein auf Basis natürlichsprachlicher Anweisungen Hunderte Zeilen Code erzeugt, verändern sich die Maßstäbe für klassische Entwicklungskompetenz.

• Früher galt die Fähigkeit, in einem leeren Editor schnell Code zu schreiben, als zentrale Wettbewerbsstärke von Entwicklern.

• Heute, da AI Wissen und Implementierungsmethoden liefert, stellen sich Fragen wie diese.

  • Kann man noch von Entwicklung sprechen, wenn man den Code nicht selbst schreibt.
  • Welche Rolle bleibt dem Entwickler, wenn AI die Implementierungsdetails übernimmt.
  • Sind traditionelles Informatikwissen und die Geschichte der Programmierung auch heute noch notwendig.

• Der Beitrag erklärt diese Fragen entlang der Begriffe Details, Abstraktion, Nichtdeterminismus und Harness.

Die Bedeutung der Programmiergeschichte

• Früheres Programmierwissen ist nicht bloß eine Liste von Techniken, sondern der Prozess, in dem damalige Entwickler Probleme lösten und neue Abstraktionsebenen schufen.
• Maschinensprache, Assemblersprache, strukturierte Programmierung, Objektorientierung und Frameworks sind Ergebnisse, die geschaffen wurden, um die Komplexität tieferer Ebenen zu verbergen.
• Auch wenn man alte Technologien nicht mehr direkt verwendet, hilft das Verständnis ihrer Geschichte dabei zu erkennen, wie sich die Rolle von Entwicklern wiederholt verändert hat.

---

Hauptteil

1. Entwickler sind Menschen, die Details konkretisieren

• Planung gibt in der Regel den Zweck eines Produkts und die grobe Richtung vor, benennt aber nicht alle Bedingungen, die für die tatsächliche Implementierung nötig sind.

• Selbst bei einer scheinbar einfachen Funktion wie „Nickname ändern“ gibt es zum Beispiel folgende Detailbedingungen.

  • Ob leere Zeichenfolgen erlaubt sind
  • Wie Sonderzeichen und Emojis behandelt werden
  • Umgang mit Netzwerkfehlern und verzögerten Antworten
  • Verhalten beim Verlassen des Bildschirms während der Bearbeitung
  • Position und Darstellung von Fehlermeldungen

• Die Arbeit des Entwicklers besteht darin, solche Lücken in logische Regeln und Ausnahmebehandlungen zu übersetzen.

• Die Professionalität von Entwicklern liegt daher weniger in der bloßen Funktionsimplementierung als in der Fähigkeit, unklare Anforderungen in ein vollständig definiertes Systemverhalten zu überführen.

2. Abstraktion ist der Prozess, gelöste Details zu verbergen

• Entwickler verpacken einmal gelöste Probleme als Funktionen, Module, Bibliotheken oder Frameworks, um Wiederholungsarbeit zu reduzieren.

• Der Kern von Abstraktion ist folgender.

  • Wiederkehrende interne Abläufe werden verborgen.
  • Nur die nach außen benötigten Funktionen werden offengelegt.
  • Die Grenze zwischen veränderbaren und festzulegenden Teilen wird definiert.

• Wenn sich robuste Abstraktionen ansammeln, entstehen neue Ebenen, und Entwickler auf höheren Ebenen können arbeiten, ohne alle Implementierungsdetails der unteren Ebenen zu kennen.

• Die heutige Entwicklungsumgebung funktioniert auf Abstraktionsebenen, die von früheren Entwicklergenerationen aufgebaut wurden.

3. Welche Tiefe Entwickler brauchen, hängt von ihrer Position ab

• Nicht jede Abstraktion ist bereits abgeschlossen.

• Eine Ebene, die ihre internen Implementierungen stabil verbirgt, kann als „abgeschlossene Abstraktion“ gelten.

• Eine Ebene, bei der interne Details weiterhin in Form von Performance-Problemen oder Fehlern nach außen dringen, ist eine „Abstraktion im Werden“.

• Selbst bei derselben Technologie unterscheidet sich der Zustand je nach Rolle des Entwicklers.

  • Für allgemeine Webentwickler ist der Browser eine relativ abgeschlossene Ebene.
  • Für Entwickler von Browser-Engines ist der Rendering-Prozess ein Detailproblem, das direkt behandelt werden muss.

• Die erforderliche Tiefe für Entwickler bedeutet nicht, alles über jede Technologie zu wissen, sondern Lecks und Grenzen der Ebene zu verstehen, für die man verantwortlich ist.

4. AI ist als neue Abstraktionsebene hinzugekommen

• AI erledigt Code-Schreiben und wiederholte Implementierung, die Entwickler bisher direkt ausführen mussten, sehr schnell.
• Dadurch beginnt AI, über ein reines Produktivitätswerkzeug hinaus als neue Ebene zu wirken, die den Entwicklungsprozess selbst abstrahiert.
• Dass AI Code generiert, bedeutet jedoch nicht, dass Anforderungsinterpretation, Architekturentwurf, Qualitätsverifikation und Betriebsverantwortung automatisch gelöst sind.
• Im Gegenteil: Da die Kosten der Implementierung sinken, wird die Bedeutung der Kosten für das Zusammensetzen und Verifizieren des generierten Codes größer.

5. Detaillierte Anweisungen können die Leistung von AI einschränken

• Der Autor versuchte bei einem Accessibility-UI-Side-Project, ohne eigenes Tippen und nur mit AI zu entwickeln.

• Anfangs gab er der AI konkrete Implementierungsmethoden vor, doch die AI verharrte auf diesen Ansätzen und fügte wiederholt Ausnahmebehandlungen hinzu.

• Das Ergebnis war komplexerer Code mit verschiedenen Nebenwirkungen, während passendere Standardmethoden erst später angewendet wurden.

• Dieser Fall zeigt, dass die vom Nutzer zuerst vorgegebene Methode als Anker wirken und das Urteilsvermögen der AI einschränken kann.

• Effektiver ist es, statt Lösungsweg und Codestruktur zu stark vorzuschreiben, Folgendes bereitzustellen.

  • Hintergrund und Ziel des Problems
  • Kontext des aktuellen Systems
  • Ergebnisse, die unbedingt erfüllt werden müssen
  • Einschränkungen, die nicht verändert werden dürfen

6. Statt Anweisungen sollten Ziel und Kontext delegiert werden

• Je leistungsfähiger AI wird, desto wirksamer kann eine zielorientierte Delegation sein als die direkte Vorgabe detaillierter Abläufe.

• Bei dieser Form der Delegation legt der Entwickler nicht vollständig fest, „wie“ etwas implementiert wird, sondern vermittelt klar, „warum“ es nötig ist und „was“ erreicht werden muss.

• Gibt man jedoch vollständige Autonomie, kann sich AI eher auf Code-Änderungen selbst als auf die eigentliche Absicht des Nutzers konzentrieren.

• Deshalb muss das Verfahren so begrenzt werden, dass AI zunächst die folgenden Schritte ausführt.

  • Analyse der Anfrageabsicht
  • Rückfragen zu fehlenden Informationen
  • Vorschlag eines Lösungsplans
  • Ausführung erst nach Zustimmung des Nutzers

• Entscheidend ist weniger ein bloßes Verbot als vielmehr, die in der aktuellen Phase zulässigen Ergebnisse klar festzulegen.

7. Pro Aufgabe sollte nur ein Ergebnis definiert werden

• Ein LLM ist in Umfang und Denkbreite dessen, was es in einer einzelnen Antwort leisten kann, begrenzt.

• Wenn man gleichzeitig Tests und Implementierung anfordert, konzentrieren sich die Ressourcen auf das Endziel der Code-Fertigstellung, wodurch die Testqualität sinken kann.

• Der Autor trennt TDD-Arbeit wie folgt.

  • /red: nur fehlschlagende Tests schreiben
  • /green: minimale Implementierung schreiben, die die Tests besteht
  • /refactor: Codestruktur verbessern, während die Tests erhalten bleiben

• Wenn das Ergebnis jeder Phase auf genau eines begrenzt wird, verringert sich das Problem, dass AI Zwischenschritte auslässt oder nur formal abarbeitet.

• Das bedeutet: Im Zentrum des Prompt-Designs steht nicht die langatmige Beschreibung eines Verhaltens, sondern die Definition des Ergebnisses, das in einer einzelnen Aufgabe erzeugt werden soll.

8. Markdown-Dokumente und Skills werden zum neuen Code

• Trennt man Spezifikation, Tests, Implementierung, Verifikation und Commit-Arbeit in einzelne Skills, lässt sich eine Pipeline wie die folgende aufbauen.

  • Spezifikation schreiben
  • Fehlgeschlagene Tests erzeugen
  • Funktion implementieren
  • Refactoring
  • Verifikation
  • Commit

• Da jeder Skill Eingaben, Ausgaben und Einschränkungen hat, funktioniert er ähnlich wie eine Funktion.

• Markdown-Dokumente, die Skills und Regeln festhalten, sind nicht bloß Anleitungen, sondern wirken als ausführbare Regeln, die das Verhalten der AI bestimmen.

• Dabei lassen sich auch klassische Prinzipien des Software-Designs anwenden.

  • Das Single-Responsibility-Prinzip, bei dem jedem Skill nur eine Verantwortung gegeben wird
  • Modularisierung, bei der Wissen und Regeln in getrennte Dateien ausgelagert werden
  • Das Open-Closed-Prinzip, bei dem Kern-Skills unverändert bleiben und über externe Wissensdateien erweitert werden

• Nur die Plattform hat sich vom IDE zum Markdown-Dokument verschoben; das Zerlegen und Verbinden von Arbeit bleibt weiterhin Programmierung.

9. Das zentrale Risiko beim AI-Coding ist Nichtdeterminismus

• Traditionelle Programme liefern bei gleicher Eingabe im Allgemeinen die gleiche Ausgabe.

• AI kann selbst bei derselben Anfrage unterschiedlichen Code und unterschiedliche Bewertungen erzeugen.

• Wenn AI ein groß angelegtes Refactoring durchführt, bleiben selbst bei funktionierendem Ergebnis noch folgende Probleme.

  • Prüfung der Korrektheit des geänderten Codes
  • Beurteilung, ob gelöschter Code tatsächlich überflüssig war
  • Möglichkeit neuer Nebenwirkungen
  • Verantwortung für Wartung und Deployment

• AI beschleunigt die Code-Erstellung, liefert aber nicht automatisch auch Stabilität und Verantwortung für das Ergebnis.

• In Produktionsumgebungen ist nicht die Generierungsfähigkeit entscheidend, sondern die Fähigkeit, den Änderungsumfang zu kontrollieren und das Ergebnis zu verifizieren.

10. AI ist stark bei Problemen mit niedriger Decke

• Probleme, die AI leicht lösen kann, sind meist „gut definierte Probleme“, bei denen Anforderungen und Lösungswege ausreichend bekannt sind.

• Solche Probleme lassen sich durch die Kombination bereits fertiger Abstraktionselemente wie Bibliotheken, Frameworks und Patterns lösen.

• AI ist stark darin, von der Menschheit angesammelten Code und Problemlösungsmuster probabilistisch zu kombinieren.

• Bei schwierigen Problemen wie den folgenden ist dagegen zusätzliches menschliches Urteil nötig.

  • Probleme mit unvollständigen Anforderungen
  • Komplexe Domain-Regeln
  • Interaktionen in groß angelegten Systemen
  • Ausnahmesituationen in Betriebsumgebungen
  • Probleme, bei denen Sicherheit, Performance, Regulierung und Verantwortung zusammenkommen

• Der Wert einfacher Implementierung verschwindet nicht völlig, doch die Implementierung selbst könnte sich allmählich in einen Bereich verschieben, den auch allgemeine Nutzer ausführen können.

11. Die Details der Entwicklerarbeit verschieben sich zur Kontrolle von AI

• Früher schrieben Entwickler deterministischen Code, um sich gegen schwer vorhersehbare Nutzereingaben und Betriebsumgebungen abzusichern.

• Im Zeitalter der AI muss man mit nichtdeterministischer AI deterministische Produkte bauen.

• Die Details, um die sich Entwickler kümmern müssen, verlagern sich in folgende Bereiche.

  • Den Arbeitsumfang festlegen, damit AI sich nicht auf falsche Ziele versteift
  • Formate für Ein- und Ausgaben je Phase definieren
  • Kontext- und Wissensdokumente verwalten
  • Den Umfang großer Änderungen begrenzen
  • Wiederherstellungsverfahren bei Fehlern entwerfen
  • Qualität und Sicherheit der Ergebnisse verifizieren

• Je stärker einfache Implementierungsaufgaben automatisiert werden, desto größer kann der Anteil von Ausnahmebehandlung und Kontrollproblemen in der Entwicklungsarbeit werden.

12. Ergebnisse von AI müssen mit deterministischen Werkzeugen verifiziert werden

• Es ist schwer, allein durch die Verifikation von AI-Ergebnissen durch eine andere AI ausreichende Zuverlässigkeit zu sichern.

• Um zu beurteilen, ob die Ausgabe eines Systems korrekt ist, braucht man einen klaren Maßstab für richtige Antworten, also ein Oracle.

• Wenn nichtdeterministische AI sogar die Verifikationskriterien beliebig erzeugt, besteht die Gefahr, richtige Ergebnisse falsch zu verändern oder die Prüfkriterien zu verzerren.

• Daher sollten Verifikationskriterien so weit wie möglich aus deterministischen Werkzeugen bestehen.

  • Compiler und Typprüfer
  • Automatisierte Tests
  • Linter und statische Analyse
  • Schema-Prüfung
  • Performance- und Sicherheitskriterien
  • Freigabeprozesse und Begrenzung des Änderungsumfangs

• Das Urteilsvermögen der AI kann als Hilfsmittel dienen, aber die endgültige Freigabe sollte an reproduzierbare Kriterien gekoppelt sein.

13. Das Harness wird zur zentralen Infrastruktur der AI-Entwicklung

• Ein Harness ist eine Verifikationsvorrichtung, die in den einzelnen Phasen des Arbeitsprozesses platziert wird, damit AI keine Fehler akkumuliert oder den Rahmen verlässt.

• Zu den wichtigsten Bestandteilen gehören die folgenden.

  • Eine Pipeline zur Trennung der Arbeitsschritte
  • Ein- und Ausgabeformate je Phase
  • Automatisierte Tests und statische Analyse
  • Verifikations-Gates, die bei Fehlern stoppen
  • Einschränkungen für änderbare Dateien und Bereiche
  • Menschliche Freigabe- und Review-Prozesse

• Ein Harness verhindert, dass sich ein kleiner Fehler in einer Phase in der nächsten vergrößert.

• Die Fähigkeit, AI sinnvoll einzusetzen, könnte künftig weniger daran gemessen werden, gute Prompts zu schreiben, als vielmehr an der Fähigkeit, unvorhersehbare Ausgaben in ein stabiles System einzubinden.

---

Fazit

Entwickler verschwinden nicht, ihre Rolle verlagert sich

• AI automatisiert bereits heute einfache Code-Erstellung und wiederholte Implementierung sehr schnell.

• Um jedoch Ergebnisse auf Produktniveau zu erzeugen, werden weiterhin folgende Rollen benötigt.

  • Definition von Problem und Ziel
  • Entwurf der Systemstruktur
  • Trennung von Arbeitsschritten und Ergebnissen
  • Abstimmung des Flusses zwischen AI-Agenten
  • Aufbau von Verifikationskriterien und Harnesses
  • Letztverantwortung für Betriebsergebnisse

• Es ist wahrscheinlich, dass sich die Arbeit von Entwicklern weg vom direkten Tippen von Code und hin zur Organisation und Kontrolle des von AI erzeugten Codes als System entwickelt.

Prompt-Schreiben ist eine neue Form des Programmierens

• Der Prozess, wiederverwendbare Anweisungen als Skills und Regeln zu formulieren und über Pipelines zu verbinden, ähnelt dem Entwurf von Funktionen und Modulen.
• Markdown-Dokumente können als neue Code-Ebene fungieren, die Kontext, Verhalten und Ausgabeformate der AI definiert.
• Entwickler müssen ihre Erfahrung und impliziten Beurteilungsmaßstäbe dokumentieren und in eine Form abstrahieren, die von AI wiederverwendet werden kann.
• Das geht über die Abstraktion bestehender Systeme hinaus und ist eine Arbeit, die sogar die eigene Arbeitsweise und den eigenen Entscheidungsprozess des Entwicklers abstrahiert.

Zentrale Kompetenzen künftiger Entwickler

• Die Fähigkeit, Probleme präzise zu definieren
• Die Fähigkeit, Arbeit anhand von Zielen und Kontext zu delegieren
• Die Fähigkeit, komplexe Arbeit in kleine Ergebnisse zu zerlegen
• Die Fähigkeit, Skills und Agenten zu einer Pipeline zusammenzustellen
• Die Fähigkeit, deterministische Verifikationskriterien zu entwerfen
• Die Fähigkeit, Harnesses aufzubauen, die die Risiken nichtdeterministischer Ergebnisse kontrollieren
• Die technische Tiefe, um von AI erzeugte Ergebnisse zu verstehen und die letztliche Verantwortung zu tragen

Gesamtbewertung

• AI beseitigt nicht das Wesen der Entwicklung, sondern verändert die Abstraktionsebene, mit der Entwickler arbeiten müssen.
• Während frühere Entwickler die Details von Code und Systemen behandelten, müssen künftige Entwickler die Details behandeln, die aus Verhalten und Ausgaben von AI entstehen.
• Die Kosten für die Code-Erzeugung sinken, aber die Bedeutung von Verifikation, Zusammensetzung, Betrieb und Kontrolle wird voraussichtlich weiter steigen.
• Das Wesen des Programmierers liegt nicht im Tippen selbst, sondern in der Fähigkeit, Details zu entdecken, zu abstrahieren und zu einem vertrauenswürdigen System zusammenzufügen.