Ich habe Code veröffentlicht, den ich nicht verstehe – und ich wette, du auch schon

AAI Engineer
Computing/SoftwareManagementInternet Technology

Transcript

00:00:00[MUSIK]
00:00:21>> Hallo zusammen, guten Tag.
00:00:22Ich werde meinen Vortrag mit einem kleinen Geständnis beginnen.
00:00:26Ich habe Code veröffentlicht, den ich nicht ganz verstanden habe.
00:00:29Ich habe ihn generiert, getestet, bereitgestellt und konnte nicht erklären, wie er funktioniert.
00:00:33Und die Sache ist die: Ich wette, jeder von euch hat das auch schon getan.
00:00:37>> [LACHEN]
00:00:40>> Da wir nun alle zugeben können, dass wir Code ausliefern,
00:00:41den wir nicht mehr verstehen, möchte ich euch auf eine kleine Reise mitnehmen,
00:00:44um zu sehen, wie es dazu gekommen ist.
00:00:46Erstens blicken wir in die Geschichte und sehen, dass sie sich tendenziell wiederholt.
00:00:50Zweitens sind wir in eine kleine Falle getappt.
00:00:52Wir haben "bequem" mit "einfach" verwechselt.
00:00:55Und schließlich gibt es eine Lösung, aber sie verlangt von uns, unser Denken nicht auszulagern.
00:01:00Ich habe die letzten Jahre bei Netflix damit verbracht, die Einführung von KI-Tools voranzutreiben.
00:01:05Und ich muss sagen: Die Beschleunigung ist absolut real.
00:01:07Backlog-Aufgaben, die früher Tage dauerten, sind jetzt in Stunden erledigt.
00:01:10Und große Refactorings, die seit Jahren anstanden, werden endlich umgesetzt.
00:01:15Aber hier ist der Punkt.
00:01:16Große Produktionssysteme scheitern immer auf unerwartete Weise.
00:01:19Schaut euch nur an, was kürzlich bei Cloudflare passiert ist.
00:01:21Wenn das passiert, sollte man den Code besser verstehen, den man gerade debuggt.
00:01:23Das Problem ist, dass wir Code jetzt in einer solchen Geschwindigkeit und Menge generieren,
00:01:28dass unser Verständnis kaum noch hinterherkommt.
00:01:29Verdammt, ich weiß es, ich habe es selbst getan.
00:01:34Ich habe einen Haufen Code generiert, ihn mir angesehen und gedacht: Ich habe keine Ahnung, was das macht.
00:01:39Aber die Tests waren erfolgreich, es funktionierte, also habe ich es veröffentlicht.
00:01:41Das Ding ist, dass das eigentlich nichts Neues ist.
00:01:44Jede Generation von Softwareentwicklern ist irgendwann an eine Wand gestoßen,
00:01:48an der die Softwarekomplexität ihre Management-Fähigkeiten überstieg.
00:01:50Wir sind nicht die Ersten, die mit einer Software-Krise konfrontiert sind,
00:01:52aber wir sind die Ersten, die sie in diesem unendlichen Ausmaß der Generierung erleben.
00:01:56Gehen wir also einen Schritt zurück, um zu sehen, wo das alles anfing.
00:01:58In den späten 60er und frühen 70er Jahren kamen kluge Informatiker zusammen
00:02:03und sagten: "Hey, wir stecken in einer Software-Krise."
00:02:06Wir haben diese enorme Nachfrage nach Software, aber wir können nicht wirklich mithalten.
00:02:11Projekte dauern zu lange, es geht alles sehr langsam voran.
00:02:15Wir machen keinen guten Job.
00:02:16Dijkstra lieferte dazu ein wirklich großartiges Zitat.
00:02:20Er sagte – um ein längeres Zitat zu paraphrasieren – als wir noch wenige, schwache Computer hatten,
00:02:23war das Programmieren ein eher kleines Problem.
00:02:26Und jetzt, da wir gigantische Computer haben, ist das Programmieren zu einem gigantischen Problem geworden.
00:02:31Er erklärte, dass mit der Steigerung der Hardwareleistung um den Faktor 1.000
00:02:34auch die Wünsche der Gesellschaft nach Software proportional gewachsen sind.
00:02:37Und so blieb es uns Programmierern überlassen, zwischen den Wegen und Mitteln abzuwägen,
00:02:41wie wir so viel mehr Software unterstützen können.
00:02:43Das wiederholt sich in Zyklen.
00:02:47In den 70ern bekamen wir C, damit wir größere Systeme schreiben konnten.
00:02:50In den 80ern kamen PCs auf und jeder konnte Software schreiben.
00:02:53In den 90ern erhielten wir die objektorientierte Programmierung.
00:02:56Verschachtelte Hierarchien aus der Hölle – danke an Java dafür.
00:03:00In den 2000ern kam Agile, und wir hatten Sprints und
00:03:03Scrum Master, die uns sagten, was zu tun ist; Schluss mit Wasserfall.
00:03:06In den 2010ern hatten wir Cloud, Mobile, DevOps, einfach alles;
00:03:09Software hat die Welt förmlich verschlungen.
00:03:10Und heute haben wir KI, Co-Pilot, Cursor, Claude, Codex, Gemini und wie sie alle heißen.
00:03:17Wir können Code so schnell generieren, wie wir ihn beschreiben können.
00:03:19Das Muster setzt sich fort, aber der Maßstab hat sich drastisch geändert – er ist jetzt unendlich.
00:03:23Fred Brooks – Sie kennen ihn vielleicht als Autor von "The Mythical Man-Month".
00:03:29Er schrieb 1986 auch ein Paper namens "No Silver Bullet".
00:03:32Darin argumentierte er, dass es keine einzelne Innovation geben würde,
00:03:36die uns eine massive Steigerung der Softwareproduktivität bescheren würde.
00:03:38Warum?
00:03:40Weil er sagte, der schwierige Teil sei nicht die Mechanik des Codierens, die Syntax,
00:03:44das Tippen oder der Boilerplate-Code.
00:03:45Es ginge darum, das eigentliche Problem zu verstehen und die Lösung zu entwerfen.
00:03:49Kein Werkzeug kann diese fundamentale Schwierigkeit beseitigen.
00:03:52Jedes Tool und jede Technik, die wir bisher entwickelt haben, erleichtert die Mechanik.
00:03:55Die Kernherausforderung jedoch –
00:03:57zu verstehen, was man bauen will und wie es funktionieren soll – bleibt genauso schwer.
00:04:00Wenn das Problem also nicht in der Mechanik liegt, warum optimieren wir dann ständig dafür?
00:04:06Wie kommt es, dass erfahrene Ingenieure am Ende Code haben, den sie nicht verstehen?
00:04:09Die Antwort liegt meiner Meinung nach in zwei Wörtern, die wir oft verwechseln: "einfach" (simple) und "bequem" (easy).
00:04:14Wir neigen dazu, sie synonym zu verwenden, aber
00:04:16sie bedeuten eigentlich völlig unterschiedliche Dinge.
00:04:18Ich wurde beim Sprecher-Dinner als Clojure-Fan geoutet, also
00:04:21ist das hier ziemlich klar.
00:04:23Aber Rich Hickey, der Schöpfer der Programmiersprache Clojure,
00:04:25erklärte dies in seinem Vortrag von 2011 namens "Simple Made Easy".
00:04:29Er definierte "simple" (einfach) als einsträngig, unverflochten und ohne Verstrickung.
00:04:33Jedes Teil macht genau eine Sache und ist nicht mit anderen verwoben.
00:04:36Er definiert "easy" (bequem) als das, was naheliegt, was in Reichweite ist.
00:04:39Was kann man ohne Anstrengung erreichen?
00:04:41Kopieren, einfügen, fertig.
00:04:43Bei "Einfachheit" geht es um Struktur.
00:04:45Bei "Bequemlichkeit" geht es um Nähe.
00:04:48Die Sache ist: Wir können etwas nicht einfach dadurch einfach machen, dass wir es uns wünschen.
00:04:51Einfachheit erfordert Nachdenken, Design und Entwirrung.
00:04:54Aber wir können etwas immer bequemer machen.
00:04:56Man rückt es einfach näher ran.
00:04:57Installiere ein Paket, generiere es mit KI, kopiere eine Lösung von Stack Overflow.
00:05:03Es liegt in der menschlichen Natur, den bequemsten Weg zu wählen.
00:05:06Wir sind darauf programmiert.
00:05:07Wie gesagt: Kopiere etwas von Stack Overflow, es ist direkt da.
00:05:10Ein Framework, das alles mit Magie für dich erledigt – installieren und loslegen.
00:05:14Aber bequem bedeutet nicht einfach.
00:05:15Bequem bedeutet, dass man sein System schnell erweitern kann.
00:05:18Einfach bedeutet, dass man die Arbeit, die man getan hat, auch verstehen kann.
00:05:20Jedes Mal, wenn wir uns für das Bequeme entscheiden, wählen wir Tempo jetzt und Komplexität später.
00:05:24Und ehrlich gesagt hat dieser Kompromiss früher wirklich funktioniert.
00:05:27Die Komplexität in unserer Codebasis sammelte sich langsam genug an,
00:05:31dass wir bei Bedarf refactoren, umdenken und neu bauen konnten.
00:05:34Ich glaube, die KI hat dieses Gleichgewicht zerstört.
00:05:36Weil sie der ultimative "Bequemlichkeits-Knopf" ist.
00:05:37Sie macht den bequemen Pfad so
00:05:38reibungslos, dass wir den einfachen gar nicht mehr in Betracht ziehen.
00:05:41Warum über Architektur nachdenken, wenn der Code sofort erscheint?
00:05:44Lassen Sie mich zeigen, wie das passiert.
00:05:47Wie sich eine einfache Aufgabe in ein Chaos aus Komplexität verwandelt,
00:05:50getrieben durch die Chat-Schnittstellen, die wir alle so lieben gelernt haben.
00:05:52Dies ist ein konstruiertes Beispiel, aber sagen wir, wir haben unsere App
00:05:55und wollen eine Authentifizierung hinzufügen.
00:05:57Wir sagen "Auth hinzufügen" und erhalten eine saubere auth.js-Datei.
00:06:01Nach ein paar Iterationen sind wir bei Nachricht fünf.
00:06:02Man denkt: Okay, cool, jetzt fügen wir auch OAuth hinzu,
00:06:04und nun haben wir eine auth.js und eine OAuth.js.
00:06:07Wir iterieren weiter und stellen fest, dass die Sessions kaputt sind.
00:06:11Und wir haben einen Haufen Konflikte.
00:06:12Wenn man bei Schritt 20 ankommt, führt man kein echtes Gespräch mehr.
00:06:15Man verwaltet Kontexte, die so komplex werden, dass man sich selbst nicht mehr
00:06:18an alle Bedingungen erinnert, die man hinzugefügt hat.
00:06:20Toter Code von verworfenen Ansätzen.
00:06:22Tests, die repariert wurden, indem man sie einfach irgendwie zum Laufen brachte.
00:06:25Fragmente von drei verschiedenen Lösungen, weil man am Ende sagt: "Warte mal kurz."
00:06:28Jede neue Anweisung überschreibt Architekturmuster.
00:06:31Wir sagten: "Bring die Auth hier zum Laufen", und das tat sie.
00:06:33Als wir sagten: "Beheb diesen Fehler", tat sie es.
00:06:35Es gibt keinen Widerstand gegen schlechte architektonische Entscheidungen.
00:06:38Der Code mutiert einfach, um die neueste Anfrage zu erfüllen.
00:06:40Jede Interaktion bevorzugt das Bequeme gegenüber dem Einfachen.
00:06:43Und bequem bedeutet immer mehr Komplexität.
00:06:46Wir wissen es eigentlich besser, aber wenn der bequeme Weg so einfach ist, nehmen wir ihn.
00:06:50Und die Komplexität summiert sich auf, bis es zu spät ist.
00:06:52KI treibt die Bequemlichkeit an ihr logisches Extrem.
00:06:58Entscheide, was du willst, und erhalte sofort den Code.
00:07:00Aber darin liegt die Gefahr.
00:07:02Der generierte Code behandelt jedes Muster in deiner Codebasis gleich.
00:07:06Wenn ein Agent deine Codebasis analysiert, wird jede Zeile zu einem Muster, das bewahrt werden muss.
00:07:10Der Authentifizierungs-Check in Zeile 47 – das ist ein Muster.
00:07:13Dieser seltsame gRPC-Code, der sich wie GraphQL verhält und den ich 2019 hinzugefügt habe –
00:07:18auch das ist ein Muster.
00:07:19Technische Schulden werden nicht als Schulden erkannt, es ist einfach nur mehr Code.
00:07:22Das eigentliche Problem hier ist die Komplexität.
00:07:25Ich weiß, ich habe dieses Wort in diesem Vortrag oft benutzt, ohne es wirklich zu definieren.
00:07:29Aber man kann es sich am besten als das Gegenteil von Einfachheit vorstellen.
00:07:31Es bedeutet einfach "verflochten".
00:07:33Und wenn Dinge komplex sind, berührt alles alles andere.
00:07:36Man kann keine Sache ändern, ohne zehn andere zu beeinflussen.
00:07:41Zurück zu Fred Brooks' Paper "No Silver Bullet".
00:07:43Darin stellte er fest, dass es in jedem System zwei Hauptarten von Komplexität gibt.
00:07:47Es gibt die essenzielle Komplexität, also die fundamentale Schwierigkeit
00:07:51des eigentlichen Problems, das man zu lösen versucht.
00:07:53Nutzer müssen bezahlen, Bestellungen müssen ausgeführt werden.
00:07:56Das ist die Komplexität des Grundes, warum dein Softwaresystem überhaupt existiert.
00:08:00Und zweitens gibt es die akzidentelle (zufällige) Komplexität.
00:08:03Alles andere, was wir unterwegs hinzugefügt haben: Workarounds, defensiver Code,
00:08:06Frameworks, Abstraktionen, die vor einiger Zeit mal sinnvoll waren.
00:08:09Es ist all das Zeug, das wir zusammengebaut haben, damit der Code an sich funktioniert.
00:08:11In einer echten Codebasis sind diese beiden Arten von Komplexität überall.
00:08:16Und sie sind so miteinander verstrickt, dass ihre Trennung Kontext,
00:08:19Historie und Erfahrung erfordert.
00:08:20Die generierte Ausgabe macht keinen solchen Unterschied.
00:08:24Und so wird jedes Muster weiter beibehalten.
00:08:26Hier ist ein echtes Beispiel aus unserer Arbeit bei Netflix.
00:08:32Ich habe ein System mit einer Abstraktionsschicht zwischen unserem alten
00:08:35Autorisierungscode von vor etwa fünf Jahren und einem neuen, zentralisierten Auth-System.
00:08:41Wir hatten keine Zeit, die gesamte App neu zu bauen, also
00:08:42haben wir einfach ein Zwischenstück (Shim) eingebaut.
00:08:44Jetzt mit KI wäre das eine tolle Gelegenheit, den Code so zu refactoren, dass er
00:08:47das neue System direkt nutzt – klingt nach einer einfachen Aufgabe, oder?
00:08:50Aber nein, der alte Code war so eng mit seinen Autorisierungsmustern verzahnt –
00:08:56wir hatten Berechtigungsprüfungen mitten in der Business-Logik,
00:08:59Rollen-Annahmen in den Datenmodellen und Auth-Aufrufe über hunderte Dateien verstreut.
00:09:03Der Agent fing mit dem Refactoring an, kam ein paar Dateien weit,
00:09:07stieß auf eine Abhängigkeit, die er nicht entwirren konnte, verlor die Kontrolle und gab auf.
00:09:10Oder schlimmer noch: Er versuchte, bestehende Logik aus dem alten System beizubehalten
00:09:16und sie im neuen System nachzubauen, was auch nicht ideal ist.
00:09:19Das Problem war: Er konnte die Trennlinien nicht sehen.
00:09:23Er konnte nicht erkennen, wo die Business-Logik aufhörte und die Auth-Logik begann.
00:09:26Alles war so verstrickt, dass die KI selbst mit perfekten Informationen
00:09:30keinen sauberen Weg hindurch fand.
00:09:33Wenn deine akzidentelle Komplexität so verfilzt ist,
00:09:35ist KI nicht die beste Hilfe, um es wirklich besser zu machen.
00:09:38Ich habe die Erfahrung gemacht, dass sie nur noch mehr Schichten obenauf legt.
00:09:40Wir können den Unterschied erkennen – zumindest, wenn wir uns genug Zeit zum Nachdenken nehmen.
00:09:45Wir wissen, welche Muster essenziell sind und
00:09:47welche nur entstanden sind, weil jemand es vor Jahren so gelöst hat.
00:09:50Wir tragen den Kontext in uns, den die KI nicht ableiten kann – aber
00:09:53nur, wenn wir uns die Zeit nehmen, diese Unterschiede zu klären, bevor wir anfangen.
00:09:56Wie macht man es also konkret?
00:10:01Wie trennt man akzidentelle und essenzielle Komplexität,
00:10:04wenn man vor einer riesigen Codebasis steht?
00:10:07Die Codebasis, an der ich bei Netflix arbeite, umfasst etwa eine Million Zeilen Java,
00:10:10und der Hauptservice darin hat ca. fünf Millionen Token – so der letzte Stand.
00:10:13Kein Kontextfenster, auf das ich Zugriff habe, kann das fassen.
00:10:17Als ich also damit arbeiten wollte, dachte ich zuerst:
00:10:19Vielleicht kann ich einfach große Teile dieser Codebasis in den Kontext kopieren
00:10:23und sehen, ob die Muster klarer werden,
00:10:24ob die KI einfach versteht, was da passiert.
00:10:26Und genau wie beim Autorisierungs-Refactoring zuvor
00:10:29verlor sich die Ausgabe einfach in ihrer eigenen Komplexität.
00:10:31Dadurch war ich gezwungen, etwas anderes zu versuchen.
00:10:34Ich musste auswählen, was wichtig war: Design-Docs, Architekturdiagramme,
00:10:37zentrale Schnittstellen – was auch immer.
00:10:39Ich nahm mir Zeit, die Anforderungen an das Zusammenspiel der Komponenten
00:10:42und die zu folgenden Muster schriftlich festzulegen.
00:10:43Ich schrieb im Grunde eine Spezifikation.
00:10:45Aus fünf Millionen Token wurden 2.000 Wörter Spezifikation.
00:10:49Um noch einen Schritt weiterzugehen, nahm ich diese Spezifikation
00:10:52und erstellte einen exakten Ablaufplan für den Code.
00:10:55Keine vagen Anweisungen, sondern eine präzise Abfolge von Operationen.
00:10:58Ich merkte, dass dies viel saubereren, fokussierteren Code lieferte, den ich verstand.
00:11:02Ich habe ihn also zuerst definiert und die Ausführung geplant.
00:11:05Diesen Ansatz nannte ich vor einiger Zeit "Kontext-Kompression".
00:11:11Man kann es auch "Kontext-Engineering" oder "Spec-Driven Development" nennen,
00:11:13wie auch immer man möchte.
00:11:15Der Name spielt keine Rolle.
00:11:16Wichtig ist nur, dass Denken und Planen den Großteil der Arbeit ausmachen.
00:11:20Ich zeige Ihnen nun, wie das in der Praxis funktioniert.
00:11:22Zuerst kommt Phase eins: Recherche.
00:11:26Dabei füttere ich das System vorab mit allem Relevanten.
00:11:28Architekturdiagramme, Dokumentationen, Slack-Threads.
00:11:31Wir haben das schon oft besprochen.
00:11:32Bringen Sie einfach so viel Kontext wie möglich ein, der für
00:11:35die geplanten Änderungen relevant ist.
00:11:36Dann lassen Sie den Agenten die Codebasis analysieren,
00:11:39um Komponenten und Abhängigkeiten zu erfassen.
00:11:42Das sollte kein einmaliger Vorgang sein.
00:11:43Ich hake gerne nach, zum Beispiel: "Was ist mit dem Caching?"
00:11:46"Wie wird mit Fehlern umgegangen?"
00:11:47Wenn die Analyse falsch ist, korrigiere ich sie.
00:11:49Fehlt Kontext, liefere ich ihn nach.
00:11:51Jeder Schritt verfeinert die Analyse.
00:11:55Das Ergebnis ist ein einzelnes Recherche-Dokument.
00:11:57Es zeigt: Das ist vorhanden, das ist womit verbunden,
00:11:59und das sind die Auswirkungen Ihrer Änderung.
00:12:01Stundenlanges Suchen wird in wenige Minuten Lesezeit komprimiert.
00:12:03Dex erwähnte es heute Morgen: Dieser menschliche Prüfpunkt ist entscheidend.
00:12:09Hier validieren Sie die Analyse gegen die Realität –
00:12:12der Moment mit der größten Hebelwirkung im gesamten Prozess.
00:12:15Fehler hier zu finden, verhindert spätere Katastrophen.
00:12:17Weiter zu Phase zwei.
00:12:20Mit der validierten Recherche in der Hand
00:12:22erstellen wir einen detaillierten Plan: reale Codestruktur,
00:12:25Funktionssignaturen, Typdefinitionen, Datenfluss.
00:12:28Der Plan soll so klar sein, dass jeder Entwickler ihm folgen kann.
00:12:30Ich vergleiche es gerne mit Malen nach Zahlen.
00:12:32Man sollte ihn dem jüngsten Ingenieur geben können und sagen: "Mach das."
00:12:35Wenn sie es Zeile für Zeile abarbeiten, sollte es einfach funktionieren.
00:12:38In diesem Schritt treffen wir die wichtigen Architektur-Entscheidungen.
00:12:43Wir stellen sicher, dass komplexe Logik korrekt ist,
00:12:45und dass Geschäftsanforderungen bewährten Praktiken folgen.
00:12:50Wir achten auf Service-Grenzen, saubere Trennung und
00:12:52vermeiden unnötige Kopplungen.
00:12:54Wir erkennen Probleme im Voraus, weil wir sie selbst erlebt haben.
00:12:57Die KI hat diese Erfahrung nicht.
00:12:59Sie behandelt jedes Muster wie eine zwingende Vorgabe.
00:13:01Der wahre Vorteil dieses Schritts ist die Geschwindigkeit der Überprüfung.
00:13:05Wir können diesen Plan in Minuten validieren und wissen genau, was gebaut wird.
00:13:10Um mit dem Tempo der Codegenerierung mitzuhalten,
00:13:13müssen wir ebenso schnell begreifen können, was wir tun.
00:13:18Zuletzt kommt die Implementierung. Mit einem klaren Plan
00:13:22und fundierter Recherche sollte diese Phase ziemlich einfach sein.
00:13:26Genau darum geht es.
00:13:28Wenn die KI einer klaren Spezifikation folgt, bleibt der Kontext sauber
00:13:31und fokussiert.
00:13:32Wir vermeiden die Komplexitätsspirale endloser Konversationen.
00:13:36Statt 50 Nachrichten mit sich entwickelndem Code
00:13:38haben wir drei gezielte Ergebnisse, die jeweils vorab validiert wurden.
00:13:41Keine verworfenen Ansätze, keine widersprüchlichen Muster,
00:13:44keine "Moment mal"-Augenblicke, die überall Codeleichen hinterlassen.
00:13:48Der wahre Nutzen für mich ist, dass ein Hintergrund-Agent
00:13:52vieles davon erledigen kann, da die Denkarbeit bereits getan ist.
00:13:56Er kann mit der Umsetzung beginnen, während Sie an etwas anderem arbeiten
00:13:59und später nur zur Überprüfung zurückkehren.
00:14:01Das geht schnell, da Sie nur prüfen, ob der Plan eingehalten wurde,
00:14:04statt mühsam zu verstehen, was sich die KI vielleicht ausgedacht hat.
00:14:07Der Punkt ist: Wir lassen die KI nicht für uns denken.
00:14:12Wir nutzen sie, um die mechanischen Teile zu beschleunigen,
00:14:15während wir selbst den Durchblick behalten.
00:14:17Recherche wird schneller, Planung gründlicher und der Code sauberer.
00:14:21Das Denken, die Synthese und das Urteilsvermögen bleiben jedoch bei uns.
00:14:26Erinnern Sie sich an das Auth-Refactoring, das die KI nicht schaffte?
00:14:34Wir arbeiten aktuell daran und
00:14:37machen mittlerweile gute Fortschritte.
00:14:39Aber nicht, weil wir bessere Prompts gefunden haben.
00:14:42Wir merkten, dass wir nicht direkt mit Recherche oder Planung
00:14:45und Implementierung starten konnten.
00:14:46Wir mussten diese Änderung zuerst manuell vornehmen.
00:14:49Ohne KI – nur Code lesen, Abhängigkeiten verstehen
00:14:52und Dinge ändern, um zu sehen, was kaputtgeht.
00:14:53Diese manuelle Migration war mühsam, aber absolut notwendig.
00:14:59Sie brachte verborgene Einschränkungen und Invarianten ans Licht
00:15:02und zeigte, welche Dienste bei einer Auth-Änderung ausfallen würden.
00:15:05Dinge, die keine Code-Analyse jemals zutage gefördert hätte.
00:15:09Diesen Pull-Request der manuellen Migration speisten wir
00:15:14dann als Grundlage in unseren Recherche-Prozess ein.
00:15:19So konnte die KI sehen, wie eine saubere Migration aussieht.
00:15:23Da jede Entität etwas anders ist, müssen wir sie immer wieder
00:15:27hinterfragen und entscheiden, was zu tun ist.
00:15:29Einiges ist verschlüsselt, anderes nicht.
00:15:32Diesen zusätzlichen Kontext mussten wir schrittweise liefern.
00:15:35Erst dann konnten wir einen Plan erstellen, der vielleicht sofort funktioniert.
00:15:41"Vielleicht" ist hier das Schlüsselwort, denn wir validieren
00:15:45und korrigieren immer noch und finden ständig neue Randfälle.
00:15:47Der Drei-Phasen-Ansatz ist kein Hexenwerk.
00:15:55Er funktioniert nur, weil wir diese eine Migration händisch gemacht haben.
00:15:57Wir mussten das Verständnis erst erarbeiten, bevor wir es systematisieren konnten.
00:16:01Es gibt keine Patentlösung.
00:16:02Weder bessere Prompts noch bessere Modelle oder Spezifikationen.
00:16:06Nur die harte Arbeit, sein System so tief zu verstehen,
00:16:09dass man sicher Änderungen daran vornehmen kann.
00:16:11Warum also der ganze Aufwand?
00:16:15Warum nicht einfach mit der KI iterieren, bis es passt?
00:16:18Irgendwann werden die Modelle stark genug sein und es klappt.
00:16:21Aber für mich reicht "es funktioniert" nicht aus.
00:16:24Es gibt einen Unterschied zwischen Code, der Tests besteht, und Code,
00:16:27der im Produktivbetrieb überlebt.
00:16:28Zwischen Systemen, die heute laufen,
00:16:31und solchen, die auch morgen noch von anderen wartbar sind.
00:16:34Das eigentliche Problem ist eine Wissenslücke.
00:16:38Wenn eine KI in Sekunden Tausende Zeilen Code erzeugt,
00:16:41kann das Verstehen Stunden oder Tage dauern.
00:16:45Vielleicht versteht man ihn nie, wenn er zu verworren ist.
00:16:48Über einen Punkt spricht derzeit kaum jemand:
00:16:52Jedes Mal, wenn wir das Denken überspringen, um mit der KI mitzuhalten,
00:16:56fügen wir nicht nur unverstandenen Code hinzu.
00:16:58Wir verlieren auch unsere Fähigkeit, Probleme zu erkennen.
00:17:00Der Instinkt, der uns warnt: "Das wird gerade zu komplex",
00:17:03verkümmert, wenn man das eigene System nicht mehr durchdringt.
00:17:09Mustererkennung basiert auf Erfahrung.
00:17:11Wenn ich eine gefährliche Architektur erkenne,
00:17:12dann weil ich um drei Uhr nachts die Fehler ausbaden musste.
00:17:16Wenn ich auf einfache Lösungen dränge,
00:17:17dann weil ich die komplizierten Alternativen anderer warten musste.
00:17:21Die KI liefert nur das, was man bestellt.
00:17:23Sie lernt nicht aus Fehlern der Vergangenheit.
00:17:25Der Drei-Phasen-Ansatz schließt diese Lücke.
00:17:29Er komprimiert Verständnis in Artefakte, die wir schnell prüfen können.
00:17:33Ohne ihn häufen wir Komplexität schneller an,
00:17:37als wir sie begreifen können.
00:17:39Die KI verändert alles daran, wie wir Code schreiben, aber ehrlich gesagt
00:17:44glaube ich nicht, dass sie etwas daran ändert, warum Software scheitert.
00:17:47Jede Generation hatte ihre eigene Software-Krise.
00:17:50Dijkstras Generation schaffte die Disziplin des Software-Engineerings,
00:17:54und wir stehen nun vor der Krise der unendlichen Codegenerierung.
00:17:56Die Lösung ist kein weiteres Tool oder eine neue Methodik.
00:18:01Es ist die Besinnung darauf, dass Software ein menschliches Unterfangen ist.
00:18:05Der schwierige Teil war nie das Tippen des Codes.
00:18:06Es war das Wissen, was man überhaupt tippen soll.
00:18:09Erfolgreich werden nicht die sein, die den meisten Code generieren.
00:18:13Sondern jene, die verstehen, was sie bauen,
00:18:15die Schwachstellen sehen und erkennen,
00:18:18wenn sie das falsche Problem lösen.
00:18:19Das bleibt unsere Aufgabe.
00:18:20Das können nur wir leisten.
00:18:21Ich möchte mit einer Frage schließen. Es geht nicht darum,
00:18:25ob wir KI nutzen werden.
00:18:26Das steht außer Frage.
00:18:28Der Zug ist längst abgefahren.
00:18:30Die Frage ist, ob wir unsere eigenen Systeme noch verstehen werden,
00:18:33wenn die KI den Großteil unseres Codes schreibt.
00:18:35Vielen Dank.
00:18:37>> [APPLAUS]
00:18:39[MUSIK]

