Latest / KI Espresso / Codex in der Praxis: Eine OpenAI-Schulung auf Deutsch

Transcript

Codex in der Praxis: Eine OpenAI-Schulung auf Deutsch · KI Espresso

• 0:00
  SPEAKER_00: Willkommen bei KI Espresso.
• 0:02
  SPEAKER_00: Heute hört ihr unsere deutsche Hörfassung einer OpenAI-Schulung zu Codex vom 13.
• 0:08
  SPEAKER_00: März 2026.
• 0:11
  SPEAKER_00: Wir haben sie übersetzt, weil sie an einem konkreten Softwareprojekt zeigt, wie Planung, Tests und Codeprüfung zusammenarbeiten.
• 0:19
  SPEAKER_00: Die Demo dreht sich um einen Support Desk, eine Web-Anwendung mit einem Posteingang für Kundenanfragen.
• 0:26
  SPEAKER_00: Dazu entsteht eine einfache iPhone-App, mit der Mitarbeiter diese Anfragen bearbeiten können.
• 0:32
  SPEAKER_00: Codex plant die Arbeit, nutzt Designvorlagen aus Figma und prüft Änderungen mit Tests.
• 0:38
  SPEAKER_00: Später geht es um Skills, also wiederverwendbare Arbeitsanweisungen und um ein Diagramm der Datenbankbeziehungen.
• 0:46
  SPEAKER_00: Ihr hört unsere gekürzte Videofassung, nicht die vollständige Schulung.
• 0:51
  SPEAKER_00: Manche Klicks und Bildschirmdetails lassen sich nur im Video nachvollziehen.
• 0:56
  SPEAKER_00: Für die Arbeitsabläufe bietet die Tonspur dennoch einen Einstieg.
• 1:00
  SPEAKER_00: Das Video und die Originalquelle sind in der Beschreibung verlinkt.
• 1:04
  SPEAKER_00: Die Funktionen entsprechen dem Stand der Schulung.
• 1:08
  SPEAKER_00: Die deutsche Stimme ist synthetisch und nicht die Stimme des Vortragenden.
• 1:12
  SPEAKER_00: Jetzt zur Demo.
• 1:14
  SPEAKER_00: Hier habe ich meinen iPhone 17 Pro Simulator.
• 1:17
  SPEAKER_00: Und das ist mein Posteingang für Support-Tickets.
• 1:20
  SPEAKER_00: Das funktioniert noch nicht ganz so, wie ich es erwartet habe.
• 1:24
  SPEAKER_00: Den Posteingang sehe ich.
• 1:25
  SPEAKER_00: Ich hatte aber erwartet, dass ich ein Ticket anklicken und seinen Inhalt sehen kann.
• 1:30
  SPEAKER_00: Deshalb sage ich jetzt, das funktioniert nicht.
• 1:32
  SPEAKER_00: Wenn ich ein Ticket öffne, bleibt die Ansicht leer.
• 1:41
  SPEAKER_00: Das schicken wir ab, sobald die Code-Prüfung fertig ist.
• 1:44
  SPEAKER_00: Weil Codex Zugriff auf den Simulator hat, kann es diese nächste Überarbeitung direkt selbst vornehmen.
• 1:52
  SPEAKER_00: Die App selbst entwickelt sich gerade zu unserer beliebtesten Oberfläche.
• 1:56
  SPEAKER_00: Dafür gibt es mehrere Gründe.
• 1:58
  SPEAKER_00: Erstens lassen sich darin sehr einfach mehrere Aufgaben parallel ausführen.
• 2:02
  SPEAKER_00: Außerdem kann man dort gut Funktionen wie Skills, Apps und Plugins entdecken.
• 2:07
  SPEAKER_00: Darauf kommen wir später noch zurück.
• 2:08
  SPEAKER_00: Insgesamt ist sie angenehm zu bedienen.
• 2:11
  SPEAKER_00: Vielleicht arbeitet ihr nicht ständig im Terminal, habt gerade erst mit dem Programmieren angefangen oder seid gar keine Programmierer von Beruf.
• 2:18
  SPEAKER_00: Dann sind euch manche Abläufe und Werkzeuge noch nicht so vertraut.
• 2:22
  SPEAKER_00: Die Codex-App bietet einen sehr zugänglichen Einstieg, wie wir gleich sehen werden.
• 2:30
  SPEAKER_00: Ich arbeite hier in einem Projekt.
• 2:32
  SPEAKER_00: Projekte in Codex sind Ordner auf eurem Computer.
• 2:35
  SPEAKER_00: Das kann ein Git-Repository sein, eine Sammlung von Dateien oder auch ein neuer, lehrer Ordner für ein Projekt, das ihr von Grund auf aufbauen wollt.
• 2:43
  SPEAKER_00: Links sehen wir die Projekte, die wir hier hinzugefügt haben und die bestehenden Chats oder Threads darin.
• 2:49
  SPEAKER_00: Ein paar weitere Funktionen besprechen wir später.
• 2:52
  SPEAKER_00: Automatisierungen und Plugins.
• 2:54
  SPEAKER_00: Ihr könnt auch eure vorhandenen Threads durchsuchen.
• 2:57
  SPEAKER_00: Schicken wir unseren ersten Prompt ab.
• 2:59
  SPEAKER_00: Mit Codex kann man sehr viel machen.
• 3:01
  SPEAKER_00: Wir könnten einfach fragen, was sind beliebte Aufgaben, die ich als Entwickler mit Codex erledigen kann?
• 3:11
  SPEAKER_00: Das ist eine ganz normale Chat-Oberfläche.
• 3:14
  SPEAKER_00: Weil ich im Codex-Projekt arbeite, wird auch dieser Thread dort ausgeführt.
