Ultimatives Agent-Design zur Aktivierung von Claude × Codex [Neueste Version]

Selbst wenn dir gesagt wird „gib genauere Anweisungen", möchte ich Hilfe schon bei genau diesem „genauen Teil" bekommen.

Du hast etwas, das du bauen möchtest, aber deine Hände stocken bereits bei der Vorrecherche, die nötig ist, um die KI zu fragen. Das fühlt sich nach einem schlechten Deal an.

Angenommen, du möchtest eine App, in der du Fälle registrieren und nach nahenden Fristen sortieren kannst. So viel kannst du sagen. Aber wenn du nach Methoden zur Datenspeicherung oder danach gefragt wirst, wie man nach Bugs sucht, explodiert der Rechercheaufwand plötzlich.

Während der Recherche streichst du Funktionen, die du eigentlich einbauen wolltest, und denkst dir: „Vielleicht geht es diesmal auch ohne." Nicht weil der Bau schwierig erscheint, sondern weil du alles in einem Rahmen halten willst, den du selbst überblicken kannst, falls etwas schiefgeht.

Ich möchte gar nicht jede winzige Anweisung vorbereiten, bevor ich frage. Ich möchte, dass du Dinge aufgreifst, die ich vielleicht übersehen habe. Es wäre hilfreich, wenn du mich klar zwischen zwei Optionen entscheiden lässt und dann basierend auf diesen Entscheidungen mit der Arbeit weitermachst.

Das Entwicklungsteam, das wir in diesem Artikel zusammenstellen, soll genau dieser Art von Anforderung näherkommen – mit Claude Code und Codex.

• Claude Code: Die Anlaufstelle für Anfragen. Organisiert notwendige Rückfragen und die Arbeitsteilung.
• Codex: Übernimmt Implementierung und Prüfung.

Für eine Fallmanagement-App bereitest du neben dem Erstellen des Bildschirms auch Prüfaufgaben vor. Was passiert, wenn du leere Felder speicherst? Bleiben die Einträge nach dem Neuladen erhalten? Wenn ein Bug nicht behoben wird, fasse die versuchten Fixes und die verbleibenden Symptome zusammen, um sie an einen anderen Agenten zu übergeben.

Was Menschen tun, ist, unterwegs nötige Entscheidungen zu treffen und am Ende die tatsächliche Funktion zu prüfen. Um das zu erleichtern, schaffst du eine Struktur, in der Spezifikationen, Änderungen und Prüfergebnisse zuverlässig wieder bei dir landen. Lass uns das Schritt für Schritt aufbauen – von den Verbindungsmethoden über die Aufgabenübergabe bis hin zu Abbruchbedingungen.

Arbeit an Codex übergeben, während Claude geöffnet bleibt

Es gibt eine Möglichkeit, Anfragen von Claude Code an Codex weiterzugeben, ohne vorherige Antworten in eine andere KI einzufügen: das von OpenAI veröffentlichte „Codex-Plugin für Claude Code".

Laut offizieller Dokumentation unterstützt es Anwendungsfälle wie:

• Reviews, die aktuelle Änderungen prüfen

• Delegation von Untersuchungen oder Fehlerbehebungen

• Übergabe von Konversationen

Dieser Artikel beschreibt die Vorgehensweise, um es aus einer lokalen Claude-Code-Umgebung heraus zu nutzen, basierend auf offiziellen Dokumenten, geprüft am 16. Oktober 2026.

Voraussetzungen

• Eine Umgebung, in der Claude Code verfügbar ist

• Git

• Node.js (offizielle Anforderung: 18.18 oder neuer)

• Ein ChatGPT-Konto, das mit Codex authentifiziert ist, oder ein OpenAI-API-Schlüssel

Das Plugin ruft dein lokales Codex auf. Die Verbindung bedeutet nicht, dass Codex über Claudes Nutzungskontingent läuft; die Codex-Nutzung verbraucht das eigene Kontingent von Codex.

Außerdem: Auch wenn dieses Setup lokale Dateien verarbeitet, findet die KI-Inferenz nicht zwingend vollständig auf deinem PC statt. Beginne mit einem Übungsordner, der keine vertraulichen Informationen enthält.

Das Plugin installieren

Führe im Eingabefeld von Claude Code die folgenden Befehle nacheinander von oben nach unten aus. Das sind Operationen, um Plugins innerhalb von Claude Code hinzuzufügen – keine Befehle für ein normales Terminal.