Key Takeaway

Echter Fortschritt in der Softwareentwicklung mit KI erfordert, dass wir das Denken und Planen nicht auslagern, sondern durch gezielte Kontext-Kompression die Kontrolle über die Systemkomplexität behalten.

Highlights

Unterscheidung zwischen "einfach" (Struktur) und "bequem" (Nähe), wobei KI als ultimativer Bequemlichkeits-Knopf die Komplexität unkontrolliert steigert.

Die historische Software-Krise der 60er Jahre wiederholt sich heute durch unendliche Codegenerierung in einem neuen, gefährlichen Ausmaß.

Fred Brooks' Theorie der "No Silver Bullet" verdeutlicht, dass die eigentliche Schwierigkeit im Problemlösen und Design liegt, nicht in der Schreibarbeit.

Essenzielle vs. akzidentelle Komplexität: KI erkennt keine technischen Schulden und vermischt notwendige Logik mit unnötigem Ballast.

Der vorgestellte Drei-Phasen-Ansatz (Recherche, Planung, Implementierung) zielt darauf ab, das menschliche Verständnis vor der Automatisierung zu priorisieren.

Manuelle Arbeit und das Durchdringen des Systems sind die einzige Basis, um KI-gestütztes Refactoring in großen Codebasen wie bei Netflix erfolgreich umzusetzen.

