Coding für die Zukunft Panel

VVercel
컴퓨터/소프트웨어경영/리더십AI/미래기술

Transcript

00:00:00(fröhliche Musik) – Willkommen zum Podium
00:00:02"Die Zukunft von KI-Programmierung"
00:00:04.
00:00:04Danke,
00:00:04dass Sie das Memo gelesen haben,
00:00:05dass Sie ganz in Schwarz gekleidet sein müssen.
00:00:07(lachen) Okay,
00:00:08ich möchte noch kurz auf die Vorstellungen eingehen.
00:00:12Ich kenne euch alle auf unterschiedliche Weise,
00:00:14aber das Publikum kennt euch wahrscheinlich noch nicht.
00:00:17Matan, fangen Sie an?
00:00:19Welche Position hat Factory in der breiteren Welt der KI-Programmierung?
00:00:26– Ja,
00:00:26bei Factory ist unsere Mission,
00:00:28Autonomie in der Softwareentwicklung zu bringen.
00:00:32Das bedeutet konkret: Wir haben End-to-End-Softwareentwicklungs-Agenten gebaut,
00:00:37sogenannte Droids.
00:00:38Sie konzentrieren sich nicht nur auf das Programmieren selbst,
00:00:41sondern auf den gesamten Softwareentwicklungsprozess.
00:00:43Also Dinge wie Dokumentation,
00:00:45Tests,
00:00:45Code-Reviews – all die lästigen Teile,
00:00:48damit du auch die spannenderen Teile wie das eigentliche Programmieren machen kannst.
00:00:52Und für die Programmierteil,
00:00:53die du nicht tun möchtest,
00:00:54können die Droids das auch übernehmen.
00:00:56Also ihr baut Droids.
00:00:58Ihr baut Droids.
00:00:59Und OpenAI braucht keine große Vorstellung,
00:01:02aber deine Rolle im Codecs-Team – ich habe dich im Codecs-Video gesehen.
00:01:08Daran habe ich erkannt, dass du daran arbeitest.
00:01:10Aber wie siehst du Codecs heutzutage,
00:01:12jetzt dass es sich stark ausgeweitet hat?
00:01:14– Ja,
00:01:15also zu Beginn dieses Jahres haben wir unseren ersten Coding-Agenten gelauncht.
00:01:19Ich habe an Codecs CLI gearbeitet und die Kraft unserer Reasoning-Modelle auf die Computer der Leute gebracht.
00:01:26Dann haben wir Codecs Cloud veröffentlicht,
00:01:28wo man diese Aufgaben verteilen und in der Cloud delegieren konnte.
00:01:31Und in den letzten Monaten haben wir diese Erfahrungen vereinheitlicht.
00:01:34Damit sie so nahtlos wie möglich zusammenarbeiten.
00:01:36Unser Fokus liegt sehr darauf,
00:01:37wie wir die Grundlagen,
00:01:39die Primitives,
00:01:39so nützlich wie möglich machen.
00:01:41Wir haben gerade das Codecs SDK auf der Dev Day veröffentlicht.
00:01:43Ich denke,
00:01:44eine der wichtigsten Richtungen,
00:01:46die wir sehen,
00:01:47ist,
00:01:47dass wir Code-Agenten nicht nur für Programmierung,
00:01:50sondern auch für allgemeine Aufgaben nutzen.
00:01:52Sei es Try,
00:01:53ein Agent den ich früher dieses Jahr gebaut habe und der Code im Hintergrund ausführt,
00:01:57um Aufgaben zu bewältigen – wir ermöglichen unseren Entwicklern jetzt,
00:02:00auf Basis von Reasoning-Modellen aufzubauen,
00:02:03aber auch auf Dingen wie Sandboxing und anderen Primitives,
00:02:05die wir in Codecs integriert haben.
00:02:07– Sehr gut.
00:02:09V0?
00:02:10– Das Ziel von V0 ist es,
00:02:11Entwicklern Preview-getriebene agentenbasierte Programmierung zu ermöglichen.
00:02:16Wenn du heute Web-Apps baust,
00:02:18hast du normalerweise einen Editor offen,
00:02:20deine IDE offen,
00:02:21irgendwelchen Code,
00:02:22und dann eine Vorschau dessen,
00:02:23was du gerade baust.
00:02:25Normalerweise läufst du einen Dev-Server.
00:02:26Mit V0 kannst du einfach einen Agenten laufen lassen und direkt gegen deine laufende App promoten.
00:02:32Und so sehen wir die Zukunft der Developer Experience.
00:02:35– Okay, sehr gut.
00:02:36Und jeder hat unterschiedliche Oberflächen,
00:02:38um auf eure Coding-Agenten zuzugreifen.
00:02:40Ich denke,
00:02:40eines der Dinge,
00:02:41das wir zum Auftakt besprechen wollen,
00:02:43ist: Wie wichtig ist lokal versus Cloud?
00:02:45Du hast mit lokal angefangen und dann Cloud dazugenommen,
00:02:47du mit Cloud angefangen und dann lokal dazugenommen,
00:02:49du bist nur Cloud.
00:02:50Wie ist das Verhältnis?
00:02:52Werden sich alle irgendwann zusammen vereinigen?
00:02:55– Ja, vielleicht kann ich da anfangen.
00:02:58Ich denke,
00:02:58am Ende des Tages geht es darum,
00:03:00dass diese Agenten so hilfreich wie möglich sind und eine sehr ähnliche Silhouette wie ein Mensch haben,
00:03:06mit dem du arbeiten könntest.
00:03:08Und es gibt da nicht lokale Menschen und Remote-Menschen,
00:03:11die so sind,
00:03:12dass nur einer in dieser Umgebung funktioniert und der andere nur in jener.
00:03:16Generell können Menschen hilfreich sein,
00:03:18egal ob du mit ihnen in einem Meeting eine Idee entwickelst oder gemeinsam an einem Computer sitzt.
00:03:24Also asymptotisch müssen diese dasselbe werden,
00:03:27aber kurzfristig ist Remote typischerweise – das ist das,
00:03:31was wir sehen – typischerweise nützlicher für kleinere Aufgaben,
00:03:36die du mit gutem Gewissen delegieren kannst.
00:03:39Lokal ist eher wenn du näher beim Agenten sein möchtest,
00:03:43bei einer größeren oder komplizierteren Aufgabe,
00:03:47die du aktiv monitoren wirst.
00:03:49Und du möchtest,
00:03:50dass er lokal läuft,
00:03:51denn wenn etwas schiefgeht,
00:03:52musst du den Branch nicht herunterpullen und dann neu anfangen,
00:03:55sondern du bist direkt da um ihn zu lenken.
00:03:57– Ja,
00:03:58vielleicht bin ich einfach gefräßig,
00:04:00aber ich will beides.
00:04:00Und ich denke,
00:04:01eine Modalität zu Matans Punkt: Ich mag darüber nachdenken,
00:04:05was die primären Formen der Zusammenarbeit sind,
00:04:07die ich mit meinen Kollegen gewohnt bin und die ich genieße.
00:04:11Oft fängt das mit etwas wie einer Brainstorm-Session an,
00:04:14wo wir einfach gemeinsam in einem Raum an etwas arbeiten.
00:04:17Bei dem Projekt,
00:04:18an dem wir gearbeitet haben – ein gutes Beispiel war agents.md,
00:04:21unsere Custom Instructions,
00:04:22die generisch über verschiedene Coding-Agenten hinweg konzipiert sind.
00:04:26Der Anfang war,
00:04:27dass Romain und ich einfach in einem Raum diese Idee entwickelt haben.
00:04:31Dann haben wir angefangen zu sketchen und ein Foto gemacht und es dann lokal in Codecs CLI gestartet,
00:04:36wie in einem Workshop an einer Next.js-App,
00:04:38an der wir arbeiten konnten,
00:04:39dann zum Essen gegangen,
00:04:40sind zurückgekommen.
00:04:41Die Struktur war schon gut.
00:04:44Und von da an konnten wir noch etwas genauer iterieren.
00:04:46Diese Art von Pair-Programming und Brainstorm-Erlebnis zu haben ist wichtig.
00:04:49Und zum zweiten Punkt,
00:04:51welche Aufgaben man delegiert: Historisch waren kleinere,
00:04:54klar umrissene Aufgaben,
00:04:56bei denen die Ausgabe klar definiert ist,
00:04:58die richtige Modalität wenn man "Fire and Forget" macht.
00:05:02Aber was wir mit GBD5 Codecs sehen – wir haben es vor etwa zwei Monaten gelauncht –
00:05:08einer der Hauptunterschiede ist,
00:05:09dass es längere,
00:05:10komplexere,
00:05:11mehrdeutigere Aufgaben bewältigen kann,
00:05:13solange du klar machst,
00:05:14was du am Ende möchtest.
00:05:16Es kann stundenlang arbeiten.
00:05:18Ich denke,
00:05:18diese Verschiebung wird mit besseren Modellen mehr Anwendungsfälle ermöglichen.
00:05:24– Ja.
00:05:24Ja,
00:05:25ich denke,
00:05:25es gibt drei Teile,
00:05:26um einen Agenten zum Laufen zu bringen.
00:05:27Da ist die Agent-Loop,
00:05:28da sind die Tool-Aufrufe,
00:05:30die er macht,
00:05:30und dann die Ressourcen,
00:05:31auf die diese Tool-Aufrufe wirken müssen.
00:05:34Ob du Cloud oder lokal zuerst machst,
00:05:35hängt davon ab,
00:05:36wo diese Ressourcen sind.
00:05:37Wenn du an einem lokalen Dateisystem arbeiten möchtest,
00:05:39sind das die Ressourcen,
00:05:40die du zugreifen musst.
00:05:41Es macht vollkommen Sinn, dass deine Agent-Loop lokal läuft.
00:05:44Wenn du auf Ressourcen zugreifst,
00:05:45die typischerweise in der Cloud existieren – du ziehst aus GitHub,
00:05:49direkt aus einem Drittanbieter-Repo – macht es Sinn,
00:05:52dass der Agent in der Cloud startet.
00:05:54Letztendlich existieren diese Ressourcen aber an beiden Orten.
00:05:57Jeder Entwickler erwartet,
00:05:58dass ein Agent sowohl auf dem lokalen Dateisystem als auch auf einem offenen PR,
00:06:02der auf GitHub gehostet wird,
00:06:04arbeiten kann.
00:06:04Es spielt also keine Rolle, wo du anfängst.
00:06:07Ich denke,
00:06:07alle konvergieren zum selben Punkt: Die Agent-Loop muss überall laufen können,
00:06:11die Tool-Aufrufe müssen von der Cloud lokal oder von lokal in die Cloud gestreamt werden..
00:06:16Und dann hängt alles davon ab,
00:06:18wo die Ressourcen sind,
00:06:19auf die du wirken möchtest.
00:06:20– Ja, sehr gut.
00:06:22Okay,
00:06:22also wir haben off-stage geredet und haben nach würzigen Fragen gesucht.
00:06:27Und die hier hat mir besonders gefallen und ich denke,
00:06:30sie ist sehr aktuell.
00:06:31Produziert ihr "Slop" als euer Geschäftsmodell?
00:06:33Sind wir in Gefahr, in einer Hype-Blase zu stecken,
00:06:40wo wir glauben, dass das ein nachhaltiger Weg zu AGI ist?
00:06:44– Ich meine,
00:06:45man könnte sagen,
00:06:46dass die einen der Schatz des anderen "Slop" ist,
00:06:50was gewissermaßen stimmt.
00:06:52Wenn du zum Beispiel ein Repo hast,
00:06:56das überhaupt keine Dokumentation hat.
00:07:00Du könntest viele der Tools,
00:07:03über die wir sprechen,
00:07:05nutzen um Dokumentation zu generieren.
00:07:08Wird es die am besten gepflegte Dokumentation sein?
00:07:13Nein, aber bringt es Wert?
00:07:16Ja,
00:07:16meiner Meinung nach,
00:07:18denn durch alte Legacy-Code-Basen ohne Docs zu wühlen ist viel schwerer,
00:07:22als durch einigermaßen fehlerhafte Dokumentation zu schauen.
00:07:26Das Wichtigste ist,
00:07:28herauszufinden,
00:07:29wo man diese Tools einsetzen kann und in welchem Maß es
00:07:33"Slop"
00:07:34ist,
00:07:34hängt davon ab,
00:07:36wie viel Anleitung du gibst.
00:07:38Wenn du einfach sagst: "Bau mir eine App,
00:07:40die das macht",
00:07:41bekommst du wahrscheinlich eine generische Slop-App – (lachen) Das ist lila.
00:07:44– Ja, blau, lila, wie ein Übergang, ja.
00:07:48Wenn du stattdessen sehr methodisch darüber bist,
00:07:51genau das,
00:07:51was du willst,
00:07:52und du hast die Tools um Tests zu laufen,
00:07:55um die Fähigkeiten zu verifizieren,
00:07:57die du anforderst.
00:07:58Ich denke,
00:07:58das macht es viel strukturierter – ähnlich wie wenn du einen Junior-Engineer in dein Team einstellst und sagst:
00:08:06"Hey,"
00:08:07mach das."
00:08:08Sie werden wahrscheinlich ein durchschnittliches Ergebnis liefern,
00:08:12weil sie keine andere Spezifikation haben.
00:08:14Und es ist ziemlich unklar,
00:08:16was du eigentlich getan haben möchtest.
00:08:19– Ich denke, das Schlüsselwort ist "Leverage", richtig?
00:08:21KI-Coding-Agenten ermöglichen es dir,
00:08:2310x mehr zu tun,
00:08:24als du allein könntest,
00:08:25mit einer ziemlich hohen Minimalschwelle.
00:08:27Wenn du Fähigkeitslevel gegen wie nützlich ein Agent ist oder wie nützlich es ist,
00:08:31Nicht-Slop zu generieren plottest,
00:08:32gibt es wahrscheinlich eine ziemlich tiefe Minimalschwelle wenn du keine Fähigkeiten hast.
00:08:36Du hast immer noch eine ziemlich hohe Minimalschwelle.
00:08:38Agenten sind gleich aus der Box ziemlich gut.
00:08:39Wenn du nichts über Entwicklung weißt,
00:08:41wird der Agent viel mehr tun als du je könntest.
00:08:44Aber je höher deine Fähigkeiten werden,
00:08:46Senior-Engineers,
00:08:46Principal-Engineers und Distinguished-Engineers nutzen Agenten anders.
00:08:50Sie nutzen es,
00:08:50um die Dinge,
00:08:51die sie bereits tun können,
00:08:52zu verbessern.
00:08:53Ein Principal-Engineer könnte manuell vielleicht 5.000 Zeilen Code pro Tag schreiben.
00:08:57Mit Agenten können sie 50.000 Zeilen Code pro Tag schreiben.
00:09:00Und es funktioniert wirklich auf der Ebene der Qualität deiner Inputs und des Wissens,
00:09:03das du reinfließen lässt.
00:09:04Ich denke,
00:09:05wir erhöhen die Minimalschwelle langsam über die Zeit,
00:09:09indem wir bessere Agenten bauen.
00:09:11Aber ich denke, das ist eine Form von Leverage.
00:09:14Es ist eine Möglichkeit,
00:09:15die Dinge,
00:09:16die du bereits tun kannst,
00:09:17zu beschleunigen.
00:09:18Und für Leute ohne Fähigkeiten kannst du die Minimalschwelle wirklich erhöhen.
00:09:23– Absolut,
00:09:24und um auf beide Punkte hinzuzufügen: Ich denke,
00:09:26sie sind Werkzeuge und Verstärker von Handwerk.
00:09:29Wenn du es hast, kannst du mehr davon tun.
00:09:31Wenn nicht,
00:09:31ist es schwerer,
00:09:32aber es erhöht die Minimalschwelle.
00:09:34Ich denke, das ist wirklich wichtig zu betonen.
00:09:36Ich denke,
00:09:36für Leute die ihren ersten Prototyp bauen oder eine Idee iterieren möchten – das Beispiel,
00:09:42das vorher erwähnt wurde.
00:09:44Es ist nicht,
00:09:44dass ich kein Frontend machen könnte,
00:09:46das irgendwie inhaltsgesteuert ist,
00:09:48sondern ich hatte einfach keine Zeit.
00:09:51Und es war spaßiger,
00:09:51einfach auf ein Whiteboard zu zeichnen,
00:09:53zu reden,
00:09:54eine Unterhaltung zu führen,
00:09:55und es dann einem Agenten zu geben.
00:09:57Aber ich denke,
00:09:57ein interessantes Beispiel war,
00:09:59als wir viel früher Iterationen von Codecs bauten,
00:10:02vor über einem Jahr.
00:10:03Wir testeten zwei verschiedene Archetypen: Leute,
00:10:07die viel Product Engineering machten,
00:10:10die daran gewöhnt sind,
00:10:11lokale,
00:10:12Inner-Loop-Tools zu nutzen,
00:10:14gewöhnt sind zu chatten und vielleicht zu iterieren.
00:10:19Und dann eine ganz andere Modalität,
00:10:20wenn wir mit Leuten aus den Reasoning-Teams sprachen – sie würden vielleicht fünf Minuten damit verbringen,
00:10:26die Aufgabe zu definieren und ein längeres Aufsatz-ähnliches Wort-Problem für den Agenten zu schreiben,
00:10:31und der würde dann eine Stunde arbeiten.
00:10:33Und das war praktisch o1 oder frühere Versionen davon.
00:10:37Das Interessante war,
00:10:39dass die Art und Weise,
00:10:40wie Menschen die Aufgabe dem Agenten geben würden,
00:10:43völlig unterschiedlich war,
00:10:44basierend auf ihrem Verständnis,
00:10:46was denken sie,
00:10:47das braucht es.
00:10:48Ich denke,
00:10:49es geht wirklich darum,
00:10:50auf Spezifizität zu setzen,
00:10:51sehr klar darüber zu sein,
00:10:53was die Ausgabe sein soll.
00:10:55Und ich denke,
00:10:55da ist eine größere Verantwortung,
00:10:57sowohl auf uns als Agentenbauren als auch auf Leute,
00:11:00die Modelle trainieren,
00:11:01diese Minimalschwelle zu erhöhen und sicherzustellen,
00:11:04dass die Maximalschwelle für Leute mit hohem Handwerk und hohem Geschmack ausgelöst wird,
00:11:09wie sie es sich wünschen.
00:11:11– Ich denke,
00:11:12eigentlich hat etwas,
00:11:13das du erwähnt hast,
00:11:13diese Idee hervorgebracht,
00:11:15die wir bemerkt haben.
00:11:16Unsere Zielgruppe ist Enterprise.
00:11:19Und etwas,
00:11:19das wir immer wieder sehen,
00:11:21ist dass es eine sehr interessante Bimodalität bei der Annahme von agentennativer Entwicklung gibt.
00:11:28Insbesondere sind früher in der Karriere stehende Entwickler offener für agentennativen Aufbau,
00:11:34aber sie haben keine Erfahrung mit der Verwaltung von Engineering-Teams.
00:11:39Also sind sie vielleicht nicht so vertraut mit Delegation,
00:11:43die gut funktioniert.
00:11:44Währenddessen haben erfahrenere Engineers viel Erfahrung mit Delegation.
00:11:47Sie wissen,
00:11:48dass wenn ich diese genauen Dinge nicht spezifiziere,
00:11:50wird es nicht erledigt.
00:11:51Und sie sind sehr gut darin,
00:11:52diesen Absatz zu schreiben,
00:11:54aber sie sind ziemlich stur und wollen ihre Art zu programmieren nicht ändern – man muss ihnen Emacs aus den kalten,
00:12:01toten Händen reißen.
00:12:03Es ist also ein interessantes Gleichgewicht.
00:12:05– Lustig, dass du das sagst.
00:12:06Ähnlich sehen wir im Enterprise: Senior Engineers,
00:12:09höher gestellte Leute schreiben Tickets.
00:12:12Sie machen also die ganze Arbeit,
00:12:13die Spezifikation dessen zu schreiben,
00:12:15was getan werden muss.
00:12:16Sie geben es einem Junior-Engineer ab,
00:12:17um es tatsächlich zu tun.
00:12:18Der Junior-Engineer nimmt dieses wunderbar geschriebene Ticket und gibt es dem Agenten,
00:12:21richtig?
00:12:21Also arbitriert man die Idee,
00:12:23dass der Junior-Engineer die Agent-Arbeit machen wird,
00:12:26weil er sich damit wohler fühlt.
00:12:28Aber der Senior-Engineer ist die Person,
00:12:30die wirklich gut darin ist,
00:12:31die Spezifikation zu schreiben,
00:12:32sehr gut darin versteht,
00:12:33welche architektonischen Entscheidungen wir treffen sollten und das in ein Ticket fasst.
00:12:37– Ja,
00:12:38für die,
00:12:38die es nicht wissen: Matan und Factory insgesamt haben über Agent-Native Development geschrieben und setzen sich dafür ein.
00:12:44Ihr könnt mehr auf ihrer Website lesen.
00:12:45Ich denke,
00:12:46eine Sache,
00:12:47die ich ansprechen möchte,
00:12:49ist ein Terminologie-Punkt:
00:12:51"Raise the floor"
00:12:52für dich ist gut.
00:12:54Ich denke,
00:12:54andere Leute sagen auch
00:12:55"lower the floor"
00:12:56und meinen das gleiche.
00:12:57Es geht grundsätzlich um Fähigkeitslevel und was Leute tun können und einfach mehr Ressourcen dafür zu geben.
00:13:05Ich denke,
00:13:06die andere Sache ist: Viele Leute denken über die Model-Layer nach.
00:13:13Offensichtlich besitzt ihr eure eigenen Modelle,
00:13:17ihr beiden nicht.
00:13:18Und ich denke,
00:13:19das ist gerade ein heißes Gesprächsthema zum Wert.
00:13:22Brian Chesky von Airbnb hat gesagt,
00:13:25dass der meiste Wert scheinbar von Quinn kommt.
00:13:28Wie wichtig sind Open-Source-Modelle für euch beide und ihr könnt auch beitragen,
00:13:33aber wie wichtig sind Open-Source-Modelle als Strategie für euch beide?
00:13:37– Ich würde gerne erst von dir hören.
00:13:38– Ja.
00:13:38Nun, ich liebe Open-Source-Modelle.
00:13:42Ich denke,
00:13:42eines der wichtigsten Dinge ist – um über Modelle zu sprechen – ich denke,
00:13:47Offenheit ist wirklich wichtig für einen nachhaltigen Entwicklungszyklus.
00:13:51Mit Codecs CLI haben wir es von Anfang an Open-Sourced,
00:13:54und Teil der Priorität war zu verstehen,
00:13:56dass ein Open-Source-Modell kommen wird..
00:13:58Wir wollten sicherstellen,
00:13:59dass wir so gut wie möglich dokumentieren,
00:14:01wie man unsere Reasoning-Modelle nutzt.
00:14:03Wir haben viel Verwirrung gesehen über: Welche Tools gebe ich,
00:14:06wie sollte die Umgebung sein,
00:14:07die Ressourcen.
00:14:08Wir wollten sicherstellen,
00:14:09dass das so klar wie möglich ist und dass es auch gut mit Open-Source-Modellen funktioniert.
00:14:12Ich denke,
00:14:13es gibt definitiv viele Anwendungsfälle,
00:14:15besonders wenn du in eingebettete Anwendungsfälle kommst oder Fälle,
00:14:20wo du nicht möchtest,
00:14:21dass Daten die Grenzen verlassen.
00:14:23Da gibt es viele gute Gründe dafür, das zu tun.
00:14:26Und ich denke,
00:14:27der Vorteil von Cloud-gehosteten Modellen – und das sehen wir bei vielen Open-Source-Modellen.
00:14:33Sie laufen nicht auf dem Gerät,
00:14:34aber sind eigentlich Cloud-gehostet,
00:14:36vielleicht aus Effizienzgründen,
00:14:38vielleicht aus Kostengründen,
00:14:40es gibt immer noch viel Wert in der reinen Intelligenz,
00:14:43die du von einem viel größeren Modell bekommst.
00:14:46Und deshalb sehen wir,
00:14:47dass Leute wirklich zu Modellen von o3 bis GPT-4.5 bis GPT-4.5 Codecs greifen.
00:14:52Es gibt immer noch viel Wert darin.
00:14:53Jetzt sehen wir,
00:14:55dass dieses Überangebot sich langsam auflöst,
00:14:58wo alle paar Monate ein neues,
00:15:00sehr kleines,
00:15:01sehr beeindruckendes Modell kommt.
00:15:04Und ich denke,
00:15:04das ist die Magie,
00:15:05wenn wir einfach zu Beginn dieses Jahres schauen,
00:15:07als wir o3 mini als Grenzmodell hatten und wo wir jetzt sind.
00:15:10Also ja,
00:15:11ich denke,
00:15:11es gibt riesigen Wert in Open-Source-Modellen,
00:15:14aber persönlich,
00:15:15aus Nutzungsperspektive,
00:15:17denke ich,
00:15:17es gibt mehr Wert darin,
00:15:19die Cloud-gehosteten zu nutzen.
00:15:21– Ja, ich intervene mal kurz.
00:15:23Factory kümmert sich wirklich um Datenschutz,
00:15:25Sicherheit,
00:15:26Agent-Robustheit.
00:15:27Wenn du auf ihn triffst, sprich mit ihm mehr über das.
00:15:30Aber für euch beide,
00:15:31vielleicht möchtet ihr starten mit: Was ist euer ungefährer Prozentsatz von Open-Source-Modell-Token,
00:15:37die in euren jeweiligen Apps generiert werden?
00:15:39Und wird er hoch oder runter gehen?
00:15:42– Also ich denke,
00:15:43um zu beginnen,
00:15:43weil ich denke,
00:15:44was du sagst,
00:15:45ist wirklich interessant.
00:15:47Vor ein paar Wochen,
00:15:48als wir unser Factory CLI Tool veröffentlichten,
00:15:50waren Leute wirklich interessiert,
00:15:52denn wir veröffentlichten auch unser Score auf diesem Benchmark namens Terminal Bench.
00:15:57Und eine der ersten Anfragen war: Könnt ihr Open-Source-Modelle testen?
00:16:02Weil unser Droid Agent völlig modell-agnostisch ist.
00:16:04Also sofort waren die Leute: Werft die Open-Source-Modelle rein und zeigt uns,
00:16:09wie es läuft.
00:16:09Und ich denke,
00:16:10etwas besonders Überraschendes war,
00:16:12dass die Open-Source-Modelle,
00:16:14besonders GLM,
00:16:15wirklich,
00:16:15wirklich gut waren.
00:16:17Sie waren offensichtlich weniger leistungsstark als die Frontier-Modelle,
00:16:22aber nicht um einen großen Satz.
00:16:24Ich denke,
00:16:25also etwas Bemerkenswertes war: Als wir die Open-Source-Modelle benchmarkten,
00:16:30waren von den sieben besten eins von den USA gebaut,
00:16:34von mir hier,
00:16:35was irgendwie schade ist.
00:16:37Die Tatsache,
00:16:38dass bei den Frontier-Modellen die USA dominiert,
00:16:42ist überall.
00:16:43Aber wenn es um Open-Source geht,
00:16:45machen wir wirklich große Fehler.
00:16:47Ich denke,
00:16:47das ist bemerkenswert und ich denke,
00:16:50da sollte es einen Aufrufen zum Handeln geben,
00:16:54um das zu ändern.
00:16:56Weil ich denke,
00:16:57um deine Frage zu beantworten: Was wir gefunden haben,
00:16:59ist,
00:17:00dass seit wir Unterstützung für Open-Source-Modelle veröffentlichten,
00:17:03der Prozentsatz der Leute,
00:17:05die Open-Source-Modelle verwenden,
00:17:07dramatisch gestiegen ist.
00:17:08Teilweise wegen der Kosten,
00:17:10und das,
00:17:10wissen Sie,
00:17:11es lässt Sie – sagen wir in dem Dokumentationsbeispiel – vielleicht Docs generieren,
00:17:16aber Sie wollen es nicht auf super hohem Reasoning haben,
00:17:20auf Maximum,
00:17:20für tausend Dollar,
00:17:21sondern nur einen ersten Pass.
00:17:24Und auch Leute mögen ein bisschen mehr Kontrolle.
00:17:28Und ich denke,
00:17:29sie bekommen viel mehr Kontrolle mit einigen dieser Open-Source-Modelle,
00:17:33sowohl Kontrolle als auch Kosten und nur Observabilität in das,
00:17:37was dort tatsächlich passiert.
00:17:39Ich denke,
00:17:39die Nachfrage ist zu einem Punkt gewachsen,
00:17:41den ich vor einem Jahr nicht erwartet hätte.
00:17:43Ich denke,
00:17:44vor einem Jahr war ich weniger bullish auf Open-Source-Modelle als ich jetzt bin,
00:17:48Open-Weight,
00:17:49aber ja.
00:17:49– Ja,
00:17:50ich denke,
00:17:50wir verwenden sowohl Open-Source- als auch Closed-Source-Modelle in unserem gesamt Agent-Pipeline.
00:17:55Und ich denke,
00:17:55die Art,
00:17:56wie wir über sie denken,
00:17:56ist dass es zwei verschiedene Anwendungsfälle für einen LLM-Aufruf gibt.
00:17:58Einer ist, dass du State-of-the-Art Reasoning willst.
00:18:01Es ist eine sehr, sehr offene Frage.
00:18:02Du weißt eigentlich nicht, was die Antwort ist.
00:18:04Das Ziel ist – die Zielfunktion ist nicht super gut definiert.
00:18:07In diesen Fällen sind Closed-Source-Modelle immer noch State-of-the-Art wenn es um Reasoning und Intelligenz geht.
00:18:13Wir verwenden Closed-Source-Modelle fast ausschließlich für diese Art von Anwendungsfällen.
00:18:16Es gibt einen zweiten Anwendungsfall,
00:18:18wo wir eine speziellere Aufgabe mit einer viel klarer Zielfunktion haben.
00:18:22In diesen Fällen versuchen wir fast immer,
00:18:24ein Open-Source-Modell zu feintunen.
00:18:26Wir sind okay mit einem 20%-Treffer-Rückgang in der Reasoning-Fähigkeit,
00:18:30damit wir wirklich einen sehr spezifischen Anwendungsfall feintunen können.
00:18:35Und ich denke,
00:18:36wir haben herausgefunden,
00:18:37dass Open-Source-Modelle extrem schnell aufholen.
00:18:39Vor anderthalb Jahren wäre es für uns unvorstellbar gewesen,
00:18:43Open-Source-Modelle in v0s Pipeline zu nutzen.
00:18:45Heute fragen wir uns bei jedem einzelnen Teil der Pipeline: Können wir hier Open-Source-Modelle einbinden?
00:18:49Können wir das,
00:18:50was wir aktuell mit Closed-Source-Frontier-Modellen machen,
00:18:54durch ein Fine-Tune eines Open-Source-Modells ersetzen?
00:18:57Und wir haben großartige Erfolge mit Qwen,
00:19:00QEMI-K2 und ähnlichen Modellen erzielt.
00:19:02Ja,
00:19:03ich würde das als eine der größten Veränderungen bezeichnen,
00:19:06die ich beobachtet habe.
00:19:08Anfang des Jahres machte ich einen Podcast mit Ankur von BrainTrust,
00:19:12und er sagte,
00:19:13die Nutzung von Open-Source-Modellen liegt bei etwa 5% und sinkt..
00:19:17Jetzt denke ich,
00:19:18wird das für jeden im Bereich von 10 bis 20% liegen.
00:19:22Interessanterweise investieren auch Closed-Source-Modelle stärker in ihre kleineren Modellklassen.
00:19:29Die Haikust, GPT-5 Minis, Gemini Flashes und so weiter.
00:19:33Diese Modellklasse konkurriert am meisten mit Open-Source-Modellen..
00:19:38Es ist die Small-Model-Klasse,
00:19:39die gegen ein Fine-Tune eines Open-Source-Modells antreten muss.
00:19:42Und ich denke,
00:19:42es gibt viele Anwendungsfälle,
00:19:44bei denen ein Frontier-Modell einfach Overkill wäre.
00:19:47Und wenn es Overkill ist,
00:19:49wird man natürlich versucht sein,
00:19:51etwas schnelleres und billigeres zu nutzen..
00:19:53Ich denke,
00:19:54ein Teil dieses Unterschieds bei der prozentualen Nutzung ist: Es gibt einen Punkt,
00:20:00an dem Open-Source-Modelle für die meisten Aufgaben ausreichend sind,
00:20:05und nur für einige Spezialfälle brauchst du mehr Rechenpower.
00:20:10Ich denke,
00:20:10wir nähern uns diesem Punkt mit einigen dieser Open-Source-Modelle,
00:20:13weshalb ich erwarten würde,
00:20:14dass wir künftig mehr Nutzung sehen werden.
00:20:16Ja, großartig, das ist sehr ermutigend.
00:20:18Wir haben noch etwas Zeit für die abschließende Frage: Was können eure Agenten heute noch nicht tun,
00:20:23das ihr euch wünscht und das sie wahrscheinlich nächstes Jahr können werden?
00:20:27Fange ich an?
00:20:31Okay.
00:20:32Ja,
00:20:32ich denke,
00:20:33was wir im letzten Jahr gesehen haben – um mit o1 vor etwas über einem Jahr anzufangen,
00:20:39oder o1 Preview – was wir damals sahen,
00:20:42als ich sehr frühe Checkpoints dieses Modells nutzte,
00:20:45war es großartig im Vergleich zu GPT-4,
00:20:48hatte aber immer noch so viel Luft nach oben.
00:20:51Ich war damals im Security-Team und es gab viele Aufgaben,
00:20:56die ich diesem Modell einfach nicht delegieren konnte.
00:21:00Und wenn wir das mit heute vergleichen,
00:21:02wo ich eine gut definierte Aufgabe nehme – vielleicht zwei Sätze,
00:21:05ein paar Stichpunkte mit den Fallstricken,
00:21:07bei denen ich denke,
00:21:08du könntest steckenbleiben – und dann komme ich eine halbe Stunde oder eine Stunde später zurück und es ist fertig.
00:21:14Wir sehen Fälle,
00:21:15wo es viele Stunden läuft,
00:21:16vielleicht sogar sieben oder acht Stunden,
00:21:19einen ganzen Arbeitstag lang – was ich viel Zeit in Meetings verbringe und daher nicht immer einen großen Zeitblock habe.
00:21:26Aber das ist nur die Hälfte von echtem Engineering.
00:21:30Ein Teil ist Coding,
00:21:31ein Teil ist Architekturdefinition,
00:21:32Troubleshooting und Debugging.
00:21:34Die andere Hälfte ist Dokumentation schreiben,
00:21:36das System verstehen,
00:21:37Menschen überzeugen.
00:21:39Deshalb denke ich,
00:21:40werden wir einen Super-Kollaborator sehen – ob über Codecs oder andere Interfaces über das Codecs-Modell – den idealen Kollegen,
00:21:51mit dem du arbeiten willst.
00:21:53Die Person,
00:21:54an die du zuerst gehst,
00:21:55der Lieblingskollege,
00:21:57mit dem du gerne Ideen erarbeitest – das ist das,
00:21:59was wir sehen wollen,
00:22:01zumindest mit Codecs.
00:22:02Ich denke,
00:22:03wir haben schnelle Fortschritte auf zwei verschiedenen Fronten gesehen.
00:22:07Erstens: Wie viele Schritte kann ein Agent vernünftigerweise ausführen und dabei gute Ergebnisse liefern?
00:22:14Letztes Jahr waren das vielleicht ein bis drei Schritte.
00:22:17Wenn du zuverlässige Ergebnisse mit über 90% Erfolgsquote wolltest,
00:22:19hast du wahrscheinlich ein bis drei Agenturschritte durchgeführt.
00:22:22Heute führen die meisten Tools fünf bis 20 Schritte aus,
00:22:25ohne wirklich schlechte Zuverlässigkeit bei über 90% Erfolg.
00:22:29Nächstes Jahr denke ich,
00:22:30werden wir 100 bis 200 Plus-Schritte hinzufügen,
00:22:32tonnenweise Schritte auf einmal durchführen,
00:22:34langfristige Aufgaben über mehrere Stunden hinweg und sind zuversichtlich,
00:22:37dass wir am Ende ein nützliches Ergebnis erhalten.
00:22:40Zweitens: Welche Ressourcen können genutzt werden?
00:22:42Vor einem Jahr war es praktisch nur das,
00:22:44was du in die Prompt-Form eingegeben hast.
00:22:47Heute kannst du externe Verbindungen über MCP konfigurieren oder API-Aufrufe direkt in deiner Anwendung tätigen.
00:22:55Das kannst du machen,
00:22:56wenn du sachkundig bist und die Fähigkeit hast,
00:22:58Dinge zu konfigurieren.
00:22:58Und ich denke, in einem Jahr wird das einfach passieren.
00:23:00Es wird einfach funktionieren.
00:23:02Das Ziel ist: Du solltest nicht wissen müssen,
00:23:04welche Kontextquellen du dem Agenten geben musst.
00:23:06Der Agent wird proaktiv diese Kontextquellen finden.
00:23:09Wir sehen das heute schon ein bisschen,
00:23:11aber ich bin mir noch nicht wirklich sicher,
00:23:13dass das heute zuverlässig und nützlich ist.
00:23:16Ich denke, nächstes Jahr wird das der Standard sein.
00:23:18Ja, dem würde ich zustimmen.
00:23:19Ich denke,
00:23:20Agenten können heute praktisch alles tun,
00:23:22aber der Grad,
00:23:23in dem sie das zuverlässig und proaktiv tun,
00:23:26ist der Schieber,
00:23:27der sich verändern wird.
00:23:29Aber dieser Schieber hängt auch vom Nutzer ab.
00:23:31Wenn du ein Nutzer bist,
00:23:32der sein Verhalten nicht wirklich ändert und dem Agenten nicht entgegenkommst,
00:23:36bekommst du vielleicht weniger Zuverlässigkeit und Proaktivität.
00:23:38Aber wenn du dein Setup richtig konfigurierst oder deine Umgebung richtig einrichtest,
00:23:43kann er das zuverlässiger und proaktiver tun.
00:23:45Ja, großartig.
00:23:46Wir sind zeitlich vorbei.
00:23:48Mein Beitrag ist Computer Vision.
00:23:49Probiert alle Atlas aus.
00:23:51Probiert mehr Computer-Vision-Anwendungsfälle aus,
00:23:54und danke vielmals für eure Zeit.
00:23:55Danke.
00:23:56(Publikum applaudiert) (lebhafte Musik)

