Das Argument gegen Fable: So verleihen Sie Claude Code das Gehirn von GPT-5.6 Sol

Der Zeitraum, in dem Claude Fable 5 ohne zusätzliche Kosten genutzt werden konnte, war ursprünglich bis zum 7. Juli 2026 angekündigt, dann auf den 12. Juli und schließlich auf den 19. Juli verlängert worden. Die Maßnahme, das wöchentliche Nutzungslimit von Claude Code um 50 % zu erhöhen, gilt ebenfalls bis zum 19. Juli.

Mit anderen Worten: Fable 5 verschwindet nicht sofort.

Allerdings ist die Situation, in der Fable 5 innerhalb eines monatlichen Plans frei genutzt werden kann, nicht dauerhaft garantiert. Die ursprüngliche Ankündigung besagte, dass es nach Ablauf des Zeitraums auf Nutzungsguthaben umgestellt wird, mit API-Preisen von 10 $ pro 1 Million Eingabe-Token und 50 $ pro 1 Million Ausgabe-Token.

Was zu Ende geht, ist nicht Fable 5 selbst, sondern die Ära, in der die leistungsstärksten Modelle fast unbegrenzt für eine monatliche Gebühr genutzt werden können.

Sollen wir also Claude Code aufgeben und vollständig zu OpenAIs Codex wechseln?

Fazit: Das ist nicht nötig.

Du kannst die Claude-Code-Terminalerfahrung, die bestehende CLAUDE.md, Hooks, MCP, Skills und Berechtigungseinstellungen behalten und einfach schwierige Aufgaben an GPT-5.6 Sol übergeben.

Außerdem musst du keine fragwürdigen Proxy-Dienste oder inoffiziellen API-Kompatibilitätsschichten verwenden.

OpenAI selbst hat ein offizielles Plugin veröffentlicht, um Codex aus Claude Code heraus aufzurufen.

Was wir hier bauen, ist kein Mechanismus, um „Claude in GPT-5.6 zu verwandeln."

Es ist eine Zwei-Gehirn-Konfiguration, bei der Claude Code das Kommandozentrum bleibt und GPT-5.6 Sol als zweites Denk-Engine angeschlossen wird.

Claude kümmert sich um Benutzerdialoge, Repository-Erkundung, kleine Änderungen und das Befolgen bestehender Muster.

GPT-5.6 Sol kümmert sich um komplexe Designentscheidungen, ungelöste Fehler, gegnerische Überprüfungen, Änderungen über mehrere Komponenten hinweg und zweite Meinungen vor dem Ausliefern.

Darüber hinaus werden durch die Platzierung japanischer Betriebsanweisungen als Agent Skills beide Modelle dazu gebracht, dieselben Fertigstellungsbedingungen, Überprüfungsstandards und Änderungsumfänge einzuhalten.

Dies ist der realistischste Weg, Claude Code das „Gehirn von ChatGPT 5.6" zu geben.

Hinweis: Ich habe die Einrichtung und ernsthafte Nutzungstechniken in einem PDF zusammengefasst.

Wenn du es haben möchtest, habe ich es hier zur Verfügung gestellt 👇!

https://x.com/MakeAI_CEO/status/2027682940847898770?s=20

Drei Ebenen, um Claude Code das Gehirn von GPT-5.6 zu geben

Das erste, was man unterscheiden muss, ist, dass das Kopieren eines Prompts und das Verbinden mit einem tatsächlichen Modell unterschiedliche Dinge sind.

Das Schreiben von Anweisungen für GPT-5.6 in CLAUDE.md verwandelt das Claude-Modell nicht selbst in GPT-5.6.

Was sich ändert, ist die Art und Weise, wie die Arbeit durchgeführt wird.

Dies wird als Aktionsebene bezeichnet.

Als nächstes wird das offizielle OpenAI-„Codex-Plugin für Claude Code" eingeführt.

Mit diesem Plugin kannst du Code-Reviews und Implementierungsaufgaben von Claude Code aus an Codex delegieren, indem du die Codex-CLI und den Codex-App-Server verwendest, die in deiner lokalen Umgebung installiert sind.

Dies ist die Argumentations-/Ausführungsebene.

Schließlich wird das „OpenAI Developers Plugin" eingeführt.

Dieses enthält das Docs MCP, das auf die offizielle OpenAI-Dokumentation verweist, sowie Skills, die der OpenAI-API, dem Agents SDK, ChatGPT Apps, API-Key-Einstellungen und der Fehlerbehebung entsprechen.

Dies ist die Wissensebene.

Überlagere diese drei Ebenen.

Aktionsebene:

Japanische Betriebsanweisungen und Agent Skills

Argumentations-/Ausführungsebene:

Codex-Plugin für Claude Code

Wissensebene:

OpenAI Developers Plugin und offizielles Docs MCP

Auf diese Weise kannst du Claude Code für den täglichen Betrieb weiterverwenden und GPT-5.6 Sol sowie die neuesten OpenAI-Dokumente nur bei Bedarf aufrufen.

Zuerst das offizielle OpenAI Codex-Plugin installieren

Was du für die Installation benötigst, ist ein ChatGPT-Konto oder ein OpenAI-API-Key, Node.js 18.18 oder höher und die Codex-CLI.

Dieses Plugin überträgt keinen Code an einen inoffiziellen Dienst.

Es nutzt die Codex-CLI auf deinem Rechner und übernimmt die vorhandene Codex-Authentifizierung, Einstellungen, Repositories und lokalen Umgebungen. Wenn du bereits bei Codex eingeloggt bist, kannst du diesen Authentifizierungsstatus direkt verwenden.

Installiere oder aktualisiere zuerst die Codex-CLI.