• 3:18
  SPEAKER_00: Damit steht ihm der Kontext der Inhalte in diesem Projekt bereits zur Verfügung.
• 3:24
  SPEAKER_00: Und hier sehen wir einige beliebte Einsatzmöglichkeiten von Codex.
• 3:30
  SPEAKER_00: Design.
• 3:31
  SPEAKER_00: Ich habe früher beruflich Software entwickelt und war damals ziemlich schlecht im Design.
• 3:36
  SPEAKER_00: Heute bin ich darin deutlich besser, weil ich die Arbeit nicht selbst mache, sondern an Codex delegiere.
• 3:42
  SPEAKER_00: Man kann gut mit Werkzeugen wie Figma zusammenarbeiten, die Entwürfe des Designteams übernehmen und umsetzen, ohne Selbstexperte zu sein.
• 3:49
  SPEAKER_00: Beim Entwickeln gibt es eine Menge Möglichkeiten.
• 3:52
  SPEAKER_00: Und davon werden wir einiges zeigen.
• 3:54
  SPEAKER_00: Dazu gehört auch das Testen.
• 3:56
  SPEAKER_00: Wenn wir später über den Entwicklungsprozess sprechen, wollen wir unseren Agenten und Werkzeugen immer Rückmeldung geben.
• 4:02
  SPEAKER_00: Tests und Simulationen unserer Anwendungen liefern dem Agenten Hinweise darauf, ob wir das Richtige bauen.
• 4:08
  SPEAKER_00: Sie helfen uns auch zu erkennen, wann er mit seiner Arbeit fertig ist.
• 4:11
  SPEAKER_00: Code-Prüfungen sind ebenfalls sehr wichtig.
• 4:14
  SPEAKER_00: KI-Werkzeuge schreiben inzwischen so viel Code, dass es entsprechend viel zu prüfen gibt.
• 4:19
  SPEAKER_00: Die Prüfung durch Menschen bleibt wichtig, gerade bei der Entwicklung von Unternehmenssoftware.
• 4:24
  SPEAKER_00: Codecs kann sie beschleunigen und in vielen Fällen den Großteil der Arbeit übernehmen.
• 4:31
  SPEAKER_00: Auch hier werden wir sehen, welchen Nutzen es hat.
• 4:35
  SPEAKER_00: Dokumentation.
• 4:36
  SPEAKER_00: Ich schreibe sie nicht gern.
• 4:38
  SPEAKER_00: KI-Werkzeuge sind besonders gut darin, eure Repositories oder Projekte zu durchgehen, zu verstehen, was darin passiert und Dokumente für euch vorzubereiten.
• 4:47
  SPEAKER_00: Auch das schauen wir uns kurz an.
• 4:49
  SPEAKER_00: Bevor ich den Prompt eingebe, möchte ich euch die Anwendung zeigen, mit der wir arbeiten werden.
• 4:54
  SPEAKER_00: Das ist eine Demo-Anwendung.
• 4:56
  SPEAKER_00: Ein Support-Desk mit einem Ticket-Posteingang.
• 4:58
  SPEAKER_00: Auf dem Dashboard sieht man ein paar Kennzahlen zu meinem Support-Team und seiner Leistung in den letzten 30 Tagen.
• 5:04
  SPEAKER_00: Vor allem habe ich hier aber einen Ticket-Posteingang.
• 5:08
  SPEAKER_00: In diesem Beispiel bin ich vielleicht ein Support-Mitarbeiter, bei dem Tickets eingehen.
• 5:12
  SPEAKER_00: Ich bearbeite sie und löse die Probleme.
• 5:16
  SPEAKER_00: Nutzen wir Codecs, um eine neue Funktion zu planen.
• 5:19
  SPEAKER_00: Dazu öffne ich einen neuen Thread in diesem Projekt und wechsle zu Agent Desk Demo.
• 5:24
  SPEAKER_00: Ich möchte vielleicht eine ergänzende iOS-App bauen.
• 5:29
  SPEAKER_00: Wenn ich gerade nicht am Computer bin, möchte ich trotzdem neue Tickets annehmen und beantworten können.
• 5:38
  SPEAKER_00: Ich nutze die Diktierfunktion, weil ich langsam tippe.
• 5:42
  SPEAKER_00: Hey Codex, plane die Arbeit an einer ergänzenden iOS-App mit Swift UI für das Support-Ticket Posteingangsprojekt.
• 5:49
  SPEAKER_00: Ich möchte nur eine einfache Ticket-Oberfläche, über die unsere Mitarbeiter auf Tickets antworten können.
• 5:55
  SPEAKER_00: Hier beende ich das Diktat, damit der Prompt übernommen wird.
• 5:59
  SPEAKER_00: Jetzt erscheint ein kleines Bedienelement, das fragt, ob ich einen Plan erstellen oder in den Planungsmodus wechseln möchte.
• 6:06
  SPEAKER_00: Das passiert, wenn der Planungsmodus nicht aktiv ist und im Prompt das Wort Planen oder etwas ähnliches vorkommt.
• 6:12
  SPEAKER_00: Man kann ihn auf mehrere Arten einschalten.
• 6:15
  SPEAKER_00: Ihr könnt hier auf den Button klicken.
• 6:17
  SPEAKER_00: Über die Plusschaltfläche lässt sich der Planungsmodus ebenfalls aktivieren.
• 6:21
  SPEAKER_00: Das mache ich jetzt.
• 6:22
  SPEAKER_00: Ich glaube, unter Windows und auf dem Mac könnt ihr im Eingabefeld auch die Tastenkombination Umschalt plus Tab verwenden, um ihn ein- oder auszuschalten.
• 6:30
  SPEAKER_00: Ich schicke das jetzt ab.