Key Takeaway

KI-Programmierungs-Agenten werden durch bessere Spezifizierung, längere Aufgaben-Durchsätze und die Konvergenz von lokalen und Cloud-Ressourcen zu unverzichtbaren Produktivitätswerkzeugen, die die Programmierfähigkeiten von Engineers verstärken, anstatt sie zu ersetzen.

Highlights

KI-Programmierungs-Agenten ermöglichen End-to-End-Softwareentwicklung, einschließlich Dokumentation, Tests und Code-Reviews, nicht nur reinem Programmieren

Die Zukunft liegt in nahtloser Zusammenarbeit zwischen lokalen und Cloud-basierten Agenten, wobei die Ressourcenlokalität darüber entscheidet, wo die Agent-Loop laufen sollte

Agenten funktionieren am besten mit klaren Spezifikationen und guter Anleitung – die Qualität der Ausgabe hängt stark vom Grad der Detaillierung der Eingaben ab

Open-Source-Modelle gewinnen dramatisch an Bedeutung und werden für spezialisierte Aufgaben durch Fine-Tuning eingesetzt, während Frontier-Modelle für komplexes Reasoning reserviert bleiben

Die Fähigkeit von Agenten zur Durchführung längerer, mehrdeutiger Aufgaben nimmt rapide zu, von ehemals 1-3 Schritten auf heute 5-20 und bald 100-200 Schritte

