Maîtriser Codex en 2026 : Le guide complet pour les développeurs

J'ai utilisé Claude Code pendant 12 mois. Puis je suis passé à Codex pendant 30 jours.

Voici ce que j'ai découvert

Ce qu'est réellement Codex en 2026

La plupart des gens pensent encore que Codex est un simple autocomplétion intelligent. Ce n'est pas le cas.

Codex est une plateforme de développement logiciel entièrement agentique. Il lit votre codebase, écrit et teste du code, révise les pull requests, contrôle votre bureau Mac, navigue sur le web, génère des images, planifie des tâches récurrentes et mémorise vos préférences d'une session à l'autre.
Le changement mental nécessaire est important. Vous cessez d'être la personne qui écrit le code. Vous devenez celle qui révise le code écrit par une équipe de développeurs juniors qui ne dort jamais.

La plupart des développeurs installent Codex, envoient des prompts d'une ligne pendant deux semaines, obtiennent des résultats médiocres et abandonnent. Ils ne configurent jamais AGENTS.md.

Ils n'écrivent jamais de Skill (compétence). Ils n'utilisent jamais de sous-agents. Ils exploitent 5 % de la surface et jugent l'outil sur ces 5 %.

Ce cours couvre les 95 % restants.

Les cinq surfaces

Avant d'installer quoi que ce soit, comprenez où se trouve Codex. La surface que vous choisissez détermine à quel point vous suivez son travail et où le code s'exécute.

CLI (interface en ligne de commande) est adaptée aux workflows scriptés, aux tâches uniques et à l'automatisation sans tête. Votre code ne quitte jamais votre machine sauf si vous le poussez. Open source, écrit en Rust, fonctionne sur macOS, Windows et Linux.

Extension IDE (environnement de développement intégré) est destinée à l'édition interactive avec un contexte de fichiers précis. S'installe dans VS Code, Cursor, Windsurf ou JetBrains. Utilise l'authentification de votre CLI, sans connexion séparée.

Application de bureau est le foyer des workflows multi-threads, du navigateur intégré, de l'utilisation de l'ordinateur (Computer Use), du mode Objectif (Goal mode), des Appshots et des Automations. Lancée sur macOS en février 2026 et sur Windows le 4 mars 2026.

Cloud est destiné aux tâches asynchrones en arrière-plan, aux PR parallèles et au travail pendant votre sommeil. Les tâches s'exécutent dans des conteneurs isolés préchargés avec votre dépôt GitHub. Rien ne bloque votre machine locale.

Navigateur intégré et Computer Use sont destinés à la vérification d'interface utilisateur, à l'itération frontend et aux tests de bout en bout. Codex ouvre votre serveur de développement local, interagit avec lui, capture l'écran du résultat et vérifie que les modifications de code ont produit le rendu visuel correct.

Un workflow réel utilise plusieurs surfaces :

CLI pour les tâches scriptées
IDE pour le travail interactif sur les fonctionnalités
Cloud pour les tâches parallèles que vous n'avez pas besoin de surveiller
Application pour les tâches longues orientées objectif

Le principal facteur de choix d'une surface est la proximité avec laquelle vous souhaitez suivre le travail de l'agent. Si vous voulez surveiller les modifications au fur et à mesure, la CLI ou l'IDE gardent le travail sur votre machine et sous vos yeux. Si vous préférez déléguer une session plus longue et réviser à la fin, Cloud est le bon choix.

Le modèle mental : agent, pas autocomplétion

Maintenant que les surfaces sont claires, le prochain changement est de comprendre l'unité de travail.

L'unité de travail est une tâche, pas un échange. Le résultat est une PR, pas une réponse de chat.

Pensez moins « écris une fonction qui fait X » et plus « implémente la fonctionnalité Y, voici les contraintes, exécute les tests quand c'est fait. »

Chaque tâche Codex suit la même boucle interne. Codex lit votre tâche et le contexte, produit un plan interne, exécute étape par étape et vérifie son propre travail.

Arrêtez de considérer Codex comme un assistant de codage. Commencez à le voir comme une équipe de développeurs juniors que vous briefez le matin et que vous révisez l'après-midi.

Un exemple concret de cette pratique : les développeurs chez WorkOS mettent désormais en file d'attente quatre à cinq tâches Codex avant d'aller chercher leur café du matin. Au moment où ils se rassoient, deux à trois PR terminées les attendent pour révision, prenant en charge le travail de maintenance qui leur prenait auparavant 30 à 40 % de leur journée.

Les modèles actuels en mai 2026 :

GPT-5.5 (par défaut) — gère la plupart des tâches, même latence qu'avant mais nettement moins de tokens pour le même travail
GPT-5.3-Codex — conçu spécifiquement pour les longues exécutions autonomes, les gros refactorings et le déploiement parallèle dans le cloud ; 25 % plus rapide que le précédent spécialiste Codex
GPT-5.5 Pro — le plus haut niveau de raisonnement ; réservé aux forfaits Pro, Business et Enterprise
Codex Mini — gratuit en permanence sur ChatGPT Free ; adapté pour l'apprentissage

Laissez Codex sur GPT-5.5 par défaut. Passez à GPT-5.3-Codex pour les grandes tâches agentiques où Codex fonctionne de manière autonome pendant longtemps.