• 6:32
  SPEAKER_00: Während Codex über die Umsetzung nachdenkt, möchte ich ein paar Dinge erklären, auf die ihr achten könnt.
• 6:38
  SPEAKER_00: Zuerst berücksichtigt Codex den verfügbaren Kontext.
• 6:42
  SPEAKER_00: Hier ist das Dieses Repository.
• 6:46
  SPEAKER_00: Darin gibt es noch keinen iOS-Code.
• 6:48
  SPEAKER_00: Es muss also zunächst planen, wo das neue Projekt angelegt werden soll.
• 6:54
  SPEAKER_00: Gleichzeitig schaut es sich die Anwendung an.
• 6:56
  SPEAKER_00: Wie ist sie aufgebaut?
• 6:58
  SPEAKER_00: Wie sieht das bestehende System aus, wie die API?
• 7:01
  SPEAKER_00: Und mit welchen Daten arbeiten wir?
• 7:05
  SPEAKER_00: In den meisten Planungsrunden kommen wir irgendwann an einen Punkt, an dem Entscheidungen nötig sind.
• 7:12
  SPEAKER_00: Vielleicht müssen wir Annahmen klären oder Gestaltungsentscheidungen treffen.
• 7:17
  SPEAKER_00: Wollen wir hier einen MVP bauen oder eine vollständig produktionsreife Anwendung?
• 7:21
  SPEAKER_00: Codex macht diese Entscheidungspunkte sichtbar und schlägt vor, woran wir seiner Ansicht nach arbeiten sollten.
• 7:31
  SPEAKER_00: Es könnte um den einfachen Standardablauf gehen oder um eine umfassendere Lösung für den gesamten Prozess.
• 7:37
  SPEAKER_00: Vielleicht geht es auch darum, wie wir die Anwendung bereitstellen.
• 7:41
  SPEAKER_00: Sobald Codex diese Optionen präsentieren kann, bekommen wir dazu hilfreiche Rückmeldungen in der Oberfläche.
• 7:47
  SPEAKER_00: Hier müssen wir ein paar Entscheidungen treffen.
• 7:49
  SPEAKER_00: Daran möchte ich den Planungsmodus zeigen.
• 7:51
  SPEAKER_00: Zuerst, was soll die erste iOS-Version enthalten?
• 7:55
  SPEAKER_00: Die Frage ist also, ob wir einen MVP wollen oder eine vollständige Anwendung.
• 8:00
  SPEAKER_00: Codex bietet mehrere Optionen an, meistens drei.
• 8:03
  SPEAKER_00: Wenn ihr mit der Maus über den Infotext geht, bekommt ihr etwas mehr Einzelheiten zu der Frage.
• 8:08
  SPEAKER_00: Und wenn euch keine der Optionen gefällt, könnt ihr jederzeit schreiben, ich habe noch eine vierte Alternative, die du stattdessen umsetzen sollst.
• 8:15
  SPEAKER_00: In diesem Fall nehmen wir die Empfehlungen.
• 8:20
  SPEAKER_00: Dann die Frage nach der Anmeldung.
• 8:22
  SPEAKER_00: Ich sage einfach, keine Authentifizierung, denn das ist eine Demo-App.
• 8:26
  SPEAKER_00: Für diesen Plan nehmen wir das MVP, eine einfache Anwendung.
• 8:37
  SPEAKER_00: Während das weiterläuft, habe ich die angeforderte Rückmeldung gegeben.
• 8:40
  SPEAKER_00: Vielleicht kommen noch weitere Fragen.
• 8:43
  SPEAKER_00: Hier sind Sie.
• 8:44
  SPEAKER_00: Nehmen wir einfach simulierte App-Daten.
• 8:46
  SPEAKER_00: Dann müssen wir uns nicht darum kümmern, dass das Backend läuft.
• 8:53
  SPEAKER_00: Und jetzt haben wir einen fertigen Plan.
• 8:56
  SPEAKER_00: Ich nehme mir dafür etwas Zeit, weil ich das wirklich hilfreich finde.
• 9:00
  SPEAKER_00: Gerade weil wir diese iOS-App von Grund auf neu aufsetzen, hilft es, zunächst einen Plan zu haben.
• 9:08
  SPEAKER_00: Darin stehen wichtige Punkte, die ihr auch in einem üblichen Teamplan finden würdet.
• 9:13
  SPEAKER_00: Eine Zusammenfassung mit dem Ziel, die wesentlichen Änderungen, die Schnittstellen, die wir anlegen wollen und ein Testplan.
• 9:21
  SPEAKER_00: Das ist wichtig.
• 9:23
  SPEAKER_00: Zum einen sind Tests für die Softwareentwicklung entscheidend.
• 9:26
  SPEAKER_00: Zum anderen entsteht dadurch eine Rückkopplung.
• 9:28
  SPEAKER_00: Codex kann die App bauen und ausführen, die Ergebnisse der Unit-Tests auswerten und auf dieser Grundlage weitere Änderungen vornehmen.
• 9:36
  SPEAKER_00: Wenn Tests fehlschlagen, wissen wir, dass etwas korrigiert werden muss.
• 9:40
  SPEAKER_00: Es macht also nicht nur einen Durchlauf, sagt dann, ich glaube, es ist fertig und überlässt euch die Qualitätssicherung.
• 9:46
  SPEAKER_00: Wenn es Annahmen gibt, werden sie hier aufgeführt.
• 9:49
  SPEAKER_00: Ihr könnt den Plan vor dem Abschicken jederzeit bearbeiten.
• 9:52
  SPEAKER_00: Ich denke aber, dass er so passt und starte die Umsetzung.
• 9:57
  SPEAKER_00: Wir sehen gleich, dass sich viele verschiedene Werkzeuge mit Codex verbinden lassen.