npm install -g @openai/codex@latest

codex --version

codex login

Um GPT-5.6 mit Codex zu verwenden, ist Codex CLI 0.144.0 oder höher erforderlich.

codex --version

Wenn die angezeigte Version alt ist, installiere die neueste Version erneut.

Starte als nächstes Claude Code und führe Folgendes der Reihe nach aus:

/plugin marketplace add openai/codex-plugin-cc

/plugin install codex@openai-codex

/reload-plugins

/codex:setup

/codex:setup prüft, ob die Codex-CLI verfügbar und die Authentifizierung abgeschlossen ist.

Wenn Codex nicht installiert ist und npm verfügbar ist, wird während der Einrichtung möglicherweise eine Installation vorgeschlagen.

Wenn du es zum ersten Mal ausprobierst, ist ein schreibgeschützter Review sicher.

/codex:review --background

/codex:status

/codex:result

/codex:review überprüft die aktuellen, nicht committeten Diffs.

Wenn du die Diffs gegen den main-Branch prüfen lassen möchtest, machst du Folgendes:

/codex:review --base main --background

Dieser Befehl ist schreibgeschützt und ändert keinen Code.

Im Hintergrund gestartete Jobs können mit den folgenden Befehlen überprüft werden:

/codex:status

/codex:result

Um einen laufenden Prozess zu stoppen, machst du Folgendes:

/codex:cancel

Zwischen normalen und gegnerischen Reviews unterscheiden

Das Codex-Plugin verfügt über eine adversarial-review-Option, die sich von normalen Reviews unterscheidet.

/codex:adversarial-review --base main

Normale Reviews suchen nach Fehlern, fehlenden Tests, Fehlerbehandlung und Typusproblemen im Code.

Gegnerische Reviews hingegen stellen die Implementierungspolitik selbst in Frage.

Zum Beispiel kann nach der Implementierung der Authentifizierung Folgendes angefordert werden:

/codex:adversarial-review --base main Erwäge, ob die aktuelle Strategie selbst aus der Perspektive von Autorisierungsgrenzen, Privilegieneskalation, Session-Fixation, Token-Leakage und fehlenden Audit-Logs falsch ist.

Für die Abrechnungsverarbeitung machst du Folgendes:

/codex:adversarial-review --base main Konzentriere dich darauf, die Möglichkeit von Doppelabrechnungen, doppelten Webhooks, Wiederholungen nach Timeout, Teilfehlern, Transaktionsgrenzen und der Unfähigkeit zum Rollback in Frage zu stellen.

Wenn ein normales Review prüft, „ob es Fehler in dieser Implementierung gibt", prüft ein gegnerisches Review, „ob diese Implementierung überhaupt hätte gewählt werden sollen".

Beide sind schreibgeschützt und überschreiben ohne Erlaubnis keinen Code.

Die Stärke dieser Konfiguration ist die Fähigkeit, das Modell, das die Implementierung erstellt, von dem Modell zu trennen, das die Prämissen der Implementierung in Frage stellt.

Das offizielle Plugin bietet Befehle für normale Reviews, gegnerische Reviews, Rescue, Session-Transfer und das Überprüfen/Stoppen von Hintergrundprozessen.

Festgefahrene Arbeit mit Rescue an Codex übergeben

Tests bestehen nicht, selbst nach mehreren Korrekturen in Claude Code.

Die Ursache erstreckt sich über mehrere Komponenten.

Es tritt nur in CI fehl.

Parallelität oder Caching sind involviert, und das Symptom ist weit von der Ursache entfernt.

In solchen Fällen verwende /codex:rescue.

/codex:rescue Reproduziere den Fehler, identifiziere die Grundursache und erstelle den minimalen sicheren Fix und Regressionstest.

Du kannst auch das Modell und die Reasoning-Stärke angeben.

/codex:rescue --model gpt-5.6-sol --effort high Reproduziere den Fehler, identifiziere die Grundursache, implementiere den minimalen sicheren Fix und führe zugehörige Tests aus.

Sende lange Prozesse in den Hintergrund.

/codex:rescue --background --model gpt-5.6-sol --effort high Untersuche Testfehler, die nur in CI auftreten.

Ergebnisse werden mit den folgenden Befehlen abgerufen:

/codex:status

/codex:result

Um die vorherige Codex-Aufgabe fortzusetzen, kannst du --resume verwenden.

/codex:rescue --resume Implementiere und verifiziere den sichersten Plan unter den zuvor vorgeschlagenen Korrekturen.

Um als neue Untersuchung getrennt von der vorherigen zu beginnen, verwende --fresh.

/codex:rescue --fresh Untersuche die Grundursache anhand einer anderen Hypothese.

Um die gesamte Konversation von Claude Code an Codex zu übergeben, verwende den folgenden Befehl:

/codex:transfer

Nach der Ausführung wird ein Befehl zum Fortsetzen auf der Codex-Seite angezeigt.

codex resume <session-id>

Dies ermöglicht einen Transfer, bei dem „die Untersuchung in Claude Code begonnen wurde, aber Codex die Führung übernimmt".

GPT-5.6 Sol als Standardmodell festlegen

Wenn du das Codex-Modell pro Projekt festlegen möchtest, platziere .codex/config.toml im Stammverzeichnis des Repositorys.

model = "gpt-5.6-sol"

model_reasoning_effort = "high"

review_model = "gpt-5.6-sol"

Um es zu einer gemeinsamen Einstellung für alle persönlichen Projekte zu machen, platziere es hier:

~/.codex/config.toml

Projektspezifische Einstellungen kommen hierhin:

your-project/.codex/config.toml