Timeline

Einleitung und das Geständnis der Unwissenheit

Der Sprecher beginnt mit dem provokanten Geständnis, bereits Code veröffentlicht zu haben, den er selbst nicht vollständig verstanden hat. Er behauptet, dass dies ein weit verbreitetes Phänomen unter Entwicklern sei, das durch moderne KI-Tools massiv beschleunigt wird. Bei Netflix beobachtete er zwar eine reale Beschleunigung der Arbeit, warnt jedoch vor den Risiken bei großen Produktionsausfällen. Wenn Systeme scheitern, wie etwa bei Cloudflare, ist ein tiefes Verständnis des Codes für das Debugging unerlässlich. Dieser Abschnitt schlägt die Brücke von der persönlichen Erfahrung zur allgemeinen Herausforderung der aktuellen Software-Krise.

Die Geschichte der Software-Krisen und Fred Brooks

Der Vortrag blickt zurück in die 60er Jahre, als Informatiker wie Dijkstra erstmals eine Software-Krise ausriefen, weil die Hardwareleistung schneller wuchs als die menschliche Fähigkeit, komplexe Programme zu schreiben. Über die Jahrzehnte entstanden Lösungen wie C, Java und Agile, doch das Grundproblem blieb laut Fred Brooks' Paper "No Silver Bullet" bestehen. Brooks argumentierte bereits 1986, dass keine Innovation die Produktivität massiv steigern kann, da das eigentliche Problem das Verständnis des Designs ist. Die Mechanik des Tippens ist einfach, aber das Lösen der Kernprobleme bleibt die fundamentale Schwierigkeit. Heute erleben wir diese Krise durch KI erneut, jedoch in einem bisher ungeahnten, unendlichen Ausmaß.