• 10:01
  SPEAKER_00: Zuerst die MCP-Server.
• 10:04
  SPEAKER_00: MCP steht für Model Context Protocol.
• 10:07
  SPEAKER_00: Damit kann ein Agent über die Werkzeuge, die ihr ihm bereitstellt, zusätzlichen Kontext beschaffen.
• 10:12
  SPEAKER_00: Wenn er feststellt, ich muss in meinem CI-Werkzeug nachsehen, wie der letzte Build ausgegangen ist, kann er das für euch tun.
• 10:19
  SPEAKER_00: Vielleicht liegt eure Dokumentation in Notion.
• 10:22
  SPEAKER_00: Oder ihr müsst Logs aus Datadoc hinzuziehen, um ein beobachtetes Verhalten einzuordnen und einen Fehler zu beheben.
• 10:28
  SPEAKER_00: Ihr könnt MCP-Server so einrichten, dass Codex bei Bedarf weiteren Kontext abrufen kann.
• 10:33
  SPEAKER_00: Plugins, auf die wir am Ende zurückkommen, bündeln solche MCP-Server mit einer Reihe von Skills.
• 10:39
  SPEAKER_00: Ein Skill ist im Grunde etwas, das ihr dem Agenten beibringt.
• 10:43
  SPEAKER_00: Ein wiederholbarer Arbeitsablauf.
• 10:45
  SPEAKER_00: Er kann bestimmte Aufgaben beschleunigen und ihre Ausführung konsistenter und genauer machen.
• 10:50
  SPEAKER_00: Diese Bestandteile lassen sich als Arbeitspaket zusammenfassen.
• 10:55
  SPEAKER_00: Wir sehen gleich, dass uns die Funktion zum Bauen einer iOS-Anwendung im Wesentlichen die Nutzung von X-Code, bewährte Vorgehensweisen bei der App-Entwicklung und das Starten eines Simulators ermöglicht.
• 11:06
  SPEAKER_00: So können wir die App tatsächlich auf meinem Computer laufen sehen.
• 11:13
  SPEAKER_00: Auf Figma kommen wir gleich zurück.
• 11:15
  SPEAKER_00: Schauen wir uns das an.
• 11:17
  SPEAKER_00: Ich habe den Skill zum Bauen der iOS-App nicht mitgegeben.
• 11:21
  SPEAKER_00: Das ist aber kein Problem.
• 11:22
  SPEAKER_00: Über das Ad-Zeichen kann ich die Plugins aufrufen und diese Ergänzung abschicken.
• 11:27
  SPEAKER_00: Sie lenkt die bereits laufende Aufgabe in die gewünschte Richtung.
• 11:30
  SPEAKER_00: Zwischen den Werkzeugaufrufen wird die Nachricht dem Kontext des Agenten hinzugefügt, wie ihr hier sehen könnt.
• 11:39
  SPEAKER_00: Wenn in eurem letzten Prompt also etwas fehlt, müsst ihr nicht abbrechen und von vorn anfangen.
• 11:44
  SPEAKER_00: Ihr könnt die laufende Arbeit einfach nachsteuern.
• 11:48
  SPEAKER_00: Arbeiten wir jetzt parallel.
• 11:50
  SPEAKER_00: Ich möchte zeigen, wie Codex euch beim Design helfen kann.
• 11:54
  SPEAKER_00: In einem Werkzeug wie Figma liegen vielleicht eure Designvorgaben und die Entwürfe, mit denen euer Team arbeitet.
• 12:02
  SPEAKER_00: Hier habe ich ein paar Datentabellen, deren Gestaltung mir gefällt.
• 12:05
  SPEAKER_00: Ihr könnt Codex bitten, diesen Stil direkt in eure Anwendung zu übernehmen.
• 12:10
  SPEAKER_00: Schauen wir uns den Ticket-Posteingang an.
• 12:12
  SPEAKER_00: Die kleinen Statusmarkierungen sind nicht einheitlich gestaltet.
• 12:17
  SPEAKER_00: Außerdem fehlt die abwechselnde Gestaltung der Tabellenzeilen, die wir erwarten würden.
• 12:21
  SPEAKER_00: Aktualisieren wir die Anwendung mit Codex.
• 12:26
  SPEAKER_00: Zuerst gebe ich das Dollarzeichen ein, um meine Skills aufzurufen und wähle den Skill Figma Implement Design.
• 12:33
  SPEAKER_00: Dann sage ich, unter dem folgenden Link habe ich einen Prototyp.
• 12:37
  SPEAKER_00: Übernimm die Gestaltung der Zeilen und Tabellen in diese App, nicht die Inhalte.
• 12:50
  SPEAKER_00: In unserem Figma-Entwurf ist nämlich irgendeine Finanztabelle zu sehen.
• 12:58
  SPEAKER_00: Wir wollen nicht genau diese Tabelle umsetzen, sondern ihre Gestaltung übernehmen.
• 13:03
  SPEAKER_00: Ich kopiere also den Link aus Figma und füge ihn ein.
• 13:08
  SPEAKER_00: Jetzt arbeiten wir parallel.
• 13:11
  SPEAKER_00: Auf der einen Seite wird die App gebaut.
• 13:13
  SPEAKER_00: Auf der anderen Seite wird der Kontext aus Figma abgerufen und entschieden, wie die Gestaltung in unsere Anwendung übernommen werden soll.
• 13:20
  SPEAKER_00: Lassen wir beides weiterlaufen.
• 13:25
  SPEAKER_00: Denken wir über das Entwickeln und Testen nach.
• 13:27
  SPEAKER_00: Wir schreiben gerade viel Software.