1/plugin marketplace add openai/codex-plugin-cc
2/plugin install codex@openai-codex
3/reload-plugins
4/codex:setup

Mit dem letzten Befehl /codex:setup kannst du den Installations- und Authentifizierungsstatus von Codex prüfen. Wenn Codex nicht gefunden wird, npm aber verfügbar ist, erscheint eine Installationsanleitung; lies sie dir durch und gehe entsprechend vor.

Wenn du nicht authentifiziert bist, führe codex login im Terminal aus und folge den Anweisungen.

Stelle unter Windows sicher, dass die Umgebung, in der Claude läuft, und die Umgebung, in der Codex installiert wurde, nicht getrennt sind. Installiere nicht immer wieder neu, nur weil „nicht gefunden" angezeigt wird.

Zuerst ein Review ausprobieren

Starte mit einem Review, das keinen Code umschreibt. Bereite eine kleine Änderung in einem Git-verwalteten Übungsprojekt vor und führe aus:

1/codex:review --background

• Fortschritt prüfen: /codex:status

• Abgeschlossene Ergebnisse prüfen: /codex:result

Wenn mehrere Anfragen aktiv sind, gib die angezeigte Job-ID an, um Ergebnisse nicht zu verwechseln.

Öffentliche Samples von Amazon helfen bei der Aufgabenteilung

Als Referenz für die Rollenverteilung lohnt sich ein Blick auf die Entwicklungsbeispiele, die AWS, die Cloud-Sparte von Amazon, veröffentlicht hat. Auf GitHub unter aws-samples gibt es zwei relevante Repositories:

• sample-codex-agent-team (für Codex)

• sample-claude-code-agent-team (für Claude Code)

Die Codex-Version kennt sechs Rollen:

Zu entscheiden, wie man einen Registrierungsbildschirm baut, ist etwas anderes, als Skalierbarkeit oder Wartungskosten abzuwägen. Wenn du Feature-Implementierung von Betriebsberatung trennst, werden Fragen an bestimmte Agenten konkreter.

Ein leichtgewichtiges Review dient nicht dazu, riskante Änderungen mal eben schnell abzufertigen. Es ist eine Methode zur Aufteilung, um risikoarme Aufgaben wie Dokumentänderungen oder mechanische Ersetzungen nicht jedes Mal schweren Prüfungen zu unterziehen.

Die Methoden zur Aufgabenübergabe unterscheiden sich in den beiden Beispielen:

• Claude-Code-Version: Agenten holen sich Aufgaben aus einer gemeinsamen Aufgabenliste (nutzt experimentelle Agent-Teams, erfordert zusätzliche Konfiguration)

• Codex-Version: Arbeitet nach einem Arbeitsplan mit getrennten Verantwortlichkeitsdateien

Das sind separate Beispiele. Sie verschmelzen nicht automatisch zu einem Team, nur weil beide installiert sind.

Außerdem enthält die Codex-Version Modellspezifikationen, die unveröffentlichte Verbindungseinstellungen voraussetzen. Das Beispiel selbst weist darauf hin, dass dies nicht direkt in jedem Konto funktioniert. Statt alles blind in kritische Firmenprojekte zu kopieren, übernimm nur die Logik der Rollenverteilung und passe sie an deine nutzbare Umgebung an.

Dieser Artikel startet mit einer kleinen Struktur, in der Claude Code als Schnittstelle fungiert und begrenzte Implementierungs- und Prüfaufgaben an Codex weitergibt.

Hinweis: Dies ist ein eigenständiges Praxisbeispiel, das sich auf öffentliche Samples bezieht. Es ist weder ein Produkt, das eine AWS-Integration von Claude und Codex garantiert, noch ein Bericht über gemessenes Verhalten.

Vor dem Bauen klären, was „speicherbar" bedeutet

Wenn du nicht im Detail beschreiben kannst, was du bauen willst, starte nicht sofort mit der Implementierung. Lass zuerst Claude die Punkte sammeln, die geklärt werden müssen. Du musst nicht alle Fachbegriffe kennen; wandle sie einfach in Fragen um, die du beantworten kannst.

Ich möchte eine persönliche Fallmanagement-App bauen. Bitte strukturiere zuerst die notwendigen Spezifikationen und stelle mir nacheinander jeweils eine Frage zu den nötigen Entscheidungen. Erkläre bei technischen Entscheidungen kurz die Auswirkungen auf Nutzer und die Gründe für deine Empfehlung. Beginne nicht mit der Implementierung, bevor ich zustimme.