Projekteinstellungen werden geladen, wenn das Repository als vertrauenswürdig behandelt wird.

Im täglichen Betrieb ist es nicht nötig, von Anfang an die maximale Reasoning-Stärke zu verwenden.

Als Richtlinie teilst du es wie folgt ein:

low:

Wortkorrekturen, Namensänderungen, klare kleine Änderungen

medium:

Normale Funktionserweiterungen, Implementierungen, die bestehenden Mustern folgen

high:

Änderungen über mehrere Dateien hinweg, schwieriges Debugging, Designentscheidungen

xhigh:

Sicherheitsüberprüfungen, groß angelegte Migrationen, komplexe Race Conditions, lange Untersuchungen

In Codex kannst du GPT-5.6 Sol, Terra oder Luna auswählen.

Sol eignet sich für komplexe und hochflexible Arbeiten, Terra für die tägliche Implementierung und Luna für klare und wiederholbare Arbeiten.

Außerdem stehen Max und Ultra getrennt von der normalen Reasoning-Stärke zur Verfügung.

Max gibt einer einzelnen Aufgabe mehr Reasoning-Zeit.

Ultra verwendet Sub-Agenten, um aufteilbare Arbeiten parallel zu verarbeiten.

Allerdings sind Max und Ultra für die meisten Aufgaben nicht notwendig. Es ist besser, mit Medium oder High zu beginnen und nur zu erhöhen, wenn ein Unterschied in der tatsächlichen Bewertung sichtbar wird.

„GPT-5.6 Sol High" und „GPT-5.6 Sol Pro" sind nicht dasselbe

Dies wird leicht verwechselt.

In ChatGPT wird GPT-5.6 Sol für Medium, High und Extra High verwendet.

Andererseits wird GPT-5.6 Sol Pro für Pro verwendet.

Daher bedeutet die einfache Angabe von Folgendem im Codex-Plugin:

--model gpt-5.6-sol --effort high

Nicht, dass „GPT-5.6 Sol Pro verwendet wurde".

Dies bedeutet, dass GPT-5.6 Sol mit hoher Reasoning-Stärke ausgeführt wurde.

In der OpenAI API Responses API kannst du standard oder pro als reasoning.mode für GPT-5.6 wählen.

Um den Pro-Modus zu verwenden, würde die Anfrage wie folgt aussehen:

{

"model": "gpt-5.6",

"reasoning": {

"mode": "pro",

"effort": "high"

},

"input": "Überprüfe diesen Datenbank-Migrationsplan und identifiziere Fehlermuster, Wiederherstellungsmethoden und Bedingungen, die ein Rollback unmöglich machen."

}

reasoning.mode und reasoning.effort sind unterschiedliche Einstellungen.

reasoning.mode:

standard or pro

reasoning.effort:

low, medium, high, xhigh, etc.

Der Pro-Modus führt mehr Modellverarbeitung durch als der Standard-Modus, was die Latenz und die Token-Nutzung erhöht.

Wenn du diesen Pro-Modus der API strikt von Claude Code aus aufrufen möchtest, würde die Konfiguration die Vorbereitung eines lokalen Skripts oder MCP-Servers beinhalten, der die Responses API umschließt, und den Aufruf über einen Claude Code Skill.

Für normale Codierarbeiten solltest du jedoch zuerst GPT-5.6 Sols Medium oder High mit dem offiziellen Codex-Plugin ausprobieren.

Erst dann kannst du Aufgaben hochstufen, bei denen die Wirkung des Pro-Modus durch tatsächliche Bewertungsergebnisse bestätigt wurde.

Du musst nicht alle Prozesse an Pro übergeben, nur weil „Pro" im Namen steht.

Der „System Prompt" für ChatGPT 5.6 Sol Pro ist nicht öffentlich

Sei hier vorsichtig.

Die Vollversion des internen System Prompts, den OpenAI in ChatGPT oder GPT-5.6 Sol Pro verwendet, ist nicht öffentlich.

Daher solltest du Texten unbekannter Herkunft, die du im Internet findest, wie „geleakter GPT-5.6 System Prompt", „vollständige Reproduktionsversion" oder „vollständiger interner Prompt-Text", nicht glauben und einführen.

Was du verwenden solltest, ist ein Betriebs-Prompt, der erstellt wurde, um in deine Entwicklungsumgebung zu passen, während du dich an offiziellen Prompt-Leitfäden orientierst.

Offizielle Leitfäden für GPT-5.6 empfehlen, die folgenden Elemente im Prompt anzugeben:

• Das endgültige Ergebnis, das erreicht werden soll
• Wichtige Einschränkungen
• Verfügbare Beweise
• Kriterien für die Beurteilung der Fertigstellung

Vermeide es andererseits, die Suchreihenfolge, die Tool-Auswahl und die detaillierten Denkschritte übermäßig festzulegen, und lasse dem Modell Raum, effiziente Wege zu wählen.

Es wird auch erklärt, dass das Ausdünnen doppelter Anweisungen, unnötiger Beispiele und bedeutungsloser Tool-Beschreibungen zur Leichtigkeit des System Prompts zu Verbesserungen bei der Leistung und Token-Effizienz führen kann.

Im Folgenden findest du einen japanischen Betriebs-Prompt, der für die gemeinsame Nutzung mit Claude Code, Codex und GPT-5.6 Sol entwickelt wurde.

Dies ist keine Reproduktion eines internen OpenAI-Prompts.

Japanischer Betriebs-Prompt für Claude Code und GPT-5.6 Sol

Rolle

Du bist ein leitender Ausführungsorchestrator in diesem Repository.

Dein Ziel ist es, korrekte, wartbare und verifizierte minimale Änderungen bereitzustellen, die die Ergebnisse erfüllen, die der Benutzer wirklich sucht.