Senior-Engineers definieren Spezifikationen in Tickets, Junior-Engineers delegieren diese an Agenten – ein Hybrid-Modell, das Expertise mit Agentur-Automatisierung verbindet

Der Schlüssel zur Nutzung liegt nicht in der bloßen Existenz von Agenten, sondern in der Zuverlässigkeit, Proaktivität und dem Grad der Benutzeradaption an neue Workflows

Timeline

Einführung und Vorstellungsrunde der Panelisten

Das Podium beginnt mit einer Begrüßung zum Thema "Die Zukunft von KI-Programmierung" und stellt drei führende Personen aus dem Bereich vor. Matan von Factory wird vorgestellt, der Autonomie in der Softwareentwicklung durch sogenannte "Droids" – End-to-End-Entwicklungs-Agenten – vorantreibt. Diese Agenten konzentrieren sich nicht nur auf das Programmieren selbst, sondern auch auf die damit verbundenen Aufgaben wie Dokumentation, Tests und Code-Reviews. Der Kontext zeigt, dass diese Agenten als umfassende Lösung für den gesamten Softwareentwicklungsprozess konzipiert sind, um Entwicklern Zeit für die spannendsten Aspekte ihrer Arbeit zu geben.

Codecs und V0: Verschiedene Ansätze zu KI-Programmierungs-Agenten