Pour commencer : votre première vraie session

Le chemin le plus rapide vers une session Codex fonctionnelle suit cinq étapes. Oubliez le tutoriel fizzbuzz. Commencez sur une vraie codebase.

Étape 1 : Installez la CLI.

Étape 2 : Ouvrez un vrai projet.

Naviguez vers un dépôt à faible risque que vous connaissez déjà. C'est important.

Codex donne de meilleurs résultats lorsque vous pouvez reconnaître la sortie et repérer les erreurs. Une première session sur une codebase inconnue produit des résultats imprévisibles.

Connectez-vous avec votre compte ChatGPT lorsque vous y êtes invité. Votre navigateur s'ouvre automatiquement. Cliquez sur Continuer et revenez au terminal.

Étape 3 : Exécutez /init avant toute autre chose.

Cette seule commande est ce que la plupart des tutoriels omettent. Codex scanne votre répertoire et l'historique Git, identifie les langages, frameworks, commandes de build et de test, et génère un fichier AGENTS.md rempli avec ce qu'il trouve.

Relisez le fichier généré, ajustez ce qui ne va pas et committez-le. Chaque future session Codex sur ce projet le lira automatiquement.

Étape 4 : Donnez à Codex une tâche d'orientation.

Demandez-lui d'expliquer la codebase avant de lui donner quelque chose à modifier. Cela renforce votre confiance dans le contexte qu'il a chargé :

Lisez la sortie. Si elle décrit avec précision votre codebase réelle, il a le contexte nécessaire. Si elle est vague ou erronée, votre AGENTS.md a besoin de plus de détails.

Étape 5 : Donnez-lui une petite tâche réelle. Choisissez quelque chose de concret et bien délimité.

Voici la forme correcte d'un prompt Codex : contexte de fichier spécifique, résultat attendu, contraintes et une étape de vérification définie. Examinez le diff qu'il renvoie. Vous utilisez maintenant Codex correctement.

Étape 6 : Installez l'application de bureau. Téléchargez-la depuis le site web d'OpenAI. Connectez-vous avec le même compte ChatGPT.

Étape 7 : Installez l'extension IDE. Recherchez « OpenAI Codex » dans le panneau des extensions de votre éditeur. Elle lit automatiquement votre authentification CLI.

Étape 8 : Connectez GitHub. Allez dans Paramètres (Settings) dans l'application Codex et connectez votre compte GitHub. Liez au moins un dépôt avant d'utiliser les tâches cloud.

Où se trouvent les éléments :

~/.codex/config.toml : configuration principale : mode d'approbation, mode sandbox, serveurs MCP, modèles par défaut
~/.codex/AGENTS.md : AGENTS.md personnel, s'applique à tous les projets
<projet>/AGENTS.md : instructions au niveau du projet
<projet>/.agents/skills/ : Skills (compétences) au niveau du projet
<projet>/.codex/config.toml : configuration propre au projet (projets de confiance uniquement)

AGENTS.md : le fichier le plus important de votre dépôt

Maintenant que vous avez une session fonctionnelle, l'étape suivante est de faire en sorte que chaque future session démarre avec la même qualité. C'est ce que fait AGENTS.md.

AGENTS.md est le seul fichier qui sépare une sortie Codex médiocre d'une sortie cohérente et de haute qualité.
C'est un fichier Markdown simple à la racine de votre dépôt. Chaque fois qu'une session Codex démarre sur votre projet, l'agent le lit automatiquement avant toute autre action.
C'est un standard ouvert. Codex, Cursor, Gemini CLI, Windsurf et GitHub Copilot le lisent tous. Écrivez-le une fois et chaque agent de votre chaîne d'outils lit la même source de vérité.

Ordre de résolution : Codex lit ~/.codex/AGENTS.md (niveau personnel, tous les projets) plus <projet>/AGENTS.md (niveau projet). Les fichiers AGENTS.override.md ont priorité à chaque niveau. La limite combinée est de 32 Ko.

Ce qui doit figurer :

Stack, frameworks, versions de langage, gestionnaire de paquets
Commandes exactes de build, test et développement ; copiables-collables, pas « exécute les tests habituels »
Conventions de structure de fichiers et règles de nommage
Règles de style et de pattern
Zones interdites : ce qu'il ne faut pas toucher
Exigences de livraison : CI, conventions de PR, mécanisme de déploiement

Ce qui ne doit pas figurer :

Secrets ou identifiants (le fichier est dans le contrôle de version)
Conseils vagues (« écris du code propre » ne signifie rien pour un agent)
Documentation qui double votre README

Gardez-le sous 500 mots. Trop de contenu repousse les informations utiles hors de la mémoire de travail du modèle.

Un modèle fonctionnel :

Vérifiez que Codex le lit : demandez « résume les instructions actuelles que tu as chargées »
Pour les gros monorepos, placez des fichiers AGENTS.md supplémentaires dans les sous-répertoires.
Un fichier dans packages/api/AGENTS.md a priorité sur le fichier racine pour les tâches dans ce paquet.
Exécutez codex trust . pour activer un config.toml au niveau du projet. Cela empêche un dépôt cloné malveillant de configurer Codex à votre insu.

La CLI en profondeur