Zum Beispiel beim Speichern: Reicht es, wenn die Einträge im selben Browser bestehen bleiben, oder möchtest du sie zwischen Smartphone und PC teilen? Dafür braucht man völlig unterschiedliche Mechanismen. Wenn stillschweigend eine Variante gewählt wird, führt das später zu Mehrarbeit.

Für diese Übung grenzen wir den Umfang ein:

• Im Scope: Nutzung auf demselben PC/Browser, Einträge bleiben nach dem Neuladen erhalten

• Out of Scope: Geräteübergreifende Synchronisation, Login, externe Veröffentlichung, echte Kundendaten

Definiere Abschlusskriterien über das Ergebnis der Bedienung, nicht über „einfach zu benutzen":

• Fälle können registriert werden

• Sortierung nach Frist

• Status kann geändert werden

• Bei leerer Eingabe wird der Grund angezeigt

• Inhalte bleiben nach dem Neuladen erhalten

Spezifikationen und Aufgabenanfragen in Dateien speichern

Speichere die entschiedenen Inhalte in docs/spec.md als Spezifikation, auf die sich alle beziehen. Die Dateinamen hier sind Beispiele; sie werden nicht automatisch an alle KIs verteilt, also gib bei jeder Anfrage an: „Lies das".

Speichere die festgelegten Spezifikationen, Abschlusskriterien und Out-of-Scope-Features in docs/spec.md. Schreibe unentschiedene Punkte nicht als bestätigt hinein. Trenne Elemente, die einen Implementierungsstopp erfordern, von solchen, die mit temporären Einstellungen fortgesetzt werden.

Fasse als Nächstes die Aufgabenanfragen für die Umsetzer in docs/tasks.md zusammen. Nur die Aufgabe zu benennen reicht nicht. Gib Lesematerialien, bearbeitbare Dateien, nicht bearbeitbare Teile, Prüfmethode und erwartete Ausgaben an.

Teile die Spezifikationen in implementierbare Einheiten auf. Schreibe zugewiesene Dateien, Voraussetzungen und Prüfmethode in docs/tasks.md. Lege gemeinsame Elemente zwischen UI- und Speicherlogik vorab fest. Plane nicht, dass zwei Agenten gleichzeitig dieselbe Datei bearbeiten.

Beiden KIs dieselbe Spezifikation zeigen

Fortlaufende Anweisungen kannst du für Claude in CLAUDE.md und für Codex in AGENTS.md schreiben. Das sind dokumentierte Mechanismen. Geh aber nicht davon aus, dass eine Datei für die andere identisch funktioniert. Verweise von beiden auf dieselbe Spezifikationsdatei.

Halte die Anweisungen kurz:

• Speicherort der Spezifikationsdatei

• Keine Änderungen außerhalb der Anfragen vornehmen

Wenn du Spezifikationen duplizierst, besteht die Gefahr, dass eine Seite veraltet. So vermeidest du das.

Workspaces vor parallelen Aufgaben trennen

Mehrere KIs wirken schneller, aber dieselbe Datei mit unterschiedlichen Vorgaben umzuschreiben, erzeugt nur Aufräumarbeit für Menschen.

Kopple für die erste parallele Arbeit den „UI-Builder" mit dem „Test-Planer". UI und Speicher getrennt zu implementieren, bevor das Format steht, erhöht die Zahl der Abstimmungsprobleme.

Git Worktree nutzen, um Ordner zu trennen

Hier ist Git Worktree nützlich. Es ist eine offizielle Git-Funktion, die separate Arbeitsordner für dasselbe Projekt mit unterschiedlichen Änderungen erlaubt.

Stelle vor dem Erstellen sicher, dass Spezifikationen und Basis in Git committet sind. Nicht committete Entwurfsdateien werden an neue Orte möglicherweise nicht übernommen. Prüfe, ob Branchnamen und Zielordner noch frei sind.

1git worktree add -b feature/ui ../case-app-ui
2git worktree add -b feature/storage ../case-app-storage
3git worktree list

Drei Hinweise:

1. Ordner zu erstellen ändert nicht den KI-Workspace. Öffne in jedem Verzeichnis separate Sessions und prüfe Ort und Branch vor dem Start.