Viel Text zu schreiben, die Anzahl der geänderten Dateien zu erhöhen oder viele Tools zu verwenden, sind an sich keine Bewertungsziele.

Du wirst nach Genauigkeit, Beweisen, Maßhalten im Änderungsumfang und überprüfbaren Ergebnissen bewertet.

Betriebsvereinbarung

1. Ergebnisse klären

Bevor du mit Bearbeitungen beginnst, identifiziere Folgendes:

• Das für den Benutzer sichtbare Endergebnis
• Verwandte Repository-Bereiche
• Einschränkungen, die eingehalten werden müssen
• Was diesmal nicht getan wird
• Kriterien für die Beurteilung der Fertigstellung
• Überprüfungsmethoden, die die Fertigstellung beweisen können

Klär zunächst unklare Punkte anhand von Beweisen im Repository.

Frage den Benutzer nur dann, wenn fehlende Urteile das Produktverhalten, die Sicherheit, die Kosten, die Daten oder irreversible Operationen erheblich verändern.

Stelle keine Fragen, nur um die Untersuchung des Repositorys zu vermeiden.

2. Vor Änderungen untersuchen

Lies den notwendigen und ausreichenden Mindestumfang an Dateien.

Untersuche Folgendes:

• Vorhandene Implementierungsmuster
• Tests
• Schnittstellen
• Migrationen
• Namenskonventionen
• Designkonventionen
• Fehlerbehandlung
• Authentifizierungs- und Autorisierungsgrenzen

Bevorzuge Beweise im Repository gegenüber Spekulationen oder Framework-Standards.

Bei Fehlerbehebungen stelle reproduzierbare Fehler oder spezifische Beweise, die die Ursache stützen, sicher, bevor du Korrekturen vorschlägst.

Schreibe vorhandene Mechanismen nicht um, bevor du verstehst, warum sie existieren.

3. In angemessener Tiefe planen

Wenn die Änderung klein, lokal und leicht rückgängig zu machen ist, fahre mit der Arbeit fort.

Wenn einer der folgenden Punkte zutrifft, zeige vor der Implementierung einen prägnanten Plan:

• Erstreckt sich über mehrere Dateien
• Ändert die Architektur
• Betrifft die Sicherheit
• Schreibt Daten um
• Ändert öffentliche Schnittstellen
• Schwer rückgängig zu machen
• Betrifft Abrechnung, Authentifizierung, Berechtigungen oder personenbezogene Daten
• Betrifft Parallelität oder asynchrone Verarbeitung

Füge Folgendes in den Plan ein:

• Das beabsichtigte Verhalten, das realisiert werden soll
• Dateien oder Komponenten, die wahrscheinlich geändert werden
• Invarianten, die aufrechterhalten werden müssen
• Hauptrisiken
• Überprüfungsverfahren
• Rollback- oder Wiederherstellungsmethoden nach Bedarf

Erhöhe keine formalen Verfahren, die das Risiko nicht verringern.

4. Arbeit der optimalen Engine zuweisen

Verwende die aktuelle Claude Code-Sitzung für die folgenden Aufgaben:

• Schnelle Repository-Erkundung
• Interaktion mit dem Benutzer
• Kleine Änderungen mit klarem Umfang
• Aufgabenzerlegung und Fortschrittsverwaltung
• Implementierung nach bestehenden Mustern
• Überprüfung und Integration von von Codex zurückgegebenem Feedback

Erwäge die Delegierung an Codex oder eine unabhängige Überprüfung, wenn einer oder mehrere der folgenden Punkte zutreffen:

• Die Arbeit steckt trotz fundierter Untersuchung oder Korrekturversuche fest
• Änderungen erstrecken sich über mehrere interagierende Komponenten
• Es gibt einen Wert in einem unabhängigen zweiten Implementierungsplan
• Eine Überprüfung aus gegnerischer Perspektive ist wirksam
• Risiken in Bezug auf Genauigkeit, Sicherheit, Parallelität, Migration oder Rollback sind hoch
• Der Benutzer bittet explizit um die Verwendung von GPT-5.6 Sol
• Es besteht die Notwendigkeit, die aktuelle Implementierungspolitik vor der Veröffentlichung in Frage zu stellen

Wenn Unsicherheit allein durch eine Überprüfung ausgeräumt werden kann, verwende lesende Codex-Reviews, bevor du beschreibbare Delegierung durchführst.

Behaupte nicht, GPT-5.6 Sol Pro verwendet zu haben, es sei denn, du verwendest den dokumentierten Pro-Modus in einer tatsächlichen Anfrage.

Melde genau die verwendete Modell-ID, Reasoning-Stärke und den Reasoning-Modus.

5. Mit engem Änderungsumfang implementieren

Sofern kein Redesign explizit angefordert wird, folge der vorhandenen Architektur, den Namenskonventionen und den Repository-Praktiken.

Vermeide Folgendes:

• Nicht zusammenhängendes Refactoring
• Übermäßige Abstraktion, die die Zukunft vorhersagt
• Hinzufügen unnötiger Abhängigkeiten
• Sinnlose Formatierungsänderungen
• Umfangreiche Umschreibungen
• Ändern des öffentlichen Verhaltens außerhalb des angeforderten Umfangs
• Löschen vorhandener Tests ohne Grund
• Schlucken von Ausnahmen, nur um Probleme zu verbergen

Halte die Abwärtskompatibilität aufrecht, es sei denn, Breaking Changes sind eine explizite Anforderung.

Gib keine Geheimnisse, Anmeldeinformationen, privaten Schlüssel, Tokens, Kundendaten oder personenbezogenen Daten preis.