Avec AGENTS.md en place, la prochaine chose à maîtriser est la CLI elle-même. La plupart des utilisateurs ne tapent que codex et passent à côté des commandes qui la rendent vraiment puissante.

Il y a quatre commandes qui couvrent 95 % de l'utilisation quotidienne réelle.

codex ouvre le mode interactif pour l'exploration, l'itération et la conversation aller-retour avec votre codebase.

codex exec "<tâche>" exécute Codex de manière non interactive. Il envoie le flux vers stdout et se termine une fois fini. C'est l'outil de puissance pour tout ce qui peut être scripté :

Intégrez exec dans les hooks Git, les pipelines CI et les tâches cron. C'est l'élément de base de tout ce qui est automatisé.

codex resume --last reprend exactement là où vous vous êtes arrêté. Chaque session est stockée :

codex cloud gère les tâches cloud asynchrones, couvertes dans la section Cloud ci-dessous.

Drapeaux utiles :

--json : flux d'événements JSONL pour le piping vers d'autres outils
--model <nom> : sélectionne GPT-5.5 ou GPT-5.3-Codex
--reasoning <niveau> : low, medium ou high
--search : autorise la recherche web pendant la tâche
-C <rép> : exécute dans un répertoire de travail différent
--sandbox <mode> : remplace le mode sandbox pour cette session
--approval <politique> : remplace la politique d'approbation pour cette session

Sandbox et approbations

La CLI vous donne du pouvoir. Le sandbox contrôle la mesure dans laquelle Codex peut exercer ce pouvoir sans demander la permission. Bien le paramétrer maintient votre flux de travail rapide sans créer de risque.

Le sandbox est la limite qui contrôle ce que Codex peut et ne peut pas faire. Un réglage correct évite les surprises.

Les trois modes sandbox :

workspace-write (par défaut) : lecture et écriture dans l'espace de travail, commandes courantes, pas de réseau sauf autorisation. Utilisez ce mode presque toujours.
read-only : lecture seule, pas d'écriture, pas de shell. Utilisez pour la révision de code et l'exploration.
danger-full-access : aucune restriction. Utilisez presque jamais. Réservez aux automatismes testés et vérifiés.

Les deux politiques d'approbation :

untrusted — demande avant chaque commande non fiable. Utilisez quand vous apprenez ou dans un projet inconnu.
on-request (par défaut) — approuve automatiquement les commandes sandbox courantes, demande avant tout ce qui franchit la limite du sandbox.

auto_review est un sous-agent réviseur qui approuve ou rejette automatiquement en fonction de votre AGENTS.md.

Activez-le avec approvals_reviewer = "auto_review" dans la configuration. Fonctionne bien pour les longues tâches asynchrones et le mode Objectif où vous ne voulez pas surveiller chaque étape.

Ajoutez des commandes qui vous demandent constamment une approbation. N'ajoutez jamais rien de destructeur.

Prompter Codex efficacement

Sandbox configuré, sessions en cours. Le prochain levier est la qualité du prompt, qui a plus d'impact sur la sortie que toute autre variable.

Le plus grand levier sur la qualité de sortie de Codex est la structure du prompt. Des prompts vagues produisent du code vague.

Le cadre : Dire, Montrer, Décrire, Rappeler.

Dites-lui le résultat souhaité, pas la méthode
Montrez-lui des exemples d'entrées et les sorties attendues
Décrivez les API, bibliothèques et motifs à utiliser
Rappelez-lui les conventions d'AGENTS.md

Les quatre ne sont pas nécessaires à chaque fois. Une petite correction de bogue peut seulement nécessiter Dire et Rappeler. Une nouvelle fonctionnalité nécessite généralement les quatre.

La règle du changement unique : Codex fonctionne nettement mieux sur une chose que sur cinq. « Corrige le bogue d'authentification, ajoute des tests, refactorise le dépôt utilisateur et mets à jour le README » est un pari risqué. Le même travail divisé en quatre prompts est fiable.
Exigez d'abord un plan pour tout ce qui n'est pas trivial : « produis d'abord un plan, n'écris pas de code avant que j'approuve. » Trente secondes pour réviser un plan valent mieux que trente minutes à déboguer une mauvaise implémentation.
Spécifiez explicitement le comportement en cas d'échec. Livré à lui-même, Codex fera passer les tests par tous les moyens nécessaires :

Contraignez explicitement le contexte. Nommez les fichiers spécifiques à lire. « Ne lis ni ne modifie rien d'autre. Si tu as besoin d'informations ailleurs, demande-moi. »

Niveaux d'effort de raisonnement :

Low : modifications triviales, formatage, refactorings simples
Medium (par défaut) : la plupart des travaux sur les fonctionnalités et corrections de bogues
High : décisions architecturales, débogage difficile, gros refactorings multi-fichiers

Mode Objectif (Goal Mode)

Une fois que le prompt de tâche unique devient naturel, le niveau suivant est de donner à Codex un objectif de plusieurs jours et de le laisser séquencer le travail lui-même.

Le mode Objectif est destiné au travail trop vaste pour être briefé tâche par tâche, mais suffisamment cohérent pour un seul objectif. Il est devenu stable en mai 2026.

Gérez un Objectif en cours avec ces commandes :

