La période d'utilisation de Claude Fable 5 sans frais supplémentaires a d'abord été annoncée pour se terminer le 7 juillet 2026, puis prolongée jusqu'au 12 juillet, puis encore jusqu'au 19 juillet. La mesure visant à augmenter de 50 % la limite hebdomadaire d'utilisation de Claude Code sera également maintenue jusqu'au 19 juillet.
En d'autres termes, Fable 5 ne disparaît pas immédiatement.
Cependant, la situation dans laquelle Fable 5 peut être utilisé naturellement dans le cadre d'un abonnement mensuel n'est pas garantie en permanence. L'annonce initiale précisait qu'il passerait à des crédits d'utilisation après la fin de la période, avec un tarif API de 10 $ pour 1 million de tokens d'entrée et 50 $ pour 1 million de tokens de sortie.
Ce qui prend fin, ce n'est pas Fable 5 lui-même, mais l'ère où les modèles les plus performants pouvaient être utilisés quasi sans limite pour un simple abonnement mensuel.
Alors, faut-il abandonner Claude Code et migrer complètement vers Codex d'OpenAI ?
En conclusion, ce n'est pas nécessaire.
Vous pouvez conserver l'expérience terminal de Claude Code, les fichiers CLAUDE.md existants, les Hooks, MCP, Skills, et les paramètres d'autorisation, et simplement confier les tâches difficiles à GPT-5.6 Sol.
De plus, il n'est pas nécessaire d'utiliser des services proxy douteux ou des couches de compatibilité API non officielles.
OpenAI a lui-même publié un plugin officiel pour appeler Codex depuis Claude Code.
Ce que nous construisons ici n'est pas un mécanisme pour « transformer Claude en GPT-5.6 ».
Il s'agit d'une configuration à double cerveau où Claude Code reste le centre de commandement et GPT-5.6 Sol est connecté comme second moteur de réflexion.
Claude gère les conversations utilisateur, l'exploration du dépôt, les petites modifications et le suivi des schémas existants.
GPT-5.6 Sol gère les décisions de conception complexes, les bugs non résolus, les revues adversariales, les changements couvrant plusieurs composants, et les seconds avis avant la mise en production.
De plus, en plaçant des consignes opérationnelles en japonais comme Agent Skills, les deux modèles sont contraints de respecter les mêmes conditions d'achèvement, normes de vérification et périmètres de modification.
C'est la manière la plus réaliste de donner à Claude Code le « cerveau de ChatGPT 5.6 ».
Remarque : j'ai résumé la configuration et les techniques d'utilisation avancée dans un PDF.
Si vous le souhaitez, je l'ai mis à disposition ici 👇 !
https://x.com/MakeAI_CEO/status/2027682940847898770?s=20
Trois couches pour donner à Claude Code le cerveau de GPT-5.6
La première chose à distinguer est que copier une consigne et se connecter à un modèle réel sont deux choses différentes.
Écrire des instructions pour GPT-5.6 dans CLAUDE.md ne transforme pas le modèle Claude lui-même en GPT-5.6.
Ce qui change, c'est la façon dont le travail est effectué.
C'est ce qu'on appelle la Couche d'Action.
Ensuite, introduisez le plugin officiel OpenAI « Codex pour Claude Code ».
En utilisant ce plugin, vous pouvez déléguer des revues de code et des tâches d'implémentation à Codex depuis Claude Code via le Codex CLI et le serveur d'applications Codex installés dans votre environnement local.
C'est la Couche de Raisonnement/Exécution.
Enfin, introduisez le plugin « OpenAI Developers ».
Il inclut le Docs MCP, qui référence la documentation officielle d'OpenAI, et des Skills correspondant à l'API OpenAI, au SDK Agents, aux applications ChatGPT, aux paramètres de clé API et au dépannage.
C'est la Couche de Connaissance.
Superposez ces trois couches.
Couche d'Action :
Consignes opérationnelles en japonais et Agent Skills
Couche de Raisonnement/Exécution :
Plugin Codex pour Claude Code
Couche de Connaissance :
Plugin OpenAI Developers et Docs MCP officiel
En faisant cela, vous pouvez continuer à utiliser Claude Code pour les opérations quotidiennes et faire appel à GPT-5.6 Sol et aux documents OpenAI les plus récents uniquement en cas de besoin.
Installer d'abord le plugin officiel OpenAI Codex
Ce dont vous avez besoin pour l'installation : un compte ChatGPT ou une clé API OpenAI, Node.js 18.18 ou ultérieur, et le Codex CLI.
Ce plugin ne transfère pas le code vers un service non officiel.
Il utilise le Codex CLI sur votre machine et hérite de l'authentification, des paramètres, des dépôts et des environnements locaux de Codex existants. Si vous êtes déjà connecté à Codex, vous pouvez utiliser cet état d'authentification tel quel.
D'abord, installez ou mettez à jour le Codex CLI.
npm install -g @openai/codex@latest
codex --version
codex login
Pour utiliser GPT-5.6 avec Codex, Codex CLI 0.144.0 ou ultérieur est requis.
codex --version
Si la version affichée est ancienne, réinstallez la dernière version.
Ensuite, démarrez Claude Code et exécutez dans l'ordre :
/plugin marketplace add openai/codex-plugin-cc
/plugin install codex@openai-codex
/reload-plugins
/codex:setup
/codex:setup vérifie si le Codex CLI est disponible et si l'authentification est terminée.
Si Codex n'est pas installé et que npm est disponible, il peut suggérer l'installation lors de la configuration.
Lors du premier essai, une revue en lecture seule est sans risque.
/codex:review --background
/codex:status
/codex:result
/codex:review passe en revue les différences non commitées actuelles.
Si vous voulez qu'il vérifie les différences par rapport à la branche main, faites ceci :
/codex:review --base main --background
Cette commande est en lecture seule et ne modifie pas le code.
Les tâches lancées en arrière-plan peuvent être vérifiées avec les commandes suivantes :
/codex:status
/codex:result
Pour arrêter un processus en cours, faites ceci :
/codex:cancel
Distinguer les revues normales et adversariales
Le plugin Codex dispose d'une option de revue adversariale distincte des revues normales.
/codex:adversarial-review --base main
Les revues normales recherchent les bugs, le manque de tests, la gestion des erreurs et les problèmes de typage dans le code.
En revanche, les revues adversariales remettent en question la politique d'implémentation elle-même.
Par exemple, après avoir implémenté l'authentification, vous pouvez demander :
/codex:adversarial-review --base main Considérez si la politique actuelle elle-même est erronée du point de vue des limites d'autorisation, de l'escalade de privilèges, de la fixation de session, de la fuite de tokens et du manque de journaux d'audit.
Pour le traitement de la facturation, faites ceci :
/codex:adversarial-review --base main Concentrez-vous sur la remise en cause de la possibilité de double facturation, de webhooks en double, de nouvelles tentatives après timeout, d'échecs partiels, de limites de transaction et d'impossibilité de rollback.
Si une revue normale vérifie « s'il y a des bugs dans cette implémentation », une revue adversariale vérifie « si cette implémentation aurait dû être choisie en premier lieu ».
Les deux sont en lecture seule et ne réécrivent pas le code sans permission.
La force de cette configuration est la capacité de séparer le modèle qui crée l'implémentation du modèle qui remet en question les prémisses de l'implémentation.
Le plugin officiel fournit des commandes pour les revues normales, les revues adversariales, le sauvetage, le transfert de session, et la vérification/arrêt des processus en arrière-plan.
Confier les tâches bloquées à Codex avec Rescue
Les tests ne passent pas même après plusieurs corrections dans Claude Code.
La cause s'étend sur plusieurs composants.
Il échoue uniquement en CI.
La concurrence ou la mise en cache est impliquée, et le symptôme est loin de la cause.
Dans de tels cas, utilisez /codex:rescue.
/codex:rescue Reproduisez le bug, identifiez la cause racine, et créez le correctif minimal sûr et le test de régression.
Vous pouvez également spécifier le modèle et le niveau de raisonnement.
/codex:rescue --model gpt-5.6-sol --effort high Reproduisez le bug, identifiez la cause racine, implémentez le correctif minimal sûr et exécutez les tests associés.
Envoyez les processus longs en arrière-plan.
/codex:rescue --background --model gpt-5.6-sol --effort high Enquêtez sur les échecs de test survenant uniquement en CI.
Les résultats sont récupérés avec les commandes suivantes :
/codex:status
/codex:result
Pour continuer la tâche Codex précédente, vous pouvez utiliser --resume.
/codex:rescue --resume Implémentez et vérifiez le plan le plus sûr parmi les correctifs proposés précédemment.
Pour démarrer une nouvelle enquête distincte de la précédente, utilisez --fresh.
/codex:rescue --fresh Enquêtez sur la cause racine à partir d'une hypothèse différente.
Pour transférer toute la conversation de Claude Code à Codex, utilisez la commande suivante :
/codex:transfer
Après exécution, une commande pour reprendre du côté de Codex s'affichera.
codex resume <session-id>
Cela permet un transfert où « l'enquête a commencé dans Claude Code, mais Codex devient le responsable principal en cours de route ».
Faire de GPT-5.6 Sol le modèle par défaut
Si vous souhaitez fixer le modèle Codex par projet, placez .codex/config.toml à la racine du dépôt.
model = "gpt-5.6-sol"
model_reasoning_effort = "high"
review_model = "gpt-5.6-sol"
Pour en faire un paramètre commun pour tous les projets personnels, placez-le ici :
~/.codex/config.toml
Les paramètres spécifiques au projet vont ici :
votre-projet/.codex/config.toml
Les paramètres du projet sont chargés si le dépôt est traité comme fiable.
Dans le travail quotidien, il n'est pas nécessaire d'utiliser le niveau de raisonnement maximal dès le début.
À titre indicatif, divisez comme suit :
low :
Corrections de mots, changements de noms, petites modifications claires
medium :
Ajouts de fonctionnalités normaux, implémentations suivant les schémas existants
high :
Changements couvrant plusieurs fichiers, débogage difficile, décisions de conception
xhigh :
Revues de sécurité, migrations à grande échelle, conditions de concurrence complexes, longues enquêtes
Dans Codex, vous pouvez sélectionner GPT-5.6 Sol, Terra ou Luna.
Sol convient pour un travail complexe et très flexible, Terra pour l'implémentation quotidienne, et Luna pour un travail clair et répétitif.
De plus, Max et Ultra sont disponibles séparément du niveau de raisonnement normal.
Max donne plus de temps de raisonnement à une seule tâche.
Ultra utilise des sous-agents pour traiter les travaux divisibles en parallèle.
Cependant, Max et Ultra ne sont pas nécessaires pour la plupart des tâches. Il est préférable de commencer avec Medium ou High et de n'augmenter que si une différence apparaît dans l'évaluation réelle.
« GPT-5.6 Sol High » et « GPT-5.6 Sol Pro » ne sont pas la même chose
C'est facile à confondre.
Dans ChatGPT, GPT-5.6 Sol est utilisé pour Medium, High et Extra High.
En revanche, GPT-5.6 Sol Pro est utilisé pour Pro.
Par conséquent, spécifier simplement ceci dans le plugin Codex :
--model gpt-5.6-sol --effort high
Ne signifie pas « GPT-5.6 Sol Pro a été utilisé ».
Cela signifie que GPT-5.6 Sol a été exécuté avec un niveau de raisonnement High.
Dans l'API Responses d'OpenAI, vous pouvez choisir standard ou pro comme reasoning.mode pour GPT-5.6.
Pour utiliser le mode Pro, la requête ressemblerait à ceci :
{
"model": "gpt-5.6",
"reasoning": {
"mode": "pro",
"effort": "high"
},
"input": "Examinez ce plan de migration de base de données et identifiez les schémas d'échec, les méthodes de récupération et les conditions qui rendent le rollback impossible."
}
reasoning.mode et reasoning.effort sont des paramètres différents.
reasoning.mode :
standard ou pro
reasoning.effort :
low, medium, high, xhigh, etc.
Le mode Pro effectue plus de traitement de modèle que le mode standard, augmentant la latence et l'utilisation de tokens.
Si vous souhaitez appeler strictement le mode Pro de cette API depuis Claude Code, la configuration impliquerait de préparer un script local ou un serveur MCP encapsulant l'API Responses et de l'appeler depuis un Skill Claude Code.
Cependant, pour un travail de codage normal, vous devriez d'abord essayer le niveau Medium ou High de GPT-5.6 Sol avec le plugin Codex officiel.
Ensuite, ne mettez à niveau que les tâches pour lesquelles l'effet du mode Pro est confirmé par les résultats d'évaluation réels.
Vous n'avez pas besoin d'envoyer tous les processus en Pro simplement parce que le nom contient « Pro ».
Le « System Prompt » pour ChatGPT 5.6 Sol Pro n'est pas public
Soyez prudent ici.
La version complète du system prompt interne utilisé par OpenAI dans ChatGPT ou GPT-5.6 Sol Pro n'est pas publique.
Par conséquent, vous ne devez pas croire et introduire des textes d'origine inconnue trouvés sur Internet, tels que « system prompt GPT-5.6 divulgué », « version de reproduction complète » ou « texte intégral du prompt interne ».
Ce que vous devez utiliser, c'est un prompt opérationnel créé pour s'adapter à votre environnement de développement tout en vous référant aux guides officiels de prompts.
Les guides officiels pour GPT-5.6 recommandent de spécifier les éléments suivants dans le prompt :
- Résultat final à atteindre
- Contraintes importantes
- Preuves disponibles
- Critères pour juger de l'achèvement
En revanche, évitez de fixer excessivement l'ordre de recherche, la sélection d'outils et les étapes de réflexion détaillées, laissant au modèle la possibilité de choisir des chemins efficaces.
Il est également expliqué que l'élagage des instructions redondantes, des exemples inutiles et des descriptions d'outils sans signification pour alléger le system prompt peut conduire à des améliorations des performances et de l'efficacité des tokens.
Voici un prompt opérationnel en japonais conçu pour être utilisé en commun avec Claude Code, Codex et GPT-5.6 Sol.
Ceci n'est pas une reproduction d'un prompt interne d'OpenAI.
Prompt opérationnel en japonais pour Claude Code et GPT-5.6 Sol
Rôle
Vous êtes un orchestrateur exécutif senior dans ce dépôt.
Votre objectif est de fournir des modifications minimales correctes, maintenables et vérifiées qui satisfont les résultats que l'utilisateur recherche réellement.
Écrire beaucoup de texte, augmenter le nombre de fichiers modifiés ou utiliser de nombreux outils ne sont pas des objectifs d'évaluation.
Vous êtes évalué sur la précision, les preuves, la modération du périmètre de modification et les résultats vérifiables.
Contrat Opérationnel
1. Clarifier les Résultats
Avant de commencer les modifications, identifiez ce qui suit :
- Résultat final visible pour l'utilisateur
- Zones du dépôt concernées
- Contraintes à respecter
- Ce qui ne sera pas fait cette fois
- Critères pour juger de l'achèvement
- Méthodes de vérification pouvant prouver l'achèvement
Résolvez les points ambigus à partir des preuves dans le dépôt d'abord.
Ne posez des questions à l'utilisateur que si les jugements manquants modifient significativement le comportement du produit, la sécurité, les coûts, les données ou les opérations irréversibles.
Ne posez pas de questions simplement pour éviter d'explorer le dépôt.
2. Enquêter Avant de Modifier
Lisez la plage minimale nécessaire et suffisante de fichiers.
Enquêtez sur les éléments suivants :
- Schémas d'implémentation existants
- Tests
- Interfaces
- Migrations
- Conventions de nommage
- Conventions de conception
- Gestion des erreurs
- Limites d'authentification et d'autorisation
Priorisez les preuves dans le dépôt par rapport aux spéculations ou aux valeurs par défaut du framework.
Dans les corrections de bugs, établissez des échecs reproductibles ou des preuves spécifiques soutenant la cause avant de proposer des correctifs.
Ne réécrivez pas les mécanismes existants avant de comprendre pourquoi ils existent.
3. Planifier à la Profondeur Appropriée
Si le changement est petit, local et facile à annuler, procédez au travail.
Si l'un des cas suivants s'applique, montrez un plan concis avant l'implémentation :
- Couvre plusieurs fichiers
- Modifie l'architecture
- Concerne la sécurité
- Réécrit des données
- Modifie des interfaces publiques
- Difficile à annuler
- Concerne la facturation, l'authentification, les autorisations ou les informations personnelles
- Concerne la concurrence ou le traitement asynchrone
Incluez ce qui suit dans le plan :
- Comportement prévu à réaliser
- Fichiers ou composants susceptibles d'être modifiés
- Invariants à maintenir
- Principaux risques
- Procédures de vérification
- Méthodes de rollback ou de récupération si nécessaire
N'augmentez pas les procédures formelles qui ne réduisent pas le risque.
4. Allouer le Travail au Moteur Optimal
Utilisez la session Claude Code actuelle pour les tâches suivantes :
- Exploration rapide du dépôt
- Interaction avec l'utilisateur
- Modifications à petite échelle avec un périmètre clair
- Décomposition des tâches et gestion de la progression
- Implémentation suivant les schémas existants
- Révision et intégration des retours de Codex
Envisagez une délégation à Codex ou une revue indépendante si un ou plusieurs des cas suivants s'appliquent :
- Le travail est bloqué malgré une enquête fondée ou des tentatives de correction
- Les changements couvrent plusieurs composants en interaction
- Il y a de la valeur dans un plan d'implémentation indépendant alternatif
- Une revue dans une perspective adversariale est efficace
- Les risques concernant la précision, la sécurité, la concurrence, la migration ou le rollback sont élevés
- L'utilisateur demande explicitement l'utilisation de GPT-5.6 Sol
- Il est nécessaire de remettre en question la politique d'implémentation actuelle avant la mise en production
Si l'incertitude peut être résolue par une simple revue, utilisez les revues Codex en lecture seule avant d'effectuer une délégation avec écriture.
Ne prétendez pas avoir utilisé GPT-5.6 Sol Pro sauf si vous utilisez le mode Pro documenté dans une requête réelle.
Rapportez précisément l'ID du modèle, le niveau de raisonnement et le mode de raisonnement utilisés.
5. Implémenter avec un Périmètre de Modification Restreint
Sauf si une refonte est explicitement demandée, suivez l'architecture existante, les conventions de nommage et les pratiques du dépôt.
Évitez ce qui suit :
- Refactoring non lié
- Abstraction excessive prédisant le futur
- Ajout de dépendances inutiles
- Modifications de formatage sans signification
- Réécritures extensives
- Modification du comportement public en dehors du périmètre demandé
- Suppression de tests existants sans raison
- Avaler des exceptions juste pour cacher des problèmes
Maintenez la rétrocompatibilité sauf si les changements cassants sont une exigence explicite.
Ne divulguez pas de secrets, identifiants, clés privées, tokens, données clients ou informations personnelles.
N'enregistrez pas de secrets dans les emplacements suivants :
- CLAUDE.md
- AGENTS.md
- SKILL.md
- Fichiers source
- Journaux
- Fixtures de test
- Rapports générés
- Messages de commit
6. Vérifier par des Preuves
Exécutez la vérification la plus pertinente pour les modifications dans la plage disponible.
En règle générale, priorisez l'ordre suivant :
- Tests ciblés
- Vérifications de type
- Vérifications de lint et de format
- Build
- Tests d'intégration
- Confirmation runtime ou visuelle
N'exécutez que des vérifications proportionnées aux modifications.
Cependant, n'omettez pas les vérifications nécessaires juste pour finir rapidement.
Pour les modifications UI, vérifiez l'écran de travail réel si possible.
Pour les corrections de bugs, ajoutez ou mettez à jour les tests de régression si réalistement possible.
Pour les migrations ou les opérations destructrices, vérifiez ce qui suit :
- Traitement en avant réussi
- Gestion en cas d'échec
- Rollback ou récupération
- Comportement en cas d'exécution partielle
- Comportement lors des nouvelles tentatives
- Comportement en cas de double exécution
N'utilisez pas d'expressions comme « corrigé », « fonctionne », « sûr » ou « terminé » sans montrer de preuves.
Si la vérification ne peut pas être exécutée, indiquez précisément la raison et ce qui reste non vérifié.
Ne fabriquez pas de tests échoués en les faisant passer pour réussis.
7. Vérifier les Différences Finales
Avant de terminer le travail, effectuez les vérifications suivantes :
- Vérifier les différences finales
- Rechercher les modifications non intentionnelles
- Vérifier la gestion des erreurs et les conditions limites
- Vérifier les limites de sécurité et le traitement des autorisations
- Vérifier la concurrence et le comportement de nouvelle tentative si nécessaire
- Vérifier les tests manquants
- Comparer les résultats finaux avec les objectifs de résultat initiaux
- Vérifier si le contenu décidé comme non fait cette fois a été accidentellement implémenté
Pour les changements à haut risque, demandez une revue Codex indépendante.
Traitez tous les points de revue importants avec l'une des options suivantes :
- Les corriger
- Les rejeter en montrant des preuves dans le dépôt
- Les documenter clairement comme hors de portée pour cette fois
- Les enregistrer comme non vérifiés par manque d'environnement
N'adoptez pas les modifications inconditionnellement simplement parce que Codex les a signalées.
Vérifiez les points avec le code, les spécifications, les tests et les résultats d'exécution.
8. Terminer au Point Approprié
Terminez le travail une fois que les critères d'achèvement sont remplis.
Ne continuez pas le polissage inutile au-delà du périmètre demandé.
N'ajoutez pas de TODO non liés ou de plans de refonte pour donner l'impression que le travail est plus important.
La réponse finale doit inclure ce qui suit :
- Résultats fournis
- Principales modifications
- Vérifications exécutées et résultats
- Risques restants, hypothèses ou blocages
- Opérations spécifiques à effectuer ensuite uniquement si vraiment nécessaire
Le but de ce prompt n'est pas de faire du modèle une « persona d'ingénieur génie ».
Il est de clarifier les résultats, les preuves, le périmètre de modification, les conditions de délégation, la vérification et les conditions d'arrêt.
Il est plus facile d'opérer en définissant ce qui constitue un achèvement plutôt que d'écrire une grande quantité de commandes abstraites comme « réfléchissez en profondeur » ou « agissez comme le meilleur ingénieur du monde ».
Placer les Prompts Longs dans les Skills, pas dans CLAUDE.md
Vous pouvez écrire le prompt précédent directement dans CLAUDE.md.
Cependant, placer des textes longs qui ne sont pas toujours nécessaires dans CLAUDE.md consomme du contexte dans chaque session.
Un endroit plus approprié est un Agent Skill.
Les Skills Claude Code reconnaissent d'abord le nom et la description et ne chargent le corps de SKILL.md que lorsque cela est nécessaire.
Les Skills Codex adoptent de même un mécanisme pour regrouper les instructions, les documents de référence, les scripts, les templates, etc., dans un seul répertoire et ne les charger que lorsque cela est nécessaire.
Comme les deux utilisent le format Agent Skills, il est facile de partager des prompts et des procédures de base.
Dans Claude Code, enregistrez-le à l'emplacement suivant :
.claude/
└── skills/
└── sol-pro-orchestrator/
└── SKILL.md
Le début de SKILL.md devrait ressembler à ceci :
name: sol-pro-orchestrator
description: >
Utiliser pour les changements complexes, les changements couvrant plusieurs fichiers, les changements à haut risque,
lorsque le travail est bloqué, ou pour un travail important avant la mise en production.
Appliquer lorsqu'une planification claire, une vérification et une revue ou délégation Codex indépendante sont nécessaires.
Sol Pro Orchestrator
[Placez ici le prompt opérationnel en japonais]
Pour l'appeler explicitement, faites ceci :
/sol-pro-orchestrator Ajoutez le traitement de facturation. Maintenez la conception d'idempotence existante et créez des tests de régression jusqu'à la double facturation.
Si la description du Skill correspond à la demande, Claude peut le charger automatiquement.
Si vous ne souhaitez pas qu'il démarre automatiquement, ajoutez ce qui suit au frontmatter :
disable-model-invocation: true
Dans ce cas, le Skill n'est utilisé que lorsque l'utilisateur exécute explicitement la commande slash.
Il est préférable de ne laisser que des règles courtes toujours nécessaires dans CLAUDE.md et de séparer les procédures de travail complexes dans les Skills.
Par exemple, CLAUDE.md suffit avec quelque chose comme ceci :
Règles du Dépôt
- Suivez l'architecture existante et les conventions de nommage.
- Priorisez les modifications minimales qui peuvent maintenir la sécurité.
- Exécutez les tests pertinents avant de terminer.
- Ne modifiez pas les fichiers non liés.
- Utilisez le Skill sol-pro-orchestrator pour les travaux complexes, bloqués, à haut risque ou importants avant la mise en production.
Ajouter les Skills Officiels OpenAI à Claude Code
Pouvoir appeler GPT-5.6 Sol ne suffit pas.
Si le modèle répond à propos de l'API OpenAI ou du SDK Agents en se basant uniquement sur des souvenirs datant de l'entraînement, il peut utiliser des API anciennes, des paramètres obsolètes ou des implémentations qui ne sont plus recommandées.
C'est là qu'intervient le plugin « OpenAI Developers ».
Exécutez ce qui suit dans Claude Code :
/plugin marketplace add openai/openai-developers-for-claude
/plugin install openai-developers@openai-developers
Après l'installation, démarrez une nouvelle session Claude Code.
Ce plugin inclut le Docs MCP officiel d'OpenAI et les Skills suivants :
openai-docs :
Achemine les questions sur les produits, API, modèles et SDK OpenAI vers la documentation officielle.
Utilisé pour vérifier les informations qui changent facilement, comme les nouveaux noms de modèles, les paramètres API actuels, l'utilisation du SDK et les paramètres Codex.
openai-platform-api-key :
Guide les paramètres OPENAI_API_KEY dans l'environnement local.
Ce Skill est destiné à être connecté comme variable d'environnement plutôt que de coller des clés API dans le code source ou les prompts.
openai-api-troubleshooting :
Classe les erreurs API OpenAI.
Vérifie l'authentification, les autorisations, la spécification du modèle, les limites de débit, le réseau, le format de la requête, etc., et mène à l'action suivante à entreprendre.
agents-sdk :
Prend en charge la conception, l'implémentation, l'exécution et l'évaluation des applications utilisant le SDK Agents OpenAI.
build-chatgpt-app :
Conçoit et implémente des projets utilisant le SDK ChatGPT Apps.
Utilisé pour le développement d'applications incluant les serveurs MCP, l'interface utilisateur des widgets et l'intégration avec ChatGPT.
chatgpt-app-submission :
Prépare les soumissions d'applications ChatGPT, les informations de description, les cas de test, etc.
Ce plugin est un dépôt officiel publié par OpenAI pour Claude Code.
C'est un ensemble du Docs MCP public d'OpenAI et des Skills de développement adaptés pour Claude Code.
Ici, ne confondez pas les deux plugins.
codex-plugin-cc :
Pont d'exécution pour déléguer les revues et l'implémentation à Codex.
openai-developers-for-claude :
Package de connaissances qui ajoute les informations officielles d'OpenAI et les procédures de développement à Claude Code.
En ajoutant les deux, Claude Code devient un environnement où non seulement il « fait réfléchir Codex » mais aussi « implémente tout en vérifiant les spécifications officielles d'OpenAI ».
Comment Répartir les Tâches Entre Claude et Codex en Pratique
Il n'est pas nécessaire de confier tous les travaux aux deux modèles en même temps.
Répartissez les rôles.
Confiez à Claude Code les tâches suivantes :
- Exploration du dépôt
- Interaction avec l'utilisateur
- Compréhension des implémentations existantes
- Modifications mineures
- Implémentation suivant les motifs connus
- Retranscription des points de Codex dans le code
Confiez à GPT-5.6 Sol les tâches suivantes :
- Décisions de conception complexes
- Bugs bloquants
- Investigations couvrant plusieurs composants
- Revues adversaires
- Vérification des limites de sécurité
- Investigation des problèmes de concurrence et de course
- Vérification des migrations et des rollbacks
- Revues indépendantes avant mise en production
Par exemple, lors de l'ajout d'un nouveau processus de facturation, le déroulement serait :
- Investiguer les flux de facturation existants, les tests et la conception d'idempotence dans Claude Code.
- Fixer le plan et les conditions d'achèvement avec la compétence sol-pro-orchestrator.
- Claude crée l'implémentation minimale et les tests de régression.
- Douter de la politique de conception avec une revue adverse Codex.
- Claude vérifie les points avec le code et les tests.
- Ne refléter que les correctifs nécessaires.
- Vérifier les diffs finales avec une revue Codex normale.
D'abord, appelez la compétence.
/sol-pro-orchestrator Ajouter le traitement de facturation. Investiguer la conception existante et inclure l'idempotence, les webhooks en double et les tests de régression dans les conditions d'achèvement.
Après l'implémentation, effectuez une revue adverse.
/codex:adversarial-review --base main Se concentrer sur la remise en question de la possibilité de double facturation, de webhooks en double, de nouvelles tentatives après expiration du délai, d'échecs partiels, de limites de transaction et d'impossibilité de rollback.
Après correction, effectuez une revue normale.
/codex:review --base main --background
/codex:status
/codex:result
Le but de cette méthode n'est pas de décider lequel de Claude ou GPT est le plus fort.
Il s'agit de séparer le rôle de création de l'implémentation du rôle de remise en cause des prémisses de l'implémentation.
Si vous demandez au même modèle de « mettre en œuvre puis de s'auto-évaluer strictement », il est probable qu'il évalue sur la base de la conception qu'il a initialement adoptée.
En faisant intervenir un modèle d'un système différent en tant que critique, vous pouvez apporter différents chemins d'exploration et hypothèses d'échec.
Ce n'est pas une compétition entre modèles, mais une séparation des tâches dans le développement logiciel.
N'envoyez pas tout à Sol High
Envoyer des modifications de noms de fichiers, des corrections de texte d'affichage et des erreurs de type simples à GPT-5.6 Sol High gaspille les limites d'utilisation et le temps.
Considérez l'utilisation des modèles comme suit :
Claude Code :
Interaction, exploration, petites corrections, travail d'intégration
GPT-5.6 Luna :
Conversions claires et à grande échelle, classification, travail routinier
GPT-5.6 Terra :
Implémentation quotidienne, débogage normal
GPT-5.6 Sol Medium :
Implémentation impliquant un certain niveau de planification ou de jugement
GPT-5.6 Sol High :
Conception difficile, bugs complexes, revues importantes
GPT-5.6 Sol xhigh, Max, Pro, Ultra :
Tâches les plus difficiles pour lesquelles des effets supplémentaires sont confirmés par évaluation
Au lieu d'utiliser toujours des modèles haute performance, concentrez-les sur les travaux où la perte en cas d'échec est importante.
Cela facilite également le contrôle des résultats ainsi que des coûts.
Ne laissez pas les portes de revue toujours activées
Le plugin officiel Codex dispose d'une porte de revue qui exécute automatiquement une revue Codex lorsque Claude tente de terminer un travail.
La commande pour l'activer est la suivante :
/codex:setup --enable-review-gate
Pour la désactiver, utilisez :
/codex:setup --disable-review-gate
Si un problème est trouvé lors de la revue, vous pouvez empêcher Claude de terminer et revenir à la correction.
C'est puissant, mais de longues boucles entre Claude et Codex peuvent se produire, consommant rapidement les limites d'utilisation.
Par conséquent, il est préférable de le limiter à des situations telles que :
- Candidates à la publication
- Modifications de l'authentification/autorisation
- Traitement de la facturation
- Migration de données à grande échelle
- Limites de sécurité
- Modifications difficiles à annuler
Pour les petites tâches quotidiennes, il est plus facile de les gérer en exécutant des revues manuelles aux moments nécessaires.
Le README officiel avertit également que les portes de revue peuvent créer de longues boucles Claude/Codex et consommer les limites d'utilisation, elles ne doivent donc être activées que lorsqu'elles peuvent être surveillées.
N'adoptez pas les points de Codex sans condition
GPT-5.6 Sol est puissant, mais pas toujours correct.
Il peut supposer des spécifications inexistantes, négliger des circonstances propres au dépôt, ou proposer des modifications de conception excessives.
Traitez les points de revue avec l'une des options suivantes :
Adopté :
Confirmation de la base et réalisation de la correction et de la vérification.
Rejeté :
Non adopté en apportant des preuves du dépôt, des spécifications ou des tests.
Reporté :
Point valide mais créé une tâche séparée comme hors du périmètre pour cette fois.
Non vérifié :
Impossible de confirmer en raison du manque d'environnement ou d'autorisations.
Vous ne modifiez pas les choses « parce que Codex l'a dit ».
« Confirmer l'hypothèse d'échec présentée par Codex avec du code et des tests » est correct.
La valeur d'une configuration à double cerveau ne réside pas dans la croyance inconditionnelle aux réponses, mais dans l'augmentation des autres possibilités qui doivent être vérifiées.
Ligne de sécurité minimale
Claude Code et Codex lisent tous deux les dépôts, exécutent des commandes et réécrivent des fichiers selon les paramètres.
Lors de la connexion de deux agents, vous devez décider des limites d'autorisation avant de privilégier la commodité.
Commencez par des revues en lecture seule d'abord.
/codex:review
/codex:adversarial-review
Utilisez le sauvetage impliquant l'écriture après avoir confirmé le dépôt cible et le contenu du travail.
Ne collez pas .env, les clés privées, les données clients ou les jetons d'accès dans CLAUDE.md, AGENTS.md ou SKILL.md.
Définissez la clé API OpenAI en tant que variable d'environnement.
export OPENAI_API_KEY="..."
En pratique, utilisez les profils shell, les services de gestion de secrets, les fonctions Secret CI, etc.
De plus, ne supposez pas que les paramètres d'autorisation de Claude Code et les paramètres de sandbox/approbation de Codex sont identiques.
Vérifiez la portée de l'accès réseau, de l'écriture de fichiers et de l'exécution de commandes à la fois du côté Claude et du côté Codex.
Lors de l'ajout de MCP externes, vérifiez le fournisseur et les autorisations, et autorisez uniquement les outils nécessaires.
Structure de répertoire terminée
Le dépôt final ressemblera à ceci :
votre-projet/
├── CLAUDE.md
├── AGENTS.md
├── .claude/
│ └── skills/
│ └── sol-pro-orchestrator/
│ └── SKILL.md
├── .codex/
│ └── config.toml
├── src/
├── tests/
└── package.json
Les rôles de chacun sont clairement divisés.
CLAUDE.md :
Écrivez des règles de dépôt courtes que Claude Code suit toujours.
- Suivez l'architecture existante
- Ne modifiez pas les fichiers sans rapport
- Priorisez les modifications minimales et sûres
- Exécutez les tests pertinents
AGENTS.md :
Écrivez les informations du projet dont Codex a besoin.
- Structure du dépôt
- Comment démarrer l'environnement de développement
- Commandes de construction
- Commandes de test
- Contraintes de conception
- Conditions d'achèvement
.claude/skills/sol-pro-orchestrator/SKILL.md :
Écrivez des invites opérationnelles en japonais à charger uniquement pour les travaux complexes.
.codex/config.toml :
Écrivez le modèle et la force de raisonnement utilisés dans Codex.
model = "gpt-5.6-sol"
model_reasoning_effort = "high"
review_model = "gpt-5.6-sol"
Et ajoutez les deux plugins officiels à Claude Code :
openai/codex-plugin-cc
openai/openai-developers-for-claude
Maintenant, Claude Code a les rôles suivants :
- Implémentation quotidienne et interaction par Claude
- Revue indépendante et sauvetage par GPT-5.6 Sol
- Vérification des dernières spécifications par le MCP officiel OpenAI Docs
- Processus de développement réutilisable par les compétences d'agent
Résumé : N'abandonnez pas Claude Code, ajoutez un deuxième cerveau
La période d'utilisation de Fable 5 sans frais supplémentaires a été prolongée jusqu'au 19 juillet 2026.
Par conséquent, nous ne sommes pas dans un état où « Fable s'est terminé aujourd'hui ».
Cependant, la tendance selon laquelle il n'est plus naturel de pouvoir continuer à utiliser les modèles les plus performants dans le cadre d'un abonnement mensuel reste inchangée.
Cela ne signifie pas que vous devez abandonner Claude Code.
Gardez Claude Code comme centre de commandement.
Utilisez le plugin officiel OpenAI codex-plugin-cc pour appeler GPT-5.6 Sol pour les revues, le sauvetage et l'implémentation.
Ajoutez le plugin OpenAI Developers pour utiliser le MCP officiel Docs et les compétences de développement OpenAI.
Faites des invites opérationnelles courantes des compétences d'agent qui ne sont chargées qu'en cas de besoin, plutôt que de les fourrer dans CLAUDE.md comme des instructions résidentes énormes.
Et séparez le « modèle qui a fait l'implémentation » du « modèle qui doute de cette implémentation ».
Avec cette configuration, vous pouvez insérer le raisonnement GPT-5.6 là où nécessaire sans abandonner la sensation opérationnelle, les paramètres existants, les compétences, les MCP et les actifs du projet de Claude Code.
Vous ne transformez pas Claude en GPT.
Vous logez un autre ingénieur senior dans Claude Code que vous pouvez consulter à tout moment.
Plutôt que de dépendre d'un seul modèle pour tout le travail, utilisez les modèles en fonction du contenu du travail.
Habituellement, avancez rapidement avec Claude Code.
Dans les endroits difficiles, demandez du secours à GPT-5.6 Sol.
Avant la livraison, recevez une revue adverse d'un modèle différent.
Faites vérifier les dernières spécifications de l'API OpenAI par le MCP officiel Docs.
Claude Code désormais n'est pas un outil de codage qui se termine dans un seul modèle.
La bonne façon est de l'utiliser comme un système d'exploitation de développement qui regroupe plusieurs modèles, compétences, MCP et plugins.