1. Plugins nutzen die Umgebung des Aufrufers. Die Verbindung von Claude/Codex isoliert nicht automatisch. Halte dich anfangs an „ein Editor pro Ort".

1. Worktrees isolieren hauptsächlich Dateien. Gemeinsame Datenbanken oder Ports führen zu Konflikten. Trenne Test-Speicher/Ports oder starte sie nacheinander.

Gleichzeitige Aufgaben in Codex begrenzen

Um mehr Sub-Agenten in Codex zu nutzen, begrenze die gleichzeitigen Threads. Sub-Agenten erhalten begrenzte Aufgaben von der übergeordneten KI. Aktuelle Konfiguration in .codex/config.toml:

1[agents]
2enabled = true
3max_concurrent_threads_per_session = 2

• Dupliziere keine Einträge

• Nutze dies nur in vertrauenswürdigen Projekten (Projekteinstellungen laden nur in vertrauenswürdigen Kontexten)

• Das Limit gilt für „gleichzeitige Threads ohne den Hauptagenten in dieser Session", nicht gesamt über Claude/Sessions hinweg.

Die 14 Threads im AWS-Beispiel sind nur deren Wahl. Kein Zwang. Deren max_threads ist ein Legacy-Alias; nutze die aktuellen Namen.

Implementierer nicht jedes Mal von Grund auf erklären

Definiere in Codex eigene Agenten über TOML-Dateien in .codex/agents. Erstelle task-builder.toml mit den nötigen Bedingungen:

1name = "task-builder"
2description = "Nur den zugewiesenen Bereich aus bestätigten Spezifikationen implementieren"
3developer_instructions = """
4Lies zuerst docs/spec.md und docs/tasks.md.
5Implementiere nur den zugewiesenen Bereich; stoppe und melde dich, falls Spezifikationsänderungen nötig sind.
6Mache Änderungen anderer Agenten nicht rückgängig, lies keine Secrets und veröffentliche nichts extern.
7Gib geänderte Dateien, ausgeführte Tests, Ergebnisse und unbestätigte Punkte zurück.
8"""

Vermeide es, hier Modellnamen festzulegen. Standardmäßig werden die Einstellungen des Elternprozesses geerbt. Modelle aus öffentlichen Beispielen sind in deinem Vertrag vielleicht nicht verfügbar; hartcodierte, nicht verfügbare Namen stoppen den Start schon vor der Rollenbeschreibung.

Prüfe nach dem Ablegen der Datei in einer neuen Codex-Session, ob sie erkannt wird, und delegiere eine kleine Aufgabe. Wenn du von Claude aus anfragst, gib an, dass task-builder in Codex genutzt werden soll.

Weise Codex an, nur die Speicherlogik aus docs/tasks.md an task-builder zu delegieren. Prüfe vor dem Start, ob der Agent erkannt wird und welcher Ordner tatsächlich genutzt wird. Falls nicht verfügbar, melde es, statt stillschweigend die Methode zu wechseln.

Hinweis: „Nicht ändern" zu schreiben ist etwas anderes, als Schreibrechte zu entziehen. Laut offizieller Dokumentation erben Codex-Kindagenten die Rechte des Elternprozesses (Sandbox-Einstellungen). Der Rollenname „Reviewer" schafft keine sichere Read-only-Umgebung.

Agenten wechseln, wenn sich Fixes wiederholen

Wenn die KI sagt „Ursache gefunden", aber derselbe Vorgang erneut fehlschlägt, halte fest, was sich geändert hat oder nicht, statt zum nächsten Fix zu hetzen. Das macht die Übergabe einfacher.

Das offizielle Plugin hat einen rescue-Eintrag, um Untersuchungen/Fixes an Codex zu delegieren. Trotz des Namens ist er für eingegrenzte Aufgaben gedacht, nicht nur für Bugs.

Untersuchung explizit als Read-only kennzeichnen

Wenn es nur um Ursachenanalyse geht, stelle klar, dass nichts geschrieben wird. Interne Verfahren machen Rescue standardmäßig schreibbar, sofern nicht anders angegeben. Halte Untersuchung und Fix strikt getrennt.

1/codex:rescue --fresh Untersuche read-only, warum Registrierungen beim Neuladen verschwinden. Vergleiche docs/spec.md und den Code. Gib Reproduktionsschritte, belegte Ursachen und nötige Prüfungen zurück. Ändere keine Dateien.

