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]