Die OpenAI-Vertreter erklären ihre zwei Hauptprodukte: Codecs, das mit einer CLI begann und sich durch Codecs Cloud und das neue Codecs SDK erweiterte, sowie V0 für Preview-gesteuerte Agenten-Programmierung. Codecs konzentriert sich darauf, Reasoning-Modelle nutzbar zu machen, mit Sandboxing und anderen Primitives für allgemeine Aufgaben. V0 revolutioniert die Web-App-Entwicklung, indem es Agenten ermöglicht, direkt gegen laufende Apps zu arbeiten, anstatt dass Entwickler zwischen Editor, IDE und Vorschau wechseln müssen. Beide Tools repräsentieren unterschiedliche Oberflächen und Paradigmen, um auf KI-Programmierungs-Agenten zuzugreifen.

Die Debatte: Lokal versus Cloud und die Rolle der Ressourcentypen

Das Panel diskutiert, ob Agenten lokal oder in der Cloud laufen sollten und kommt zu einem wichtigen Schluss: Die Entscheidung hängt von der Ressourcenlokalität ab. Wenn ein Agent auf ein lokales Dateisystem zugreift, sollte die Agent-Loop lokal laufen; wenn er auf Cloud-Ressourcen wie GitHub-Repositories zugreift, macht Cloud-Ausführung Sinn. Das Ziel ist asymptotische Konvergenz: Agenten sollten überall laufen können und zwischen lokalen und Cloud-Ressourcen streamen. Die Panelisten stimmen darin überein, dass Entwickler erwarten, dass Agenten sowohl mit lokalen Dateisystemen als auch mit offenen Pull Requests arbeiten können, unabhängig davon, wo die Ausführung beginnt.