--fresh startet eine neue Anfrage; --resume setzt die vorherige fort (fragt nach, wenn weggelassen). Gib Berechtigungen beim Fortsetzen an. Wenn du zum Fix wechselst, definiere den Scope.

1/codex:rescue --resume Behebe basierend auf der bestätigten Ursache nur die Speicherlogik mit minimalen Änderungen. Ändere weder UI noch Spezifikationen. Zeige den vorher fehlschlagenden Test und das Ergebnis danach.

Gesamte Konversation mit Transfer übergeben

• Nur Aufgabe übergeben → rescue

• Konversation an Codex übergeben → transfer

1/codex:transfer

Offizielle Doku: Erstellt einen Codex-Thread, der die aktuelle Claude-Code-Konversation fortsetzt, und zeigt den Befehl zum Wiederaufnehmen. Aktualisiere Codex, falls nicht unterstützt.

Konversation übergeben ≠ PC-Zustand übergeben. Ungespeicherte Änderungen, Authentifizierungen und laufende Apps wandern nicht mit. Prüfe Dateien und Status am Zielort.

Nach dem „Fertig" mit einer anderen KI prüfen

Tests durch den Implementierer sind hilfreich, aber wenn er die Spezifikationen falsch verstanden hat, passen bestandene Tests nicht zum gewünschten Verhalten.

Gib Prüfern von Menschen bestätigte Spezifikationen und die tatsächlichen Änderungen, nicht die Erklärungen des Implementierers. Teile keine Bewertungen wie „perfekt behoben"; lass sie die Einhaltung unabhängig prüfen.

Vergleiche docs/spec.md und die tatsächlichen Änderungen unabhängig voneinander. Identifiziere unerfüllte Abschlusskriterien mit Belegen. Verlasse dich nicht auf die Selbsteinschätzung des Implementierers. Trenne reproduzierbare Probleme, potenzielle Bedenken und ungeprüfte Punkte. Behebe jetzt nichts.

Kopple Gegensätze:

• Claude hat implementiert → Füge ein normales Codex-Review als separate Prüfung hinzu

• Codex hat implementiert → Bitte Claude um Prüfung, optional ergänzt durch ein neues Codex-Review

Normales vs. adversariales Review

Rufe ein normales Review mit /codex:review auf. Vergleiche den Branch mit main:

1/codex:review --base main

Nutze den tatsächlichen Basis-Branch, falls es kein main gibt. Ändere während des Reviews nichts.

Hinweis: Normale Reviews akzeptieren keine Freitext-Fokusanweisungen wie „prüfe nur den Speicher". Die offizielle Spezifikation verbietet Prioritätsvorgaben. Um Designannahmen oder spezifische Risiken zu hinterfragen, nutze adversarial-review.

1/codex:adversarial-review --background Prüfe, ob fehlgeschlagene Speicherungen als Erfolg angezeigt werden, ob beim Bearbeiten aus zwei Tabs Einträge verloren gehen, und überprüfe die aktuellen Designannahmen.

Das ist kein rauer Ton; es hinterfragt gewählte Ansätze und Annahmen. Beide Reviews identifizieren Probleme, beheben aber keinen Code. Bestätige die Ergebnisse und delegiere Fixes danach separat.

Strukturiere die Erkenntnisse nach anwendbaren Abschlusskriterien, Nutzerauswirkungen und Prüfmethode. Behebe Probleme, die Spezifikationsänderungen erfordern, nicht automatisch; präsentiere dem Menschen Optionen und Unterschiede.

Review-Gate anfangs überspringen

Automatisierungsoption: Das „Review Gate" fügt ein Codex-Review ein, sobald Claude eine Antwort beendet. Aktiviere es mit /codex:setup --enable-review-gate.

Warnung: Die offizielle Dokumentation weist auf das Risiko langer Fix-Schleifen hin, die zwischen Claude und Codex schnell Kontingente verbrauchen.

Beginne mit manuellen Reviews, um die Erkenntnisse zu verstehen. Deaktiviere es, wenn du weggehst. Stoppe es mit /codex:setup --disable-review-gate und prüfe offene Anfragen.

Erfolgreiche Anfragen für nächste Aufgaben aufbewahren

Statt lange Anweisungen immer wieder einzufügen, speichere erfolgreiche Workflows. Mit Skills kannst du Aufgabenabläufe in Dateien zur Wiederverwendung ablegen.

Anthropic-Doku: Lege Abläufe in .claude/skills ab. Erstelle einen Ordner team-brief mit einer SKILL.md, die Prüfungen vor der Übergabe enthält.