• 13:29
  SPEAKER_00: Tests entstehen dabei bereits mit, denn so arbeitet Codex.
• 13:33
  SPEAKER_00: Es kann aber noch weitergehen.
• 13:41
  SPEAKER_00: Vielleicht fehlen in unserer Anwendung Integrations- oder Unit-Tests.
• 13:45
  SPEAKER_00: Oder wir wollen einen Fehler beheben und zugleich einen Test ergänzen, damit er später nicht wieder auftritt.
• 13:52
  SPEAKER_00: Darin ist Codex besonders gut.
• 13:54
  SPEAKER_00: Ich weiß, dass die Anwendung, die wir hier bauen, einen Fehler hat, weil wir ihn absichtlich eingebaut haben.
• 14:02
  SPEAKER_00: Wenn ich in den Netzwerkbereich der Konsole gehe und die App neu lade, sehe ich, jedes Mal, wenn sie einen Vorgang lädt, schickt sie eine ganze Reihe solcher Anfragen ab.
• 14:14
  SPEAKER_00: Im Wesentlichen ist das ein N plus 1-Fehler, den wir bewusst in das Projekt eingebaut haben.
• 14:19
  SPEAKER_00: Während wir diese andere Aufgabe untersucht haben, hat Codex übrigens die Gestaltung direkt aus Figma übernommen.
• 14:28
  SPEAKER_00: Die Aufgabe ist also vermutlich schon fertig oder läuft noch.
• 14:34
  SPEAKER_00: Ich lege jetzt einen neuen Thread im selben Projekt an und sage, hey Codex, beim Abrufen der Tickets für alle Benutzer in meinem Ticket-Posteingang gibt es ein N plus 1-Abfrageproblem.
• 14:47
  SPEAKER_00: Überarbeite die Abfragelogik und ergänze einen Regressionstest, damit dieses Problem künftig nicht wieder auftritt.
• 14:54
  SPEAKER_00: Ohne Planungsmodus ist Codex darauf ausgerichtet, zu handeln.
• 14:58
  SPEAKER_00: Es setzt die gewünschten Änderungen um und bespricht deutlich weniger mit euch oder sammelt weniger gemeinsam Ideen.
• 15:04
  SPEAKER_00: Im Planungsmodus dagegen verändert es grundsätzlich nichts in eurem Dateisystem.
• 15:09
  SPEAKER_00: Den angezeigten Plan entwickelt ihr gemeinsam weiter, ungefähr wie in einer Planungssitzung oder im Gespräch mit einem Kollegen.
• 15:16
  SPEAKER_00: Das eignet sich besonders für ein neues Projekt, bei dem ihr noch nicht genau wisst, welche Anforderungen es geben soll.
• 15:26
  SPEAKER_00: Im Austausch könnt ihr Annahmen sichtbar machen, Produktentscheidungen treffen und das Wissen aus dem Modelltraining für bewährte Vorgehensweisen bei der Architektur nutzen.
• 15:38
  SPEAKER_00: Das gilt auch, wenn ihr eher aus der Perspektive eines Produktmanagers denkt und euch fragt, ob das Produkt zu seinem Markt passt.
• 15:45
  SPEAKER_00: Welche Vorgehensweisen helfen beim Veröffentlichen eines MVP?
• 15:48
  SPEAKER_00: Wie lässt sich eure App vereinfachen?
• 15:53
  SPEAKER_00: Wir haben eine Reihe von Änderungen am Code vorgenommen, aber noch nichts eingecheckt.
• 15:57
  SPEAKER_00: Das wäre eine gute Gelegenheit für eine Code-Prüfung.
• 16:00
  SPEAKER_00: Hier sind wir in dem Work Tree, in dem wir das N plus 1-Abfrageproblem beheben.
• 16:04
  SPEAKER_00: Es sind nur wenige Änderungen, nichts besonders Großes.
• 16:08
  SPEAKER_00: Eine Möglichkeit, die ich nicht empfehle, wäre, sie einfach ohne Prüfung einzuchecken.
• 16:15
  SPEAKER_00: Hoffentlich laufen bei euch zumindest einige CI-Tests und es findet eine gewisse Prüfung statt.
• 16:20
  SPEAKER_00: Aber ich kann verstehen, dass es manchmal verlockend ist, den Code einfach hochzuschieben und die Sache abzuschließen.
• 16:29
  SPEAKER_00: Dafür gibt es auch den Befehl Schrägstrich-Review.
• 16:32
  SPEAKER_00: Damit könnt ihr entweder euren aktuellen Branch mit einem Basisbranch vergleichen oder, wie in diesem Fall, die noch nicht eingecheckten Änderungen prüfen lassen.
• 16:40
  SPEAKER_00: Ich wähle diese Option und die Prüfung startet.
• 16:44
  SPEAKER_00: Dabei öffnet sich hier im Seitenbereich auch die Ansicht der Änderungen.
• 16:47
  SPEAKER_00: Wenn ich Codex eine Rückmeldung zu seinem Ergebnis geben möchte, etwa weil ich es gerade zum ersten Mal prüfe, kann ich direkt an einer Code-Zeile kommentieren.
• 16:58
  SPEAKER_00: Vielleicht möchte ich Tickets stattdessen in Support-Tickets umbenennen.
• 17:06
  SPEAKER_00: Ich klicke auf Comment.
• 17:07
  SPEAKER_00: Der Kommentar wird dann an meinen Prompt angehängt.
• 17:10
  SPEAKER_00: Außerdem hat die Prüfung ein Problem gefunden und hilft uns dabei, seine Auswirkungen bzw.
• 17:15
  SPEAKER_01: seinen Schweregrad einzuschätzen.