Zeichne keine Geheimnisse an den folgenden Orten auf:

• CLAUDE.md
• AGENTS.md
• SKILL.md
• Quelldateien
• Logs
• Test-Fixtures
• Generierte Berichte
• Commit-Nachrichten

6. Durch Beweise verifizieren

Führe die relevanteste Überprüfung für die Änderungen im verfügbaren Bereich durch.

Als Regel priorisiere die folgende Reihenfolge:

1. Gezielte Tests
2. Typprüfungen
3. Lint- und Formatprüfungen
4. Build
5. Integrationstests
6. Laufzeit- oder visuelle Bestätigung

Führe nur Überprüfungen durch, die den Änderungen angemessen sind.

Unterlasse jedoch nicht notwendige Überprüfungen, nur um schnell fertig zu werden.

Bei UI-Änderungen überprüfe nach Möglichkeit den tatsächlichen Arbeitsbildschirm.

Bei Fehlerbehebungen füge nach Möglichkeit Regressionstests hinzu oder aktualisiere sie.

Bei Migrationen oder destruktiven Operationen überprüfe Folgendes:

• Erfolgreiche Vorwärtsverarbeitung
• Handhabung bei Fehlern
• Rollback oder Wiederherstellung
• Verhalten bei teilweiser Ausführung
• Verhalten bei Wiederholungen
• Verhalten bei doppelter Ausführung

Verwende keine Ausdrücke wie „behoben", „funktioniert", „sicher" oder „abgeschlossen", ohne Beweise zu zeigen.

Wenn die Überprüfung nicht ausgeführt werden kann, gib den Grund und das, was ungeprüft bleibt, genau an.

Erfinde keine fehlgeschlagenen Tests als erfolgreich.

7. Endgültige Diffs überprüfen

Bevor du die Arbeit beendest, führe die folgenden Prüfungen durch:

• Überprüfung der endgültigen Diffs
• Suche nach unbeabsichtigten Änderungen
• Prüfung der Fehlerbehandlung und Randbedingungen
• Prüfung der Sicherheitsgrenzen und Autorisierungsverarbeitung
• Prüfung der Parallelität und des Wiederholungsverhaltens nach Bedarf
• Prüfung auf fehlende Tests
• Vergleich der Endergebnisse mit den anfänglichen Ergebniszielen
• Prüfung, ob Inhalte, die nicht getan werden sollten, versehentlich implementiert wurden

Bei risikoreichen Änderungen fordere ein unabhängiges Codex-Review an.

Verarbeite alle wichtigen Überprüfungspunkte mit einer der folgenden Optionen:

• Korrigiere sie
• Lehne sie ab, indem du Beweise im Repository zeigst
• Dokumentiere sie klar als außerhalb des diesmaligen Umfangs
• Zeichne sie als aufgrund fehlender Umgebung ungeprüft auf

Übernimm Änderungen nicht bedingungslos, nur weil Codex darauf hingewiesen hat.

Überprüfe Punkte mit Code, Spezifikationen, Tests und Ausführungsergebnissen.

8. Am angemessenen Punkt enden

Beende die Arbeit, sobald die Fertigstellungskriterien erfüllt sind.

Führe kein unnötiges Polieren über den angeforderten Umfang hinaus fort.

Füge keine nicht zusammenhängenden TODOs oder Redesign-Pläne hinzu, um die Arbeit größer erscheinen zu lassen.

Die endgültige Antwort sollte Folgendes enthalten:

1. Bereitgestellte Ergebnisse
2. Hauptänderungen
3. Durchgeführte Überprüfungen und Ergebnisse
4. Verbleibende Risiken, Annahmen oder Blockaden
5. Spezifische Operationen, die als nächstes durchgeführt werden sollen, nur wenn wirklich notwendig

Der Zweck dieses Prompts ist nicht, das Modell zu einer „genialen Ingenieurspersona" zu machen.

Es geht darum, Ergebnisse, Beweise, Änderungsumfang, Delegierungsbedingungen, Überprüfung und Stoppbedingungen zu klären.

Es ist einfacher zu bedienen, indem man definiert, was eine Fertigstellung ausmacht, anstatt eine große Menge abstrakter Anweisungen wie „denke gründlich nach" oder „handle wie der weltbeste Ingenieur" zu schreiben.

Lange Prompts in Skills ablegen, nicht in CLAUDE.md

Du kannst den vorherigen Prompt direkt in CLAUDE.md schreiben.

Das Ablegen langer Texte, die nicht immer benötigt werden, in CLAUDE.md verbraucht jedoch in jeder Sitzung Kontext.

Ein besserer Ort ist ein Agent Skill.

Claude Code Skills erkennen zuerst den Namen und die Beschreibung und laden den SKILL.md-Text nur bei Bedarf.

Codex Skills übernehmen ähnlich einen Mechanismus, um Anweisungen, Referenzmaterialien, Skripte, Vorlagen usw. in einem Verzeichnis zu gruppieren und nur bei Bedarf zu laden.

Da beide das Agent Skills-Format verwenden, ist es einfach, grundlegende Prompts und Verfahren zu teilen.

Speichere es in Claude Code an folgendem Ort:

.claude/

└── skills/

└── sol-pro-orchestrator/

└── SKILL.md

Der Anfang von SKILL.md sollte so aussehen:

name: sol-pro-orchestrator

description: >

Verwenden für komplexe Änderungen, Änderungen über mehrere Dateien hinweg, risikoreiche Änderungen,

wenn die Arbeit feststeckt, oder für wichtige Arbeiten vor der Veröffentlichung.

Anwenden, wenn klare Planung, Überprüfung und unabhängige Codex-Überprüfung oder Delegierung erforderlich sind.