Pair-Programming und Delegationsmuster mit Agenten

Ein konkretes Beispiel wird mit dem Projekt "agents.md" gegeben, das Romain und ein Kollege gemeinsam entwickelten – zunächst durch Brainstorming in einem Raum, dann durch Skizzierung und anschließende Iteration mit Codecs CLI an einer Next.js-App. Dieses Pair-Programming-Erlebnis kombiniert Mensch-zu-Mensch-Zusammenarbeit mit Agenten-Unterstützung und zeigt, dass die beste Nutzung in hybriden Workflows liegt. Historisch wurden kleinere, klar umrissene Aufgaben delegiert, aber mit besseren Modellen wie GPT-4-O3 können nun längere, komplexere und mehrdeutigere Aufgaben bewältigt werden, die stundenlang laufen können. Die Verschiebung zu besser definierten Aufgaben mit klaren Endzielen ermöglicht vertrauensvollere Delegation an Agenten.

Die "Slop"-Debatte: Qualität durch Spezifizierung und Struktur

Eine Frage aus dem Publikum stellt, ob Agenten-Tools hauptsächlich "Slop" – minderwertigen, generischen Code – produzieren und ob dies einer nachhaltigen Weg zu AGI darstellt. Die Antwort zeigt eine Nuance: Die Qualität hängt stark vom Grad der Spezifizierung ab. Wenn man einem Agenten vague Anweisungen gibt (z.B. "Baue mir eine App"), bekommt man generischen Code. Mit methodischen, klaren Anforderungen, Tests zur Verifizierung von Fähigkeiten und detaillierten Spezifikationen kann man strukturierte, hochwertige Ergebnisse erreichen. Die Panelisten verwenden das Analogon eines Junior-Engineers: Ohne klare Spezifikation liefert er durchschnittliche Ergebnisse; mit klarem Ticket und Anforderungen kann er großartige Arbeit leisten. Dies unterstreicht, dass Agenten Werkzeuge sind, die das handwerkliche Geschick verstärken, anstatt es zu ersetzen.