• 17:21
  SPEAKER_00: Hier ist es P2, nicht besonders schwerwiegend, aber etwas, um das wir uns wahrscheinlich kümmern sollten.
• 17:27
  SPEAKER_00: Auch das wird als Befund angezeigt.
• 17:30
  SPEAKER_00: Hier haben wir einen API-Endpunkt, der offenbar mehrere Aufgaben übernimmt.
• 17:34
  SPEAKER_00: Vielleicht sollten wir diese aufteilen.
• 17:36
  SPEAKER_00: Ihr könnt den Befund verwerfen, wenn ihr das Problem schon kennt oder es im Moment nicht für wichtig haltet.
• 17:41
  SPEAKER_00: Natürlich könnt ihr Codex auch bitten, es sofort zu beheben.
• 17:47
  SPEAKER_00: In diesem Fall möchte ich mich aber lieber später darum kümmern.
• 17:51
  SPEAKER_00: Für mich gehört es nicht zur Korrektur der N plus 1-Abfrage.
• 17:55
  SPEAKER_00: Dieser Commit und dieser Merge-Request sollen sich wirklich auf die konkrete Aufgabe beschränken.
• 18:04
  SPEAKER_00: Statt das jetzt zu bearbeiten, verschiebe ich es und trage es in mein Ticketsystem ein.
• 18:09
  SPEAKER_00: Ich nutze linear und habe dort ein Projekt namens RTA.
• 18:13
  SPEAKER_00: Ich bitte Codex einfach, diesen P2-Befund als Ticket in Linear zu speichern.
• 18:27
  SPEAKER_00: Der Linear Skill weiß, wie er ein Ticket erstellen und über die Linear-App übermitteln kann.
• 18:43
  SPEAKER_00: Das hatte ich vergessen anzugeben.
• 18:47
  SPEAKER_00: Jetzt habe ich dieses P2-Problem nach Linear übertragen.
• 18:51
  SPEAKER_00: Wenn ich die Ansicht aktualisiere, sehe ich, dass das Ticket dort verfügbar ist.
• 18:55
  SPEAKER_00: Ich hatte eine solche Integration bereits beim Planungsmodus erwähnt.
• 18:59
  SPEAKER_00: Sie ist hilfreich.
• 19:00
  SPEAKER_00: Was wir aber nicht wollen, dass Codex und andere Agenten unsere Arbeit komplizierter machen, indem sie zu viele Änderungen ohne Bezug zur Aufgabe in einen Branch oder Pull Request packen.
• 19:10
  SPEAKER_00: So könnt ihr eure Systeme für Wissensverwaltung und Aufgabenverfolgung anbinden und trotzdem methodisch arbeiten.
• 19:17
  SPEAKER_00: Mit einem Werkzeug wie Codex schafft ihr dabei einfach mehr und seid schneller.
• 19:23
  SPEAKER_01: Skills hängen eng mit Apps und Plugins zusammen.
• 19:26
  SPEAKER_00: Ein Skill ist aber ausdrücklich ein wiederverwendbarer Arbeitsablauf.
• 19:30
  SPEAKER_00: Nehmen wir an, ihr erledigt bei eurer Arbeit immer wieder dieselben Dinge.
• 19:34
  SPEAKER_00: Das ist auch ein üblicher Ausgangspunkt für Automatisierung.
• 19:40
  SPEAKER_00: Vielleicht müsst ihr einen offenen Pull-Request im Auge behalten.
• 19:43
  SPEAKER_00: Vielleicht wechselt ihr von einem anderen Werkzeug zu Codex.
• 19:48
  SPEAKER_00: Oder ihr pflegt eure Codebasis.
• 19:50
  SPEAKER_00: Sucht nach nicht mehr genutzten Code-Pfaden, nach Möglichkeiten, die Architektur zu verbessern, oder nach Datenbankproblemen.
• 20:01
  SPEAKER_00: Über den Tag gibt es viele solche Aufgaben.
• 20:05
  SPEAKER_00: Das gilt auch außerhalb der Programmierung.
• 20:07
  SPEAKER_00: Vielleicht soll Codex euch helfen, mit den Slack-Nachrichten Schritt zu halten.
• 20:12
  SPEAKER_00: Während dieses Webinars sammeln sich bei mir bestimmt einige davon an.
• 20:16
  SPEAKER_00: Ich könnte Codex bitten, sie zu durchsuchen, zu sortieren und mir nur die wichtigsten Punkte zu zeigen.
• 20:24
  SPEAKER_00: Dafür lassen sich Skills einsetzen.
• 20:28
  SPEAKER_00: Schauen wir uns an, wie das in der Praxis aussieht.
• 20:31
  SPEAKER_00: Ich klicke oben rechts auf die Plugins.
• 20:33
  SPEAKER_00: Dort gibt es einen Reiter für Skills.
• 20:37
  SPEAKER_00: Codex bringt eine Reihe empfohlener und mitgelieferter Skills mit.
• 20:41
  SPEAKER_00: Playwright ist besonders nützlich für die Frontend-Entwicklung.
• 20:44
  SPEAKER_00: Es startet einen Testbrowser und bedient ihn für euch.
• 20:48
  SPEAKER_00: Damit lässt sich der Browser in den Entwicklungsablauf einbeziehen.
• 20:52
  SPEAKER_00: Hier sind auch Skills, die ich selbst erstellt und auf Benutzerebene in Codex eingerichtet habe.
• 21:00
  SPEAKER_00: Schauen wir uns einen davon an.
• 21:03
  SPEAKER_00: Den Skill Figma Implement Design haben wir bereits genutzt.
• 21:06
  SPEAKER_00: Ich öffne ihn als Beispiel.
• 21:08
  SPEAKER_00: Ein Skill ist im Grunde ein Prompt, der da ist unser Simulator.