Sol Pro Orchestrator

[Platziere hier den japanischen Betriebs-Prompt]

Um es explizit aufzurufen, machst du Folgendes:

/sol-pro-orchestrator Füge Abrechnungsverarbeitung hinzu. Behalte das bestehende Idempotenz-Design bei und erstelle Regressionstests bis zur Doppelabrechnung.

Wenn die Beschreibung des Skills mit der Anfrage übereinstimmt, kann Claude es automatisch laden.

Wenn du nicht möchtest, dass es automatisch startet, füge Folgendes zum Frontmatter hinzu:

disable-model-invocation: true

In diesem Fall wird der Skill nur verwendet, wenn der Benutzer explizit den Slash-Befehl ausführt.

Es ist besser, nur kurze Regeln, die immer notwendig sind, in CLAUDE.md zu lassen und komplexe Arbeitsabläufe in Skills zu trennen.

Zum Beispiel reicht CLAUDE.md mit etwas wie diesem:

Repository-Regeln

• Befolge die vorhandene Architektur und Namenskonventionen.
• Priorisiere minimale Änderungen, die die Sicherheit aufrechterhalten können.
• Führe vor dem Abschluss relevante Tests aus.
• Ändere keine nicht zusammenhängenden Dateien.
• Verwende den sol-pro-orchestrator Skill für komplexe, feststeckende, risikoreiche oder wichtige Arbeiten vor der Veröffentlichung.

Offizielle OpenAI Skills zu Claude Code hinzufügen

Es reicht nicht, nur GPT-5.6 Sol aufrufen zu können.

Wenn das Modell Fragen zur OpenAI-API oder zum Agents SDK nur auf der Grundlage von Erinnerungen aus der Trainingszeit beantwortet, kann es alte APIs, veraltete Parameter oder nicht mehr empfohlene Implementierungen verwenden.

Hier kommt das „OpenAI Developers Plugin" ins Spiel.

Führe Folgendes in Claude Code aus:

/plugin marketplace add openai/openai-developers-for-claude

/plugin install openai-developers@openai-developers

Nach der Installation starte eine neue Claude Code-Sitzung.

Dieses Plugin enthält das offizielle OpenAI Docs MCP und die folgenden Skills:

openai-docs:

Leitet Fragen zu OpenAI-Produkten, APIs, Modellen und SDKs an die offizielle Dokumentation weiter.

Wird verwendet, um Informationen zu überprüfen, die sich leicht ändern, wie neue Modellnamen, aktuelle API-Parameter, SDK-Verwendung und Codex-Einstellungen.

openai-platform-api-key:

Führt durch die OPENAI_API_KEY-Einstellungen in der lokalen Umgebung.

Dieser Skill ist für die Verbindung als Umgebungsvariable gedacht, anstatt API-Keys in Quellcode oder Prompts einzufügen.

openai-api-troubleshooting:

Klassifiziert OpenAI-API-Fehler.

Überprüft Authentifizierung, Berechtigungen, Modellspezifikation, Ratenlimits, Netzwerk, Anfrageformat usw. und führt zur nächsten zu ergreifenden Maßnahme.

agents-sdk:

Unterstützt Design, Implementierung, Ausführung und Bewertung von Anwendungen, die das OpenAI Agents SDK verwenden.

build-chatgpt-app:

Entwirft und implementiert Projekte mit dem ChatGPT Apps SDK.

Wird für die App-Entwicklung einschließlich MCP-Server, Widget-UI und Integration mit ChatGPT verwendet.

chatgpt-app-submission:

Bereitet ChatGPT-App-Einreichungen, Beschreibungsinformationen, Testfälle usw. vor.

Dieses Plugin ist ein offizielles Repository, das von OpenAI für Claude Code veröffentlicht wurde.

Es ist eine Sammlung des öffentlichen OpenAI Docs MCP und von Entwicklungsskills, die für Claude Code angepasst wurden.

Hier solltest du die beiden Plugins nicht verwechseln.

codex-plugin-cc:

Ausführungsbrücke zur Delegierung von Reviews und Implementierung an Codex.

openai-developers-for-claude:

Wissenspaket, das Claude Code offizielle OpenAI-Informationen und Entwicklungsverfahren hinzufügt.

Durch das Hinzufügen beider wird Claude Code zu einer Umgebung, in der es nicht nur „Codex nachdenken lässt", sondern auch „unter Berücksichtigung der offiziellen OpenAI-Spezifikationen implementiert".

Wie man Aufgaben in der Praxis zwischen Claude und Codex aufteilt

Es ist nicht nötig, alle Jobs gleichzeitig an beide Modelle zu werfen.

Teile die Rollen auf.

German (Deutsch) Translation:

Vertraue Claude Code die folgenden Aufgaben an:

• Repository-Erkundung
• Interaktion mit dem Benutzer
• Verständnis bestehender Implementierungen
• Kleine Änderungen
• Implementierung nach bekannten Mustern
• Umsetzung von Codex-Punkten in Code

Vertraue GPT-5.6 Sol die folgenden Aufgaben an:

• Komplexe Designentscheidungen
• Festgefahrene Bugs
• Untersuchungen, die mehrere Komponenten betreffen
• Adversarial Reviews
• Prüfung von Sicherheitsgrenzen
• Untersuchung von Concurrency- und Race-Condition-Problemen
• Prüfung von Migrationen und Rollbacks
• Unabhängige Reviews vor der Freigabe

Wenn du beispielsweise einen neuen Abrechnungsprozess hinzufügst, würde der Ablauf wie folgt aussehen:

1. Untersuche bestehende Abrechnungsabläufe, Tests und das Idempotenz-Design in Claude Code.
2. Korrigiere den Plan und die Fertigstellungsbedingungen mit der sol-pro-orchestrator Skill.
3. Claude erstellt die minimale Implementierung und Regressionstests.
4. Hinterfrage die Designpolitik mit einem Codex-Adversarial-Review.
5. Claude verifiziert die Punkte mit Code und Tests.
6. Übernimm nur die notwendigen Korrekturen.
7. Prüfe die finalen Diffs mit einem normalen Codex-Review.

Rufe zuerst die Skill auf.

/sol-pro-orchestrator Add billing processing. Investigate existing design and include idempotency, duplicate webhooks, and regression tests in completion conditions.

Führe nach der Implementierung ein Adversarial-Review durch.

/codex:adversarial-review --base main Focus on doubting the possibility of double billing, duplicate webhooks, retries after timeout, partial failures, transaction boundaries, and inability to rollback.

Führe nach der Korrektur ein normales Review durch.

/codex:review --base main --background

/codex:status

/codex:result

Das Ziel dieser Methode ist es nicht zu entscheiden, welches Modell – Claude oder GPT – stärker ist.

Es geht darum, die Rolle der Implementierungserstellung von der Rolle des Infragestellens der Prämissen der Implementierung zu trennen.

Wenn du dasselbe Modell bittest, "zu implementieren und sich dann streng selbst zu reviewen", wird es wahrscheinlich auf der Grundlage des ursprünglich gewählten Designs reviewen.

Indem du ein Modell eines anderen Systems als Kritiker hinzuziehst, kannst du andere Erkundungspfade und Fehlerhypothesen einbringen.

Dabei handelt es sich nicht um einen Wettbewerb zwischen Modellen, sondern um eine Aufgabentrennung in der Softwareentwicklung.

Nicht alles an Sol High senden

Das Senden von Dateinamenänderungen, Anzeigetextkorrekturen und einfachen Typfehlern an GPT-5.6 Sol High verschwendet Nutzungslimits und Zeit.

Betrachte die Modellnutzung wie folgt:

Claude Code:

Interaktion, Erkundung, kleine Korrekturen, Integrationsarbeit

GPT-5.6 Luna:

Klare und umfangreiche Konvertierungen, Klassifizierung, Routinearbeit

GPT-5.6 Terra:

Tägliche Implementierung, normales Debugging

GPT-5.6 Sol Medium:

Implementierung mit einem gewissen Maß an Planung oder Urteilsvermögen

GPT-5.6 Sol High:

Schwieriges Design, komplexe Bugs, wichtige Reviews

GPT-5.6 Sol xhigh, Max, Pro, Ultra:

Die schwierigsten Aufgaben, bei denen zusätzliche Effekte durch Evaluierung bestätigt werden

Anstatt immer High-Performance-Modelle zu verwenden, konzentriere sie auf Aufgaben, bei denen der Verlust bei Fehlschlag groß ist.

Dies erleichtert sowohl die Überprüfung der Ergebnisse als auch der Kosten.

Review Gates nicht immer aktiviert lassen

Das offizielle Codex-Plugin hat ein Review-Gate, das automatisch eine Codex-Review ausführt, wenn Claude versucht, eine Arbeit abzuschließen.

Der Befehl zum Aktivieren lautet wie folgt:

/codex:setup --enable-review-gate

Zum Deaktivieren verwende:

/codex:setup --disable-review-gate

Wenn ein Problem im Review gefunden wird, kannst du verhindern, dass Claude abschließt, und zur Korrektur zurückkehren.

Es ist mächtig, aber es können lange Schleifen zwischen Claude und Codex entstehen, die schnell Nutzungslimits verbrauchen.

Daher ist es besser, es auf Situationen wie die folgenden zu beschränken:

• Freigabe-Kandidaten
• Änderungen an Authentifizierung/Authorisierung
• Abrechnungsverarbeitung
• Umfangreiche Datenmigrationen
• Sicherheitsgrenzen
• Änderungen, die schwer rückgängig zu machen sind

Bei täglichen kleinen Aufgaben ist es einfacher, sie durch manuelle Reviews zu gegebener Zeit zu erledigen.

Die offizielle README warnt ebenfalls, dass Review Gates lange Claude/Codex-Schleifen erzeugen und Nutzungslimits verbrauchen können, daher sollten sie nur aktiviert werden, wenn sie überwacht werden können.

Codex-Punkte nicht bedingungslos übernehmen

GPT-5.6 Sol ist leistungsstark, aber nicht immer korrekt.

Es kann nicht existierende Spezifikationen annehmen, repository-spezifische Umstände übersehen oder übermäßige Designänderungen vorschlagen.

Verarbeite Review-Punkte mit einer der folgenden Optionen:

Übernommen:

Grundlage bestätigt und Korrektur sowie Verifikation durchgeführt.

Abgelehnt:

Nicht übernommen, indem Nachweise aus Repository, Spezifikationen oder Tests erbracht wurden.

Verschoben:

Valider Punkt, aber als separates Ticket erstellt, da außerhalb des aktuellen Rahmens.

Nicht verifiziert:

Konnte aufgrund fehlender Umgebung oder Berechtigungen nicht bestätigt werden.

Du änderst Dinge nicht, "weil Codex es gesagt hat."

"Die von Codex präsentierte Fehlerhypothese mit Code und Tests zu bestätigen" ist korrekt.

Der Wert einer Dual-Brain-Konfiguration liegt nicht im bedingungslosen Glauben an die Antworten, sondern in der Erhöhung anderer Möglichkeiten, die überprüft werden sollten.

Mindestsicherheitslinie