Minimalschwelle und Leverage-Effekte: Wer profitiert am meisten von Agenten?

Die Diskussion offenbart ein wichtiges Konzept: Agenten erhöhen sowohl die Minimalschwelle (Junior-Entwickler können mehr erreichen) als auch das Leverage für erfahrene Engineers. Eine Grafik wird mentalisiert, die zeigt, dass selbst ohne Fähigkeiten ein Agent viel mehr tut als ein unskillierter Mensch, aber je höher die Skills, desto mehr Leverage können Agenten bieten – ein Principal-Engineer könnte von manuell 5.000 Zeilen pro Tag auf 50.000 mit Agenten kommen. Es gibt auch eine interessante Bimodalität bei der Adoption: Junior-Developers sind offener für agentennativen Aufbau, aber weniger erfahren mit Delegation; Senior-Engineers verstehen Delegation besser und können präzise Spezifikationen schreiben, sind aber oft gegen Veränderungen ihrer Arbeitsweise. Die Verantwortung liegt auf Agent-Bauern und Modell-Trainern, diese Schwellen kontinuierlich zu verbessern.

Die Enterprise-Realität: Tickets, Junior-Engineers und Agent-Delegation

Ein praktisches Enterprise-Muster wird offenbart: Senior-Engineers schreiben detaillierte Tickets mit klarer Spezifikation und architektonischen Entscheidungen. Junior-Engineers nehmen diese hervorragend geschriebenen Tickets und übergeben sie Agenten zur Implementierung, weil sie sich damit komfortabler fühlen als Senior-Engineers, die an ihren etablierten Workflows festhalten möchten. Dies zeigt, wie Agenten in vorhandene Hierarchien und Prozesse integriert werden, anstatt diese zu revolutionieren. Die Diskussion betont auch Terminologie: "Floor raising" (Minimalschwelle erhöhen) ist bei beiden Gruppen wichtig – mehr Ressourcen und Fähigkeiten zu ermöglichen. Das Fazit ist, dass es nicht um Ersetzung geht, sondern um strategische Integration in bestehende Team-Strukturen und Workflows.