• 21:14
  SPEAKER_00: Ein Skill ist ein Prompt, der den gewünschten Arbeitsablauf zusammenfasst und beschreibt.
• 21:19
  SPEAKER_00: Wir haben diesen Ablauf vorhin schon verwendet.
• 21:21
  SPEAKER_00: Deshalb könnt ihr euch hoffentlich etwas darunter vorstellen.
• 21:25
  SPEAKER_00: Hier stehen die Voraussetzungen.
• 21:27
  SPEAKER_00: Wir haben einen Figma MCP-Server.
• 21:29
  SPEAKER_00: Wir mussten eine Figma URL für die Designdatei angeben, was wir getan haben.
• 21:34
  SPEAKER_00: Und das Projekt sollte bereits ein Designsystem, eine Komponentenbibliothek oder etwas Vergleichbares besitzen.
• 21:41
  SPEAKER_00: Um die App im Simulator kümmere ich mich gleich.
• 21:43
  SPEAKER_00: Für diesen Figma Skill erfüllen wir zuerst die Voraussetzungen, ermitteln die Node-ID des Projekts, rufen den Designkontext ab, erfassen die Referenzen und so weiter.
• 21:58
  SPEAKER_00: Ich hätte auch einfach den Figma MC Mit Codex verbinden und jeden dieser Schritte einzeln durchgehen können.
• 22:04
  SPEAKER_00: Wahrscheinlich hat derjenige, der diesen Skill erstellt hat, genau diesen Prozess zuvor mehrfach ausgeführt.
• 22:10
  SPEAKER_00: Er wusste dann, was erreicht werden sollte und hat dafür einen Skill geschrieben.
• 22:15
  SPEAKER_00: Skills können auch ausführbare Skripte enthalten.
• 22:19
  SPEAKER_00: Wenn Codex etwas für euch erledigt, ruft es oft nicht nur das Modell auf.
• 22:23
  SPEAKER_00: Es erstellt tatsächlich Software und führt sie aus, um die Aufgabe zu lösen.
• 22:27
  SPEAKER_00: Mit einem Skill könnt ihr das bündeln und anderen Mitgliedern eures Teams oder im gesamten Unternehmen zur Verfügung stellen.
• 22:35
  SPEAKER_00: Ein hilfreicher Bestandteil von Codex ist der Skill Creator.
• 22:39
  SPEAKER_00: Nehmen wir an, wir möchten einen neuen Skill erstellen, der nicht mehr genutzte und unerreichbare Code-Pfade findet, außer dem unübersichtlichen Code, den wir entfernen wollen.
• 22:52
  SPEAKER_00: Ich könnte das jeden Tag selbst anstoßen oder daran denken, es jedes Mal in meinen Prompt aufzunehmen.
• 22:58
  SPEAKER_00: Ich weiß aber, dass ich diese Aufgabe häufig wiederholen möchte.
• 23:02
  SPEAKER_00: Also öffne ich mit dem Dollarzeichen die Skill-Auswahl und suche nach dem Skill-Creator.
• 23:06
  SPEAKER_00: Wie ihr seht, ist das ein Systemskill, der mit Codex ausgeliefert wird.
• 23:13
  SPEAKER_01: Ich diktiere jetzt.
• 23:14
  SPEAKER_00: Ich möchte einen Skill erstellen, der in dieser Codebasis ungenutzten Code und unerreichbare Code-Pfade findet.
• 23:23
  SPEAKER_00: Ich möchte noch einmal zu der iOS-App zurückkehren, die wir erstellt haben.
• 23:27
  SPEAKER_00: Statt mir die neue Anwendung jetzt selbst vollständig anzusehen, sollte ich zunächst eine Code-Prüfung durchführen.
• 23:33
  SPEAKER_00: Ich prüfe dafür einfach die noch nicht eingecheckten Änderungen.
• 23:39
  SPEAKER_00: Wie ihr seht, hat Codex den Xcode BuildMCP-Server verwendet, um die Anwendung im Simulator zu starten.
• 23:46
  SPEAKER_00: Hier habe ich meinen iPhone 17 Pro Simulator.
• 23:49
  SPEAKER_00: Und das ist mein Posteingang für Support-Tickets.
• 23:53
  SPEAKER_00: Das funktioniert noch nicht ganz so, wie ich es erwartet habe.
• 23:56
  SPEAKER_00: Den Posteingang sehe ich.
• 23:58
  SPEAKER_00: Ich hatte aber erwartet, dass ich ein Ticket anklicken und seinen Inhalt sehen kann.
• 24:02
  SPEAKER_00: Deshalb sage ich jetzt, das funktioniert nicht.
• 24:05
  SPEAKER_00: Wenn ich ein Ticket öffne, bleibt die Ansicht leer.
• 24:14
  SPEAKER_00: Das schicken wir ab, sobald die Code-Prüfung fertig ist.
• 24:17
  SPEAKER_00: Weil Codex Zugriff auf den Simulator hat, kann es diese nächste Überarbeitung direkt selbst vornehmen.
• 24:22
  SPEAKER_00: Das finde ich wirklich interessant.
• 24:24
  SPEAKER_00: Ich weiß nicht, wie man iOS-Apps entwickelt.
• 24:27
  SPEAKER_00: Ich habe das vorher eigentlich noch nie gemacht, aber ich muss nicht all diese Einzelheiten kennen, um etwas Funktionsfähiges hinzubekommen, das ich verwenden kann.
• 24:36
  SPEAKER_00: Zum Schluss machen wir noch etwas.
• 24:38
  SPEAKER_00: Ich hatte die Dokumentation von Änderungen erwähnt.
• 24:41
  SPEAKER_00: Neue Tickets und Aufgaben können wir in einem System wie Linear erfassen.