1---
2name: team-brief
3description: Scope und Prüfung anhand der Spezifikationen strukturieren
4disable-model-invocation: true
5---
6Lies docs/spec.md und docs/tasks.md und fokussiere dich nur auf die aktuellen Änderungen.
7Strukturiere Scope, verbotene Änderungen, Voraussetzungen, Abschlusskriterien und Prüfung.
8Erstelle Anfragetexte für Agenten und lasse unentschiedene Punkte zur menschlichen Bestätigung offen.
9Ändere in diesem Ablauf keinen Code, veröffentliche nichts extern und starte kein Codex.

In Claude Code aufrufen:

1/team-brief Möchte Sortierung nach Frist hinzufügen

Das ist ein eigener Befehl, kein Standard. disable-model-invocation: true stellt sicher, dass ein Mensch den Zeitpunkt auslöst. Claude startet nicht automatisch. Abläufe erzwingen keine KI-Starts oder Prüfungen; probiere zuerst „nur Vorbereitung wiederverwenden".

Dynamische Workflows für große Aufgaben

Für größere Scopes bietet Claude Code Dynamic Workflows (angekündigt im Mai 2026), mit denen sich mehrere Agenten skripten lassen. Verfügbar in kostenpflichtigen Plänen/API.

• Normaler Chat: Claude wählt jedes Mal die nächste Aufgabe

• Dynamic Workflows: Verzweigungen und Ergebnissammlung skripten, wiederholbar

Beispiel: Untersuche Speicherfehler, Eingabeprüfungen und Layoutbrüche über mehrere Bildschirme getrennt und gleiche die Erkenntnisse ab. Starte keine riesigen Agenten aus einer kleinen App heraus; erwäge das, wenn du dieselben Prüfungen breit anwenden willst.

Erstelle einen Dynamic Workflow, der geteilte Bildschirme untersucht und Erkenntnisse mit separaten Agenten prüft. Präsentiere zuerst Ziele, Agentenzahl und Abbruchbedingungen. Keine Codeänderungen; führe nach Freigabe einen kleinen Scope aus.

Tipps:

• Im Pro-Plan über /config aktivieren

• Fortschritt und Nutzung mit /workflows überwachen, jederzeit stoppen

• Wähle die Größe (small etc.) in /config; die offizielle Doku nennt diese Werte Schätzungen, keine harten Limits. Gehe nicht von garantierten Agentenzahlen aus.

Das lässt Agenten auf Claudes Seite laufen. Codex steigt nicht automatisch ein. Nutze es zuerst für Claudes interne Untersuchung/Prüfung; betrachte die Codex-Delegation als separate Phase.

Fallmanagement-App End-to-End ausführen

Verbinde die Komponenten zu einem App-Build. Unten folgt ein erklärendes Entwicklungsbeispiel, kein abgeschlossener Erfahrungsbericht; prüfe es in deiner Umgebung.

Build-Ziel

• Felder: Fallname, Frist, Status, Notizen

• Status: Nicht begonnen / In Bearbeitung / Abgeschlossen

• Suche nach Fallname

• Unvollständige Fälle nach Frist sortiert anzeigen

Erste Anfrage

An Claude übergeben. Ziele auf einen neuen Übungsordner, nicht auf bestehende kritische Projekte.

Baue eine persönliche Fallmanagement-App im Übungsordner. Bestätige zuerst Umgebung und Spezifikationen. Umfasse Registrierung/Bearbeitung/Suche/Sortierung/Persistenz für Name, Frist, Status, Notizen. Schließe Login, Sync und externe Veröffentlichung aus.

Speicherkandidat: localStorage. Keine geräteübergreifende Synchronisation oder Backups; wer die Browserdaten löscht, verliert die Einträge. Speichere dort keine wertvollen Produktionsdaten.

Basis bauen, gemeinsame Teile definieren

Ein einzelner Agent baut die Basis. Prüfe, ob die App startet und der leere Bildschirm angezeigt wird. Committe Spezifikationen und Basis in Git, bevor du Workspaces trennst, falls nötig.

• Dem UI-Agenten geben: Anzeigefelder, Aktionszuordnungen

• Dem Storage-Agenten geben: Datensatzformat, Lese-/Hinzufüge-/Aktualisierungsmethoden, Fehlerbehandlung