Open-Source versus Frontier-Modelle: Strategische Nutzung und Trends

Eine ausführliche Diskussion über die Rolle von Open-Source-Modellen versus Frontier-Modellen zeigt, dass beide ihren Platz haben. Bei Open-Source-Modellen werden massive Fortschritte gemacht – Benchmarks wie Terminal Bench zeigen, dass Modelle wie GLM wirklich beeindruckend sind, obwohl sie weniger leistungsfähig als Frontier-Modelle sind. Die Nutzung von Open-Source-Modellen ist dramatisch gestiegen, teilweise wegen der Kosten und der Kontrolle, die sie bieten. Factory und OpenAI verwenden beide Modelle strategisch: Frontier-Modelle für offene, komplexe Reasoning-Aufgaben mit undefinierter Zielfunktion; Open-Source-Modelle für spezialisierte Aufgaben, die feiner abgestimmt werden können. Die Haikust, GPT-4-Mini und Gemini Flash konkurrieren direkt mit fine-tuned Open-Source-Modellen, und viele Aufgaben erfordern nicht die maximale Rechenleistung eines Frontier-Modells. Die Prognose: Open-Source-Nutzung wird von aktuellen 5-10% auf 10-20% oder höher ansteigen.

Zukünftige Entwicklungen: Längere Aufgaben, proaktive Kontexte und der ideale Kollaborator

Die Panelisten skizzieren eine Vision für die nächsten 12 Monate: Agenten werden von heute etwa 5-20 Schritten auf 100-200+ Schritte mit über 90% Zuverlässigkeit eskalieren, um mehrstündige Aufgaben zu bewältigen. Ressourcen-Zugang wird von heute manueller Konfiguration (MCP, API-Aufrufe) zu automatischer, proaktiver Kontextfindung übergehen, ohne dass Nutzer angeben müssen, welche Kontextquellen relevant sind. Die Zukunftsvision ist ein "Super-Kollaborator" – der ideale Kollege, mit dem man gerne Ideen erarbeitet, die erste Person, die man erreicht, um Probleme zu diskutieren. Das Ziel ist nicht Automatisierung um ihrer selbst willen, sondern echte Zusammenarbeit, die echtes Engineering abdeckt: von Coding über Architektur und Debugging bis zu Dokumentation und Überzeugungsarbeit. Die Veränderung hängt auch vom Nutzer ab – wer seine Verhaltensweise und Umgebung anpasst, wird größere Zuverlässigkeit und Proaktivität erfahren.

Community Posts

View all posts