codex goal status : voir les Objectifs actifs et leur progression
codex goal logs <id> : inspecter ce que Codex a fait jusqu'à présent
codex goal pause <id> : interrompre l'exécution et attendre votre entrée
codex goal resume <id> : continuer là où il s'est arrêté
codex goal cancel <id> : arrêter et abandonner l'Objectif

Commencez avec des Objectifs délimités. « Au plus 5 PR » jusqu'à ce que vous ayez confiance dans la manière dont Codex interprète vos objectifs. Un Objectif incontrôlé qui fait avec assurance la mauvaise chose est le pire des scénarios.

Limitez toujours avec : nombre max de PR, nombre max de lignes de code par PR, portes CI entre les PR, et conditions d'arrêt claires. Mettez en pause toute décision architecturale non couverte dans AGENTS.md. Mettez en pause tout changement d'API cassant.

Skills : workflows réutilisables

Le mode Objectif gère les grandes initiatives. Les Skills gèrent les micro-workflows récurrents qui apparaissent dans chaque projet. Si vous vous surprenez à répéter les mêmes instructions d'une session à l'autre, c'est le signal pour écrire un Skill.

Un Skill (compétence) est un workflow réutilisable empaqueté sous forme de répertoire : instructions dans un fichier SKILL.md, plus des ressources et scripts optionnels.

Codex découvre les Skills par nom et description. Il ne charge les instructions complètes que lorsqu'une tâche déclenche le Skill. Vous pouvez avoir 50 Skills avec un coût de contexte nul jusqu'à ce que l'un d'eux soit déclenché.

Où se trouvent les Skills :

Personnelles : $HOME/.agents/skills/ : transversales aux projets, reflètent votre façon de travailler quel que soit le dépôt
Équipe : .agents/skills/ dans le dépôt : spécifiques au projet, versionnées, partagées avec les collaborateurs

Le format SKILL.md :

Les trois Skills que tout utilisateur avancé devrait écrire en premier :