Einfach vs. Bequem: Die Falle der Bequemlichkeit

In diesem zentralen Teil unterscheidet der Sprecher zwischen den Begriffen "simple" (einfach) und "easy" (bequem), basierend auf den Theorien von Rich Hickey. Einfachheit bezieht sich auf eine klare, unverflochtene Struktur, während Bequemlichkeit lediglich bedeutet, dass eine Lösung ohne Anstrengung in Reichweite liegt. KI fungiert hierbei als der ultimative Knopf für Bequemlichkeit, der Entwickler dazu verleitet, Architektur und Design zugunsten schneller Ergebnisse zu ignorieren. Anhand eines Beispiels zur Implementierung von Authentifizierung wird gezeigt, wie iterative Chat-Anweisungen zu einem Chaos aus widersprüchlichem Code führen. Jede bequeme Entscheidung tauscht kurzfristiges Tempo gegen langfristige, unüberschaubare Komplexität ein.

Komplexität und die Grenzen der KI-Analyse

Der Sprecher definiert Komplexität als das Gegenteil von Einfachheit, nämlich als den Zustand, in dem alles mit allem verflochten ist. Er nutzt Brooks' Kategorisierung in essenzielle und akzidentelle Komplexität, um zu erklären, warum KI oft an echten Refactorings scheitert. KI-Modelle unterscheiden nicht zwischen notwendiger Geschäftslogik und historisch gewachsenen technischen Schulden; für sie ist alles nur ein zu bewahrendes Muster. Ein Praxisbeispiel von Netflix verdeutlicht dies: Ein Refactoring einer alten Autorisierungsschicht schlug fehl, weil die KI die tiefen Verstrickungen im Code nicht entwirren konnte. Ohne den menschlichen Kontext und die Erfahrung bleibt die KI an der Oberfläche der Code-Struktur hängen.