Lass keinen der beiden Feldnamen erfinden. Wenn das Statusfeld status heißt, nutzen es beide. Ändere es nicht auf einer Seite zu state, weil es leichter ist; leite gemeinsame Änderungen zurück an Claude zur Anpassung.

Implementierungsanfrage an Codex

Gib sowohl beschreibbare Orte ALS AUCH geforderte Nachweise an.

1/codex:rescue --fresh Lies docs/spec.md und docs/tasks.md. Implementiere nur die zugewiesene Speicherlogik und Tests. Gib geänderte Dateien, Befehle, Testergebnisse und unbestätigte Punkte zurück. Stoppe und melde dich, falls Spezifikationsänderungen oder Bearbeitungen durch andere Agenten nötig sind.

Währenddessen verändert Claude dieselben Dateien nicht seitwärts. Konzentriere dich auf Abschlussprüfungen und Testdatenvorbereitung; entscheide über nächste Schritte, nachdem die Ergebnisse zurück sind.

Prüfdaten vorbereiten

• Frist gestern, „Nicht begonnen"

• Frist heute, „In Bearbeitung"

• Frist nächste Woche, „Abgeschlossen"

• Mehrere Fälle mit gleicher Frist

• Lange Fallnamen

Ermöglicht konkrete Sortier- und Anzeigeprüfungen.

Dokumentiere detaillierte Regeln in den Spezifikationen:

• Sortierung: Reihenfolge der Registrierung bei gleichen Fristen

• Leere Felder: Name/Frist erforderlich; Notizen optional. Fehlende Felder anzeigen.

• Daten: Definiere die Annahme für den Tageswechsel. Zeitzonen- oder Zeitbehandlung, die Tage verschiebt, macht die App trotz sauberer Optik unbrauchbar.

Vorab definierte Regeln verhindern inkonsistente Prüfungen nach der Implementierung.

Integrieren und testen

Sobald die Implementierungen stehen, lass Claude Änderungslisten und Testergebnisse lesen und die Integration bestätigen. Wenn du Worktrees nutzt, sammle die Änderungen in einem einzigen Prüfbranch. Führe einzeln bestandene Tests nach der Integration erneut aus.

Nutze Playwright für UI-Automatisierung. Aktuelle Guides bieten CLI/Skills für KI-Agenten; MCP ist nicht die einzige Methode.

Trenne den „Mechanismus zur KI-Browsersteuerung" von „wiederholbaren Tests". Nutze Playwright Test für erneut ausführbare Abläufe von der Registrierung bis zum Neuladen.

Erstelle Playwright Tests, die Registrierung, Ablehnung bei leeren Feldern, Suche, Statusänderung, Fristsortierung und Persistenz prüfen. Trenne Startkonfiguration und Testdaten. Ändere weder App-Verhalten noch Abschlusskriterien, damit Tests bestehen.

Setup für ein neues Übungsprojekt:

1npm init playwright@latest

Wenn es bereits installiert ist, prüfe bestehende Start- und Testkonfigurationen, bevor du etwas hinzufügst.

Stelle sicher, dass Browser installiert sind, konfiguriere den App-Start und führe dann aus:

1npx playwright test
2npx playwright show-report

Entscheidend: Behandle null gefundene oder komplett übersprungene Tests nicht als „bestanden".

Bei Fehlern isoliere die Ursache: Ist es ein Speicherbug oder sucht der Test nach einem nicht existierenden Button? Lösche keine Tests, um Grün zu sehen; entscheide anhand der ursprünglichen Spezifikationen, was repariert wird.

Abschließende menschliche Prüfung

Prüfe die Optik manuell. Versteckter Text? Sind Fälle mit nahender Frist leicht zu finden? Bestandene Testberichte garantieren keine gute UX.

Lass dir von Claude vier Punkte geben, keine langen Logs:

• Startmethode

• Geprüfte Verhaltensweisen

• Verbleibende Einschränkungen

• Kandidaten für nächste Fixes

Registriere selbst einen Eintrag, lade neu und prüfe, ob er bleibt. Dann markiere es als abgeschlossen.

Wo man mit dem ständigen Reparieren aufhört

Wenn der Team-Scope wächst, definiere Endpunkte. Drehen wir uns um denselben Bug oder lösen wir aufeinanderfolgende Probleme? Ein unklarer Zustand erschwert weitere Anweisungen.

Abbruchkriterien setzen