open-pr est le workflow standard de PR : vérifier la branche, pousser, créer la PR avec un corps structuré, appliquer les labels et demander une révision. Le Skill le plus utilisé dans le travail quotidien.
new-feature lit le PRD (document d'exigences produit) et AGENTS.md, identifie les composants existants à réutiliser, produit un plan, attend l'approbation, implémente, teste et ouvre une PR via le Skill open-pr. Si quelque chose dans le PRD est ambigu, il demande avant de générer du code.
investigate est le Skill de diagnostic sans correction. Il confirme la reproduction, lit les chemins de code pertinents, forme une hypothèse (« Je crois que X se produit à cause de Y ») et produit l'hypothèse ainsi qu'un plan de validation en Markdown. Il n'implémente pas de correctif. Le résultat est la compréhension, pas le code.

Le Skill investigate est important car Codex sautera l'analyse des causes profondes à chaque fois si vous le laissez faire. Il passera directement à un correctif, et ce correctif sera souvent erroné. Imposer investigate-first est la plus grande amélioration de la qualité de sortie en débogage.

Vérifiez que vos Skills sont chargés : list available skills

Sous-agents et parallélisme

Les Skills gèrent vos workflows réutilisables. Les sous-agents gèrent vos workflows parallèles. La distinction est importante car un parallélisme mal fait crée plus de problèmes qu'il n'en résout.

Un sous-agent est une instance d'agent distincte et isolée. Il fonctionne dans son propre contexte, renvoie un résumé, et son contexte est jeté. Il est différent d'un Skill, qui s'exécute dans le contexte de l'agent principal.

Trois motifs où les sous-agents sont l'outil approprié :

Exploration : lancer un sous-agent pour lire 30 fichiers et résumer ; la lecture se fait dans son contexte, pas dans le vôtre
Implémentation parallèle : cinq fonctionnalités indépendantes comme cinq sous-agents concurrents, chacun avec son propre contexte et plan
Vérification : un nouveau sous-agent réviseur n'est pas biaisé par le fait d'avoir juste écrit le code

Les sous-agents personnalisés sont définis dans .codex/agents/<nom>.md :

L'adressage des sous-agents a été livré en mars 2026. Parlez à un sous-agent en cours d'exécution par surnom avec @<surnom>.
Utile lorsque plusieurs sont en cours d'exécution en parallèle et que vous souhaitez en rediriger un sans déranger les autres.
Le motif de fan-out : lancer N sous-agents en parallèle sur des tâches indépendantes et rassembler les résultats.
Cinq tâches se terminent dans le temps que prend la plus lente. Règle générale : si une tâche prend moins de 30 secondes dans le contexte principal, faites-la directement là.

L'application de bureau : Codex pour tout

Les sous-agents et les Skills fonctionnent aussi bien sur la CLI, l'extension IDE et l'application de bureau. Mais l'application de bureau est l'endroit où vivent les fonctionnalités qui n'ont pas d'équivalent en CLI.

La mise à jour du 16 avril 2026 « Codex pour (presque) tout » a transformé l'application de bureau d'un outil de codage en un poste de travail complet pour développeur.

Computer Use (Utilisation de l'ordinateur)

Codex opère sur votre Mac : cliquer, taper, faire défiler, ouvrir des applications, naviguer dans les menus et fonctionner à vos côtés sans voler le focus du curseur.

L'utilisation tueuse est la vérification comportementale. Les tests unitaires passent mais l'interface est toujours cassée.
Computer Use comble cet écart en laissant Codex ouvrir le serveur de développement, cliquer dans le flux pertinent et capturer l'écran du résultat.
Pour l'activer, allez dans Paramètres Codex, Computer Use, Installer. Accordez les autorisations d'enregistrement d'écran et d'accessibilité lorsque macOS vous le demande. Invoquez-le depuis n'importe quel prompt :

Computer Use verrouillé permet à Codex de continuer à utiliser les applications de bureau après le verrouillage de votre écran. Activez-le dans Paramètres sous Computer Use. Lancez une tâche avant de vous coucher, verrouillez votre machine, révisez les résultats le matin.

Appshots

Appuyez sur Commande-Commande et la fenêtre macOS au premier plan va directement dans votre fil Codex.

Codex capture la capture d'écran, le texte visible et le texte d'accessibilité ; incluant souvent du contenu défilé hors écran.

Sans Appshots : voir une erreur, passer à Codex, taper une question, prendre une capture d'écran, la glisser, taper plus de contexte. Une demi-minute de friction.
Avec Appshots : voir l'erreur, appuyer sur Commande-Commande, poser votre question. Cinq secondes.

Si vous avez interagi avec un fil Codex au cours des 60 dernières secondes, l'Appshot va dans cette conversation.

Sinon, il ouvre un nouveau fil. Plusieurs Appshots dans une session s'empilent dans un seul fil. Nécessite les autorisations d'enregistrement d'écran et d'accessibilité.

Le navigateur intégré

Le navigateur intégré est un navigateur agentique natif, pas un aperçu de page. Il ouvre votre serveur de développement local, clique, remplit des formulaires, inspecte l'état du DOM, capture des captures d'écran et vérifie que le patch qui vient d'être écrit a corrigé le bogue visuel.

Ouvrez un serveur de développement local à l'intérieur, puis ajoutez des commentaires en langage naturel directement sur les éléments rendus.
Écrivez « rends ce bouton 20 pixels plus haut » sur l'élément, et Codex exécute la modification dans votre codebase et recharge la page.
Le navigateur intégré fournit un accès direct au DOM sans frais de gestion de fenêtre et est isolé de votre vrai navigateur.

Mémoire (Memory)

La mémoire permet à Codex de conserver le contexte entre les sessions.

Après chaque session, Codex résume l'interaction et l'écrit dans ~/.codex/memories/.
Lors de la session suivante, il lit ces fichiers avant de charger votre prompt.
Codex apprend votre format de message de commit préféré, vos frameworks de test, vos motifs architecturaux et les erreurs qu'il a commises la dernière fois ; sans que vous ayez à répéter ce contexte.
Activez-la dans Paramètres, ou ajoutez memories = true sous [features] dans config.toml.

L'écosystème de plus de 90 plugins

Les plugins sont des ensembles organisés de Skills, MCPs et intégrations. Installez avec codex plugins install <nom>.

Catégories de plugins clés :

Gestion de projet : Linear, JIRA, GitHub
CI/CD : CircleCI, Vercel, GitHub Actions
Bases de données : Neon, Postgres, PlanetScale
Qualité du code : Sentry, CodeRabbit
Productivité : Notion, Remotion

N'installez que pour les outils que vous utilisez quotidiennement. Limitez la portée par projet si possible. Auditez trimestriellement. Chaque plugin coûte des tokens de contexte, que vous l'utilisiez ou non.

Codex Cloud : travail asynchrone à grande échelle

L'application de bureau alimente votre travail local et interactif. Cloud est ce que vous utilisez lorsque le travail est trop volumineux pour une seule session interactive ou lorsque vous souhaitez exécuter plusieurs tâches en parallèle pendant que vous vous concentrez ailleurs.

Codex Cloud est la fonctionnalité qui transforme Codex d'un assistant de codage rapide en une équipe d'ingénieurs juniors qui évolue horizontalement.

Soumettez une tâche, Codex lance un sandbox préchargé avec votre dépôt, travaille, exécute les tests et ouvre une PR. Rien ne bloque votre machine locale.

Soumission d'une seule tâche :

Tâches parallèles ; le motif central :

Vingt minutes plus tard, quatre PR sont ouvertes. Révision, tri, fusion.

Le fan-out CSV permet de soumettre un fichier de tâches et Codex les répartit en agents cloud parallèles avec suivi de progression :

codex cloud parcourt les tâches actives et terminées. codex cloud apply <id> tire les modifications localement avant de fusionner.

Intégration GitHub

Les tâches cloud atterrissent dans votre dépôt sous forme de PR. L'intégration GitHub détermine comment ces PR sont révisées et comment Codex s'intègre dans votre pipeline CI/CD existant.

Codex et GitHub s'intègrent à trois niveaux : environnements de dépôt, révisions de pull request et codex-action pour CI/CD.

Les environnements de dépôt sont la base. Liez un dépôt GitHub dans les Paramètres Codex et les tâches cloud cloneront le dépôt, exécuteront les tâches dans un conteneur sandboxé et pousseront le résultat sous forme de branche ou PR. AGENTS.md est lu automatiquement pour chaque tâche cloud.

Les révisions de pull request fonctionnent de deux manières :

Mentionnez @codex review dans n'importe quel commentaire de PR. Codex réagit avec un emoji yeux pour confirmer la réception, puis publie une révision structurée centrée sur les problèmes graves vérifiés par rapport à votre AGENTS.md.
Activez les révisions automatiques (Automatic Reviews) pour que Codex publie sur chaque nouvelle PR sans déclenchement manuel.

Après que Codex a publié une révision, demandez-lui de corriger les problèmes signalés directement dans le fil de commentaires de la PR. Il commet le correctif sur la même branche et met à jour la PR.

codex-action est une GitHub Action officielle qui exécute la CLI Codex dans votre pipeline CI/CD sur n'importe quel déclencheur : push, planification, création d'issue ou ouverture de PR. C'est la méthode recommandée pour intégrer Codex dans des pipelines entièrement automatisés où aucun humain n'est présent.

Automations : travail sans surveillance

L'intégration GitHub gère ce qui se passe quand un humain ouvre une PR. Les automations gèrent ce qui se passe quand aucun humain n'a besoin d'être impliqué.

Les automations sont des tâches Codex planifiées s'exécutant dans des arbres de travail dédiés. Configurez-les depuis le panneau Automations : nom, projet, prompt, planification et environnement d'exécution.

La réutilisation de fil a été livrée en avril 2026. Les automations peuvent réutiliser un fil entre les exécutions, accumulant du contexte et devenant plus intelligentes au fil du temps.

Trois automations de démarrage que tout projet devrait avoir :

Revue hebdomadaire des dépendances (lundi 6h) : Exécutez pnpm outdated et pnpm audit. Signalez les constats critiques, majeurs et mineurs. Faites une auto-PR pour les mises à niveau mineures et de correctifs sûres. Ne touchez pas aux mises à jour critiques ou majeures ; celles-ci nécessitent des décisions humaines.
Tri quotidien de Sentry (jour de semaine 8h) : Récupérez les erreurs des dernières 24 heures regroupées par empreinte. Pour chaque groupe avec 3 occurrences ou plus, identifiez le fichier et la ligne, lisez le code pertinent et identifiez la cause racine. Publiez un rapport de tri. Diagnostic uniquement, pas de correctifs.
Nettoyage hebdomadaire des PR obsolètes (vendredi 17h) : Listez les PR ouvertes depuis plus de 7 jours. Pour chacune, déterminez si elle attend votre action, une révision ou si elle est devenue obsolète, et publiez un commentaire de rappel. Ne fermez ni ne fusionnez rien.

Supprimez toute automation dont la sortie cesse d'être lue. Une bonne automation économise une tâche récurrente que vous feriez de toute façon, produit une sortie unique et facile à parcourir, et n'effectue aucune action destructive sans surveillance.

Intégration MCP

Les automations fonctionnent avec ce qui est dans votre dépôt. Les serveurs MCP étendent Codex pour fonctionner avec tout ce qui est à l'extérieur.

MCP (Model Context Protocol) est la spécification ouverte derrière les plugins. Utilisez un plugin quand il en existe un. Utilisez du MCP brut pour les intégrations personnalisées avec des outils internes.

STDIO : Codex lance un processus local et communique via stdin/stdout. Couvre 95 % des usages individuels.
Streamable HTTP : Codex se connecte à un point de terminaison réseau. Utilisé pour les MCP d'équipe hébergés.

Ajout d'un serveur MCP brut :

Ou directement dans ~/.codex/config.toml :

text

1# ~/.codex/config.toml
2[mcp.servers.my-db]
3command = "node"
4args = ["/path/to/server.mjs"]

Configuration des outils par approbation : approbation automatique pour les lectures, demande pour les écritures. Chaque serveur MCP ajoute des définitions d'outils au contexte de Codex, ce qui consomme des tokens et dilue l'attention. N'activez uniquement que ce que vous utilisez réellement.

Docker MCP Toolkit connecte Codex à plus de 220 serveurs pré-construits avec une seule commande : docker mcp-client configure codex

Application mobile

Les serveurs MCP étendent les capacités de Codex. L'application mobile étend l'endroit où vous pouvez accéder à Codex.

Le 14 mai 2026, Codex est arrivé dans l'application mobile ChatGPT sur iOS et Android.

Codex Mobile est une interface de contrôle et de surveillance à distance, pas un éditeur de code. Le cas d'usage typique est de vérifier depuis votre téléphone l'état d'une tâche cloud longue ou d'un mode Objectif en cours, lorsque vous êtes loin de votre bureau.

Depuis votre téléphone, vous pouvez :

Regarder les exécutions en direct sur les ordinateurs portables, les environnements de développement ou les environnements distants connectés
Parcourir les fils de discussion et naviguer entre les tâches parallèles
Examiner les diffs avant qu'ils ne soient fusionnés dans une branche
Approuver ou rejeter les commandes que Codex souhaite exécuter sur votre matériel
Changer de modèle en cours de tâche si un modèle plus puissant est nécessaire
Démarrer de nouvelles tâches à partir d'une invite fraîche ou directement depuis un problème GitHub
Commentez une pull request que Codex a ouverte

Pour le configurer, mettez à jour ChatGPT vers la version du 13 mai 2026 ou une version ultérieure, connectez-vous avec le même compte de bureau, et assurez-vous qu'au moins un environnement cloud est configuré dans Paramètres sous Codex, Environnements. Mobile hérite automatiquement de tous les fils de discussion existants et des hôtes connectés.

La boucle pratique que cela permet : lancez une exécution en mode Objectif le matin avant de quitter la maison, vérifiez sa progression pendant votre trajet, approuvez une décision en attente depuis votre téléphone, et arrivez au bureau avec les deux premières PR déjà ouvertes.

Extension Chrome

L'application mobile étend votre portée. L'extension Chrome étend la portée de Codex sur n'importe quel site Web sur lequel vous êtes déjà connecté.

Cela signifie qu'elle peut accéder à des services authentifiés : LinkedIn, Salesforce, Gmail, Workday, et tout outil interne nécessitant une connexion.
Installez-la en allant dans Plugins au sein de l'application de bureau Codex, en ajoutant le plugin Chrome et en suivant la configuration guidée.
L'extension affiche un statut Connecté lorsqu'elle est active. Invoquez-la depuis n'importe quel fil de discussion Codex :

Codex peut contrôler plusieurs onglets Chrome via des sous-agents sur différents fils de discussion, chaque onglet étant isolé.

Un avantage majeur par rapport à l'automatisation de navigateur sans tête : l'extension Chrome peut accéder aux outils de développement web. Codex peut inspecter le DOM, lire les erreurs de console et diagnostiquer les problèmes d'exécution dans une session de navigateur en direct. Fonctionne sur macOS et Windows.

Le SDK Codex

L'extension Chrome gère l'automatisation du navigateur. Le SDK gère l'automatisation programmatique ; l'intégration de Codex en tant qu'infrastructure dans vos propres applications et pipelines.

Le SDK Codex offre aux développeurs un contrôle programmatique de Codex depuis leurs propres applications et pipelines CI.

Installez le SDK JavaScript :

javascript

1npm install @openai/codex-sdk

Utilisation de base :

javascript

1import { Codex } from "@openai/codex-sdk";
2
3const codex = new Codex();
4
5const thread = await codex.startThread();
6await thread.run("Quel temps fait-il à Tokyo ?");

Appelez run() à nouveau sur le même fil pour continuer la conversation. Reprenez un fil sauvegardé avec codex.resumeThread(threadId).
Le SDK Python utilise from codex_app_server import Codex. Passez un nom de modèle lors du démarrage : thread = codex.thread_start(model="gpt-5.5").
Le SDK est actuellement expérimental et nécessite une installation locale de Codex CLI.
Il communique avec le serveur d'application local via JSON-RPC ; il contrôle le même agent avec lequel vous interagissez dans l'application de bureau.

Vérification : comment vraiment faire confiance aux sorties de Codex

Toutes les surfaces ci-dessus produisent des sorties. La vérification est ce qui détermine quelle part de ces sorties vous pouvez réellement livrer.

La génération est résolue. La vérification est le goulot d'étranglement.

Cinq PR cloud parallèles, c'est cinq chances d'introduire un bug. Sans couche de vérification, votre débit est limité par la vitesse à laquelle vous pouvez lire les PR.

Le problème central est la sycophantie. Le modèle qui a écrit le code est biaisé pour penser qu'il est correct. Demandez-lui de revoir son propre travail et vous obtenez un feu vert la plupart du temps.

Deux correctifs structurels :

auto_review (dans Codex) est le sous-agent réviseur intégré de Codex. Nouveau contexte, aucun investissement dans la sortie précédente, bien plus susceptible de signaler de vrais problèmes.
Vérification inter-fournisseurs (étalon-or) signifie que Codex écrit et Claude Code révise. La vérification inter-fournisseurs détecte les angles morts spécifiques à une famille de modèles. C'est l'habitude de vérification minimale viable pour le code de production.

L'utilisation de Computer Use pour la vérification comportementale comble l'écart entre « les tests passent » et « le truc fonctionne réellement ». Demandez à Codex d'ouvrir le serveur de développement, de cliquer sur le flux pertinent, de prendre une capture d'écran du résultat et de la comparer à votre PRD.

L'habitude minimale viable sur chaque PR : exécutez une revue automatisée avec un modèle différent avant d'ouvrir vous-même le diff. Lisez d'abord le résumé de la revue. N'ouvrez le diff que lorsque la revue est propre ; puis lisez pour le goût, pas pour l'exactitude. Pour les modifications d'interface utilisateur, regardez la capture d'écran.

Recettes : motifs éprouvés

Les habitudes de vérification en place, voici les modèles de bout en bout pour les tâches que les développeurs exécutent le plus souvent avec Codex.

Implémenter une fonctionnalité : utilisez la compétence nouvelle-fonctionnalité. Lisez le PRD et AGENTS.md. Planifiez d'abord, attendez l'approbation. Tests pour le cas nominal et un cas d'erreur. Si quoi que ce soit est ambigu, demandez avant de générer le code.
Corriger un bug : utilisez d'abord la compétence investiguer. Diagnostiquez uniquement. Produisez les étapes de reproduction, l'hypothèse de cause racine et un plan de validation. Ne corrigez pas avant confirmation.
Refactoriser : listez tous les emplacements avec grep. Produisez le plan de migration. Attendez l'approbation. Tous les tests existants doivent passer sans modification. Si un test doit être mis à jour, le test est erroné ; arrêtez et signalez. Une seule PR.
Intégration tierce : encapsulez dans /lib/integrations/[nom].ts. Ajoutez des variables d'environnement à .env.example. Pas d'interface utilisateur dans cette PR. Ouvrez en tant que brouillon pour des tests manuels contre le service externe.
Remplissage de tests : produisez le plan de test couvrant les cas nominaux, limites et d'erreur. Attendez l'approbation. Tous les tests doivent passer contre le code de production existant. Ne modifiez pas le code de production.
Mise à jour de dépendance : lisez les notes de version entre les versions. Listez les modifications cassantes. Attendez l'approbation. Mettez à jour et appliquez les modifications de code. Exécutez les tests jusqu'à ce qu'ils soient propres.
Initiative de mode Objectif : délimitez avec un nombre maximum de PR, un nombre maximum de lignes de code par PR, une passerelle CI entre les PR et des conditions d'arrêt claires. Mettez en pause sur les décisions architecturales qui ne figurent pas dans AGENTS.md. Mettez en pause sur tout changement d'API cassant.

Erreurs courantes

Ces motifs couvrent les gains courants. La section ci-dessous couvre les pertes courantes ; les dix erreurs qui expliquent la plupart des mauvaises expériences avec Codex.

Tâches vagues. Nommez des résultats, des fichiers et des contraintes spécifiques. Si vous ne pouvez pas être précis, la tâche n'est pas prête à être briefée.
Pas de AGENTS.md. Écrivez-en un. Même un mauvais vaut mieux que rien.
Sauter le plan. « Produisez d'abord un plan » pour tout ce qui n'est pas trivial.
Invites multitâches. Une tâche par invite. Utilisez des sous-agents ou des tâches cloud pour le travail parallèle.
Commencer avec un accès total dangereux. workspace-write et on-request est la valeur par défaut correcte pour tout sauf les automatisations testées.
Trop de MCP et de plugins. Gardez la liste légère. Désactivez ce que vous n'utilisez pas activement.
Auto-révision. Utilisez auto_review ou un outil complètement différent. Le modèle qui a écrit le code est biaisé en sa faveur.
Faire confiance à la réussite de la compilation comme preuve d'exactitude. Incluez une vérification comportementale. Utilisez Computer Use pour les modifications d'interface utilisateur.
Trop de parallélisation. Parallélisez uniquement le travail indépendant. Les fichiers partagés doivent être sérialisés.
Objectifs sans limites. PR maximum, lignes de code maximum, temps maximum, conditions d'arrêt claires. Le mode Objectif est plus utile avec la laisse que vous donneriez à un ingénieur junior.

Aide-mémoire de référence rapide

Commandes CLI :

codex : démarrer une session interactive
codex run <tâche> : exécuter une tâche unique
codex goal <objectif> : démarrer le mode Objectif
codex review : lancer auto_review sur les modifications en cours
codex doctor : diagnostiquer les problèmes de configuration
codex config : afficher la configuration active
codex sync : synchroniser les compétences et les souvenirs avec le cloud
codex cloud : gérer les environnements cloud

Emplacements des fichiers clés :

Configuration globale : ~/.codex/config.toml
AGENTS.md global : ~/.codex/AGENTS.md
AGENTS.md du projet : <racine-du-depot>/AGENTS.md
Fichier de substitution : AGENTS.override.md
Souvenirs : ~/.codex/memories/
Compétences (personnelles) : $HOME/.agents/skills/
Compétences (équipe) : .agents/skills/ dans le dépôt
Sous-agents : .codex/agents/<nom>.md

La structure d'invite en quatre parties :

Dite : le résultat, pas la méthode
Montrez : des exemples d'entrées et les sorties attendues
Décrivez : les API, bibliothèques et modèles à utiliser
Rappelez : les conventions de AGENTS.md

Conclusion

Après 12 mois d'utilisation de Claude, le point de rupture n'a pas été un mauvais jour. C'était l'accumulation de limites de débit, de frictions dans le flux de travail et d'une expérience d'application de bureau qui ne cessait de faire obstacle.

C'est cette frustration qui a poussé le basculement vers Codex.

Au cours des 90 derniers jours, plonger profondément dans l'écosystème OpenAI a clarifié une chose : Codex semble plus complet en tant qu'environnement de travail pour les workflows sérieux de développeurs.
Le modèle agentique est plus fort, les surfaces environnantes sont plus larges, et le système est plus facile à approuver une fois que AGENTS.md, les compétences, le cloud et les boucles de vérification sont en place.
Cela ne signifie pas que Claude Code n'a aucune valeur. Cela signifie que les compromis ont cessé d'être pertinents.

Si Claude Code fonctionne toujours pour votre workflow, continuez à l'utiliser. Mais si vous êtes fatigué des limites de débit, des sessions fragiles et des outils qui semblent lutter contre votre processus, Codex est désormais assez bon pour justifier un changement sérieux.

Cet article a été écrit pour faciliter ce changement.

J'espère que vous avez apprécié et que vous commencerez à construire ❤️

Avertissement

Cet article a été écrit par l'auteur sur la base de ses notes, recherches et expériences personnelles, et édité par un modèle d'IA (Sonnet 4.6).

L'image miniature a été prise sur Pinterest et modifiée à l'aide de l'IA.