• 24:46
  SPEAKER_00: Nehmen wir aber an, ich möchte erst einmal die Codebasis verstehen.
• 24:49
  SPEAKER_00: Ich wechsle zurück zur lokalen Arbeitsumgebung und frage Codex, erstelle mir ein ERP-Diagramm, das die Beziehungen zwischen den verschiedenen Entitäten in meiner Datenbank erklärt.
• 24:59
  SPEAKER_00: Vielleicht möchte ich einfach sehen, was dieses Projekt macht.
• 25:03
  SPEAKER_00: Das geht auch mit der Architektur.
• 25:05
  SPEAKER_00: Welche Komponenten hat das Projekt?
• 25:07
  SPEAKER_00: Wie wird es bereitgestellt?
• 25:08
  SPEAKER_00: Wie sieht seine Architektur aus?
• 25:12
  SPEAKER_00: Das ist besonders hilfreich, wenn ihr mit älterem Code arbeitet, den ihr noch gar nicht versteht oder der sehr kompliziert ist.
• 25:18
  SPEAKER_00: Lasst das Modell den Code durchsuchen, die Zusammenhänge verstehen, herausarbeiten und für euch dokumentieren.
• 25:24
  SPEAKER_00: Wir sehen, dass es ein ERD-Diagramm für mich erstellt hat.
• 25:28
  SPEAKER_00: Das kann ich hier im Seitenbereich öffnen.
• 25:30
  SPEAKER_00: Dort werden auch Vorschauen von Coded-Dateien angezeigt.
• 25:33
  SPEAKER_00: Ich kann mich umsehen.
• 25:34
  SPEAKER_00: Hier gibt es einen Benutzer, eine Sitzung und Konten.
• 25:37
  SPEAKER_00: Die Benutzer sind mit Tickets verknüpft.
• 25:39
  SPEAKER_00: Die Tickets haben Anhänge, Ereignisse und so weiter.
• 25:43
  SPEAKER_00: So lassen sich diese Zusammenhänge sehr gut darstellen.
• 25:46
  SPEAKER_00: Und ich musste dafür überhaupt nicht in den Code gehen, um einen klaren Überblick über die Codebasis zu bekommen.
• 25:53
  SPEAKER_00: Die ganze Zeit haben wir Prompts an Codex geschickt.
• 25:56
  SPEAKER_00: Und es arbeitet dabei in einer Schleife.
• 25:58
  SPEAKER_00: Das Modell verarbeitet die Prompts und liefert Informationen zurück.
• 26:02
  SPEAKER_00: Es prüft aber auch, muss ich zusätzlichen Kontext holen?
• 26:06
  SPEAKER_00: Muss ich über einen Werkzeugaufruf etwas ausführen?
• 26:09
  SPEAKER_00: Die Ausführungsumgebung von Codex ermöglicht diese Schleife.
• 26:12
  SPEAKER_00: Wenn ihr im Prompt klar beschreibt, wann die Aufgabe als erledigt gilt und gute Rückmeldungen ermöglicht, etwa durch Tests, kann Codex sehr lange in diesem Ablauf arbeiten.
• 26:22
  SPEAKER_00: Wenn es feststellt, dass es fertig ist oder eure Rückmeldung braucht, verlässt es die Schleife und antwortet euch.
• 26:28
  SPEAKER_00: Das bedeutet, im Hintergrund erledigt Codex viel Arbeit für euch.
• 26:33
  SPEAKER_00: Eure Aufgabe als diejenigen, die das Ganze steuern, ist es, guten Kontext bereitzustellen.
• 26:39
  SPEAKER_00: Gebt passende Anweisungen mit.
• 26:41
  SPEAKER_00: Beschreibt, wann die Aufgabe erledigt ist und was Codex nicht tun soll.
• 26:45
  SPEAKER_00: Hilft ihm, die Annahmen zu verstehen und sagt ihm, wo es zusätzlichen Kontext findet, etwa in einem Ordner mit Dokumentation oder über ein Werkzeug, das ihr bevorzugt.
• 26:55
  SPEAKER_00: Wenn ihr dann feststellt, dass ihr dieselbe Aufgabe immer wieder erledigt, ist es Zeit, einen Skill zu erstellen oder den Projektkontext in eurer agents.md-Datei zu ergänzen.
• 27:05
  SPEAKER_00: Ich möchte außerdem darauf hinweisen, dass Codex in einer Sandbox auf Betriebssysteme läuft.
• 27:11
  SPEAKER_00: Es gibt also Berechtigungen, mit denen sich der Dateizugriff auf freigegebene Speicherorte begrenzen lässt.
• 27:17
  SPEAKER_00: Auch der Netzwerkzugriff lässt sich steuern.
• 27:19
  SPEAKER_00: Wenn ihr Regeln festgelegt habt und Codex etwas außerhalb dieser Regeln tun möchte, bittet es euch um Freigabe.
• 27:29
  SPEAKER_00: Ich arbeite schon lange genug mit Codex, dass ich meine Einstellungen für diese Demos passend vorkonfiguriert habe.
• 27:35
  SPEAKER_00: Hätten wir aber etwas verlangt, das nicht erlaubt ist, hätte ich die Aktion manuell bestätigen müssen.
• 27:40
  SPEAKER_00: Gerade neuen Nutzern empfehle ich, zunächst in diesem Modus zu arbeiten.
• 27:44
  SPEAKER_00: So vermeidet ihr unerwartete, gefährliche Änderungen an eurem Dateisystem.
• 27:49
  SPEAKER_00: Mit der Zeit könnt ihr die Berechtigungen genauer einstellen oder lernt besser einzuschätzen, wie Codex auf bestimmte Prompts reagiert.