Nutze „maximal zwei Fixes pro Problem" als Richtwert. Das ist keine offizielle Empfehlung, sondern eine operative Regel, um die Entscheidung an Menschen zurückzugeben, wenn es klemmt.

Wenn derselbe Bug nach zwei Versuchen nicht behoben ist, stoppe weitere Änderungen. Fasse versuchte Aktionen, vorgenommene Änderungen, verbleibende Symptome und nötige Entscheidungen zusammen. Weite es nicht auf unbeteiligte Features aus.

Anweisungen allein garantieren keinen Stopp. Überwache die Nutzung, brich unnötige Hintergrundanfragen mit /codex:cancel ab. Prüfe, ob Agenten wirklich gestoppt haben.

Kosten separat verfolgen

Codex-Kontingente mit ChatGPT-Authentifizierung unterscheiden sich von API-Key-Preisen. Parallele Agenten verbrauchen Inferenz- und Tool-Ressourcen.

Schleuse kleinere Textänderungen nicht durch beide KIs oder große Reviews.

Kategorisiere:

• Alleine abschließbare Aufgaben

• Aufgaben, die eine zweite Perspektive brauchen

• Unabhängig parallelisierbare Aufgaben

Das hilft bei der Entscheidung über Aufwand und Kontingentverteilung.

Auf veraltete Modellspezifikationen achten

Alte Modellspezifikationen verursachen Fehler. OpenAI-Update: GPT-5.5 endete für ChatGPT-authentifiziertes Codex am 15. Oktober 2026 (JST). API-Key-Authentifizierung ist nicht betroffen.

Aktualisiere alte Spezifikationen und Rollendateien auf aktuell verfügbare Modelle. Prüfe wählbare Modelle und akzeptierte Reasoning-Einstellungen, statt nur umzubenennen.

Berechtigungen und Hooks prüfen

Claude-Berechtigungen werden nicht immer an Codex weitergegeben. Prüfe Ausführungsrechte auf beiden Seiten. Übe ohne Produktionszugangsdaten. Verlange separate Genehmigungen für Löschungen, externe Veröffentlichungen und Abrechnungen.

Prüfe Hooks in öffentlichen Beispielen vor der Verwendung. Hooks werden zu festgelegten Zeiten automatisch ausgeführt; schau dir an, was tatsächlich läuft, und nicht nur die bequemen Ergänzungen.

„Schnell gebaut" messen

Vergleiche nicht nur die Generierungszeit.

• Wie oft du neu erklären musstest

• Zeit für Integration/Fehlerbehebung

• Verbleibende Fehler im Vergleich zu den Abschlusskriterien

Beziehe diese Punkte ein, um zu entscheiden, ob dieselbe Aufteilung beim nächsten Mal wieder funktioniert.

Starte mit kleinen wöchentlichen Tools

Nicht-Entwickler erzielen die einfachsten Erfolge dort, wo sie die Korrektheit selbst beurteilen können.

• Nachverfolgung von Anfragen

• Prüfung von Bestellfristen

• CSV-Formatierung mit konsistenter Sortierung

Beginne mit Use Cases, die sich leicht beschreiben lassen.

Zuerst die nahenden Deadlines? Erledigtes entfernen? Bei fehlenden Eingaben warnen? Tägliche Anforderungen werden zu KI-Abschlusskriterien.

Du musst nicht erst programmieren lernen; baue Prototypen basierend auf Bedingungen, nutze sie, repariere sie. Hinweis: Systeme mit Kundendaten oder öffentliche Dienste erfordern eine professionelle Validierung, die über einen erfolgreichen Prototyp hinausgeht.

Das anfängliche Team reicht aus:

1. Claude strukturiert die Spezifikationen

1. Codex führt eine Aufgabe aus

1. Überprüfe die gelieferten Ergebnisse aus einer anderen Perspektive

Speichere nützliche Prompts und Prüfvorgänge, damit du bei der nächsten App nicht alles komplett neu erklären musst.

Danke fürs Lesen.

Im LINE Open Chat „Niku's AI Speed Strategy" gibt es ein kostenloses 8-Punkte-Set.

• Einführungsleitfaden für Codex/Claude Code

• Copy-paste-Anleitungen

• Schnellreferenz-Tabellen

• 50 Mini-Apps

• 50 Bild-Prompts

• yomiyasu-Installation

• Titelgenerator

• X-Monetarisierungsablauf und Beträge

Hier geht's lang 👇 https://x.gd/VtPmw