Claude Code und Codex lesen beide Repositories, führen Befehle aus und überschreiben je nach Einstellungen Dateien.

Wenn du zwei Agenten verbindest, musst du vor der Bequemlichkeit die Berechtigungsgrenzen festlegen.

Beginne zuerst mit Read-Only-Reviews.

/codex:review

/codex:adversarial-review

Setze Rescue, die Schreibzugriff beinhaltet, erst ein, nachdem du das Ziel-Repository und den Arbeitsinhalt bestätigt hast.

Füge keine .env-Dateien, privaten Schlüssel, Kundendaten oder Zugriffstoken in CLAUDE.md, AGENTS.md oder SKILL.md ein.

Setze den OpenAI-API-Key als Umgebungsvariable.

export OPENAI_API_KEY="..."

Verwende in der Praxis Shell-Profile, Secret-Management-Dienste, CI-Secret-Funktionen usw.

Gehe außerdem nicht davon aus, dass die Berechtigungseinstellungen von Claude Code und die Sandbox-/Genehmigungseinstellungen von Codex identisch sind.

Überprüfe den Umfang des Netzwerkzugriffs, des Dateischreibens und der Befehlsausführung sowohl auf der Claude-Seite als auch auf der Codex-Seite.

Wenn du externe MCPs hinzufügst, überprüfe den Anbieter und die Berechtigungen und erlaube nur notwendige Tools.

Abgeschlossene Verzeichnisstruktur

Das finale Repository wird wie folgt aussehen:

1your-project/
2├── CLAUDE.md
3├── AGENTS.md
4├── .claude/
5│   └── skills/
6│       └── sol-pro-orchestrator/
7│           └── SKILL.md
8├── .codex/
9│   └── config.toml
10├── src/
11├── tests/
12└── package.json

Die Rollen für jede Datei sind klar verteilt.

CLAUDE.md:

Schreibe kurze Repository-Regeln, die Claude Code immer befolgt.

• Befolge die bestehende Architektur
• Ändere keine nicht zusammenhängenden Dateien
• Priorisiere minimale, sichere Änderungen
• Führe relevante Tests aus

AGENTS.md:

Schreibe Projektinformationen, die Codex benötigt.

• Repository-Struktur
• Start der Entwicklungsumgebung
• Build-Befehle
• Test-Befehle
• Design-Einschränkungen
• Fertigstellungsbedingungen

.claude/skills/sol-pro-orchestrator/SKILL.md:

Schreibe japanische operative Prompts, die nur für komplexe Arbeiten geladen werden.

.codex/config.toml:

Schreibe das Modell und die Reasoning-Stärke, die in Codex verwendet werden.

1model = "gpt-5.6-sol"
2model_reasoning_effort = "high"
3review_model = "gpt-5.6-sol"

Und füge die beiden offiziellen Plugins zu Claude Code hinzu:

• openai/codex-plugin-cc
• openai/openai-developers-for-claude

Jetzt hat Claude Code die folgenden Rollen:

• Tägliche Implementierung und Interaktion durch Claude
• Unabhängiges Review und Rescue durch GPT-5.6 Sol
• Prüfung der neuesten Spezifikationen durch OpenAI Official Docs MCP
• Wiederverwendbare Entwicklungsprozesse durch Agent Skills

Zusammenfassung: Claude Code nicht aufgeben, ein zweites Gehirn hinzufügen

Der Zeitraum für die Nutzung von Fable 5 ohne zusätzliche Kosten wurde bis zum 19. Juli 2026 verlängert.

Daher befinden wir uns nicht in einem Zustand, in dem "Fable heute endet."

Der Trend, dass die weitere Nutzung der leistungsstärksten Modelle innerhalb eines monatlichen Plans nicht mehr selbstverständlich ist, bleibt jedoch unverändert.

Das bedeutet nicht, dass du Claude Code aufgeben musst.

Behalte Claude Code als Kommandozentrale.

Verwende das offizielle OpenAI-Codex-plugin-cc, um GPT-5.6 Sol für Reviews, Rescue und Implementierung aufzurufen.

Füge das OpenAI-Developers-Plugin hinzu, um Official Docs MCP und OpenAI-Entwicklungs-Skills zu nutzen.

Mache gängige operative Prompts zu Agent Skills, die nur bei Bedarf geladen werden, anstatt sie als riesige residente Anweisungen in CLAUDE.md zu stopfen.

Und trenne das "Modell, das die Implementierung erstellt hat" von dem "Modell, das diese Implementierung anzweifelt."

Mit dieser Konfiguration kannst du GPT-5.6-Reasoning dort einfügen, wo es benötigt wird, ohne das Betriebsgefühl, die bestehenden Einstellungen, Skills, MCPs und Projekt-Assets von Claude Code aufzugeben.

Du verwandelst Claude nicht in GPT.

Du beherbergst einen weiteren Senior Engineer in Claude Code, den du jederzeit konsultieren kannst.

Anstatt dich für alle Arbeiten auf ein Modell zu verlassen, verwende Modelle entsprechend dem Arbeitsinhalt.

Normalerweise arbeite schnell mit Claude Code fort.

An schwierigen Stellen bitte GPT-5.6 Sol um Rescue.

Vor der Auslieferung erhalte ein Adversarial-Review von einem anderen Modell.

Lass das Official Docs MCP die neuesten OpenAI-API-Spezifikationen prüfen.

Claude Code ist von nun an kein Codierungswerkzeug mehr, das innerhalb eines einzigen Modells abgeschlossen wird.

Die richtige Herangehensweise ist, es als ein Entwicklungs-Betriebssystem zu verwenden, das mehrere Modelle, Skills, MCPs und Plugins bündelt.