Der Drei-Phasen-Ansatz zur Kontext-Kompression

Um die Kontrolle zurückzugewinnen, stellt der Sprecher die Methode der "Kontext-Kompression" vor, die aus Recherche, Planung und Implementierung besteht. In der Recherche-Phase wird der relevante Kontext aus Dokumenten und Analysen in ein kompaktes Dokument gefiltert, das ein Mensch validieren muss. Die Planungs-Phase erstellt daraufhin einen präzisen Ablaufplan, der Architektur-Entscheidungen vorwegnimmt und wie "Malen nach Zahlen" funktioniert. Erst in der Implementierungs-Phase wird die KI zur Ausführung genutzt, wodurch endlose, verwirrende Chat-Konversionen vermieden werden. Dieser strukturierte Prozess stellt sicher, dass das menschliche Urteilsvermögen die Richtung vorgibt, während die Maschine nur die Mechanik beschleunigt.

Fazit: Softwareentwicklung bleibt ein menschliches Unterfangen

Abschließend betont der Sprecher, dass selbst der beste Drei-Phasen-Ansatz eine gründliche manuelle Einarbeitung nicht ersetzen kann. Er berichtet, wie sein Team eine Migration erst händisch durchführen musste, um die Invarianten des Systems zu verstehen, bevor die KI effektiv helfen konnte. Das eigentliche Problem der Zukunft ist eine Wissenslücke: Wenn wir nur noch generieren, ohne zu verstehen, verlieren wir unseren Instinkt für gefährliche Komplexität. Der Sprecher schließt mit der Mahnung, dass Softwareentwicklung trotz KI ein menschliches Handwerk bleibt, das auf Erfahrung und tiefer Durchdringung basiert. Die entscheidende Frage für die Zukunft ist nicht, ob wir KI nutzen, sondern ob wir unsere eigenen Systeme dann noch verstehen werden.

Community Posts

No posts yet. Be the first to write about this video!

Write about this video