Claude Code vs Codex CLI 2026 : référence de décision

J’utilise Claude Code comme outil de développement principal. Ce parti pris mérite d’être annoncé d’emblée, car les meilleures comparaisons naissent d’une connaissance approfondie d’un outil doublée d’un test honnête de l’autre. Après 36 duels à l’aveugle (où j’ai soumis des tâches identiques aux deux outils et noté les résultats sans savoir lequel les avait produits ¹) et des centaines de sessions avec l’un comme avec l’autre, j’en suis venu à la conclusion que la réponse à « lequel est le meilleur ? » est sincèrement « cela dépend de la tâche ».

Claude Code excelle dans le refactoring en profondeur, la revue de code et la gouvernance programmable grâce à son système de hooks de cycle de vie ; Codex CLI l’emporte sur l’isolation au niveau du noyau et la portabilité entre outils via AGENTS.md. Claude Code applique la sécurité à la couche applicative, avec plus de deux douzaines d’événements de hook que vous câblez vous-même, tandis que Codex l’applique à la couche du noyau du système d’exploitation, là où le modèle ne peut contourner aucune restriction. Choisissez Claude Code pour le raisonnement complexe sur plusieurs fichiers et les flux de travail personnalisables les plus poussés. Choisissez Codex pour une isolation maximale et des instructions d’agent standardisées qui fonctionnent sur plus de huit outils.

À jour au 5 juin 2026. Les deux outils publient des mises à jour chaque semaine ; les faits exposés ici ont donc une durée de vie limitée. À l’heure de cette révision, Claude Code utilise par défaut Opus 4.8 (CLI v2.1.165) et Codex utilise par défaut GPT-5.5 (CLI v0.137.0). Le plus grand changement depuis le printemps : Codex a livré un véritable système de hooks de cycle de vie, réduisant ce qui était autrefois l’avance la plus nette de Claude Code. Consultez Là où chaque outil l’emporte pour comprendre ce que cela change — et ce que cela ne change pas.

En bref

Claude Code et Codex CLI résolvent le même problème (le développement assisté par IA) avec des architectures fondamentalement différentes. Claude Code gouverne principalement par les hooks : plus de deux douzaines de types d’événements de cycle de vie qui appliquent les règles de façon déterministe à la couche applicative ². Codex gouverne principalement par l’isolation : des restrictions du noyau au niveau du système d’exploitation, sous la couche applicative ³, désormais associées à ses propres hooks de cycle de vie. Aucune des deux approches n’est strictement supérieure.

Claude Code a régulièrement surpassé Codex en revue de code et en vérification de sécurité lors des tests à l’aveugle. Codex offre de véritables avantages en matière d’isolation, de portabilité entre outils via AGENTS.md et de délégation de tâches dans le cloud.

Décision rapide : Besoin d’une isolation au niveau du noyau ou d’un AGENTS.md partagé entre outils ? → Codex. Besoin des hooks de gouvernance programmable les plus aboutis ou de refactoring en profondeur ? → Claude Code. Besoin des deux modèles de sécurité ? → Faites tourner les deux.

Nouveau sur ces deux outils ? Commencez d’abord par le guide Claude Code ou le guide Codex. Cet article suppose une familiarité avec au moins l’un des deux.

Deux modèles mentaux

Les deux outils reposent sur des architectures à trois couches, mais ces couches servent des objectifs différents.

Claude Code :

1. Raisonnement. Claude Code exécute le modèle Claude sélectionné. Depuis CLI v2.1.154 (28 mai 2026), Opus 4.8 est le modèle par défaut, avec un effort élevé par défaut et un niveau /effort xhigh pour les tâches les plus ardues ; Sonnet 4.6 et Haiku 4.5 restent sélectionnables pour les travaux plus légers ²
2. Exécution. Bash, opérations sur les fichiers, commandes git, appels d’outils MCP
3. Gouvernance. Les hooks interceptent les actions à plus de deux douzaines de points du cycle de vie ² ; les permissions encadrent la portée

Codex :

1. Modèle. GPT-5.5 (lancé le 23 avril 2026) est le modèle par défaut : 400K de contexte dans Codex, 1M dans l’API, 5 $ / 30 $ par MTok, 82,7 % sur Terminal-Bench 2.0 (état de l’art à sa sortie). GPT-5.5-pro couvre le palier au plus haut effort ; le plus petit GPT-5.4 mini gère encore le travail de sous-agent à faible latence ⁴
2. Bac à sable. Application au niveau du noyau du système d’exploitation (Seatbelt sur macOS, Landlock + seccomp sur Linux) ³
3. Approbation. Trois politiques (untrusted, on-request, never) encadrent les modifications avant exécution ⁵

La différence décisive tient à l’endroit où réside principalement la gouvernance. Le centre de gravité de Claude Code est la couche applicative ; les hooks sont des programmes que vous écrivez pour intercepter des événements précis. Le centre de gravité de Codex est la couche du noyau ; le système d’exploitation empêche les opérations interdites, quoi que tente le modèle. Les deux outils disposent désormais de hooks, mais leurs architectures continuent de privilégier des choix par défaut différents.

Pourquoi cette distinction compte : la gouvernance à la couche applicative est programmable. Vous pouvez encoder une logique métier, lancer des linters, valider des schémas, tout ce qui s’exprime en code. La gouvernance à la couche du noyau, elle, est inviolable. Le modèle ne peut contourner les restrictions, car le système d’exploitation refuse l’appel système avant qu’il n’atteigne l’application. Toute architecture de sécurité troque l’expressivité contre la robustesse, et ces deux outils se situent aux extrémités opposées de ce spectre.

Philosophie de configuration

Claude Code utilise JSON. Codex utilise TOML. Tous deux prennent en charge une portée hiérarchique. Les philosophies divergent dans leur manière de penser le changement de contexte.

Claude Code : configuration en couches

// ~/.claude/settings.json (user-level)
{
  "permissions": {
    "allow": ["Bash(git *)"],
    "deny": ["Bash(rm -rf *)"]
  }
}

// .claude/settings.json (project-level, inherits user)
{
  "permissions": {
    "allow": ["Bash(npm test)"]
  }
}

Claude Code résout les paramètres depuis plusieurs couches : paramètres gérés (priorité la plus élevée) → ligne de commande → projet local → projet partagé → valeurs par défaut de l’utilisateur ⁶. Les fichiers de mémoire (CLAUDE.md) suivent leur propre portée : utilisateur → projet → local. Les skills et les hooks ajoutent encore des couches supplémentaires. Cette flexibilité est puissante, mais la configuration active n’est visible depuis aucun fichier unique ; vous la reconstituez en parcourant la hiérarchie.

Codex : des profils avec bascule explicite

# ~/.codex/config.toml
model = "gpt-5.5"
approval_policy = "on-request"

[profiles.deep-review]
model = "gpt-5.5-pro"
approval_policy = "never"

[profiles.careful]
approval_policy = "untrusted"

codex --profile careful "Review this PR"
codex --profile deep-review "Audit this module"

Les profils Codex vous permettent de basculer d’une configuration à l’autre avec un simple drapeau ⁷. Aucune résolution de couches à démêler ; la configuration active est toujours explicite. Pour les équipes qui standardisent leurs politiques d’approbation, c’est plus simple à auditer. Les profils ont quitté le stade expérimental pour devenir une surface gérée de premier ordre : --profile est désormais le sélecteur principal à travers la CLI, les permissions de la TUI et les flux du bac à sable, et les profils de permission nommés prennent en charge l’héritage, les API de liste, ainsi qu’un fichier requirements.toml géré pour la politique de l’organisation ⁷.

Modèles de sécurité

La sécurité constitue la divergence architecturale la plus profonde entre les deux outils.

Claude Code : des hooks déterministes à la couche applicative

Les hooks interceptent les actions avant leur exécution. Un hook PreToolUse sur Bash peut inspecter chaque commande et bloquer les schémas dangereux ² :

# Hook: git-safety-guardian (PreToolUse:Bash)
if echo "$tool_input" | grep -q "push.*--force.*main"; then
  echo '{"decision": "block", "reason": "Force push to main blocked"}'
fi

La force : les hooks sont des programmes. Vous pouvez encoder une logique de sécurité arbitrairement complexe : vérifier des chemins de fichiers, valider du JSON, imposer des conventions de nommage, lancer des linters. Je fais tourner 95 hooks qui couvrent tout, de la détection d’identifiants aux barrières de qualité.

La faiblesse : les hooks opèrent à la couche applicative. En 2025, Check Point Research a divulgué la CVE-2025-59536, démontrant que des hooks malveillants placés dans les fichiers de configuration d’un projet pouvaient exécuter des commandes shell pendant l’initialisation de Claude Code, avant même que l’utilisateur ne voie une boîte de dialogue de consentement ¹⁹. Anthropic a corrigé la vulnérabilité en quelques semaines, mais cette divulgation confirme la préoccupation architecturale : l’application à la couche applicative partage une frontière de processus avec l’agent. Les recommandations de l’AI Red Team de NVIDIA aboutissent à la même conclusion : « les hooks et les fonctions d’initialisation MCP s’exécutent souvent en dehors d’un environnement de bac à sable, offrant l’occasion d’échapper aux contrôles du bac à sable » ²⁰.

Codex : un bac à sable au niveau du noyau

Codex restreint l’agent au niveau du système d’exploitation. Sur macOS, les profils Seatbelt limitent l’accès au système de fichiers, la connectivité réseau et la création de processus ³. Sur Linux, Landlock + seccomp offrent des restrictions équivalentes, avec une chaîne Bubblewrap (bwrap) optionnelle disponible par configuration ³.

# Three sandbox modes
codex --sandbox read-only           # Agent can read but not write
codex --sandbox workspace-write     # Agent writes only in project directory (default)
codex --sandbox danger-full-access  # No restrictions (named to signal risk)

La force : l’application au niveau du noyau se situe en dessous de l’application. Le modèle ne peut échapper aux restrictions en concoctant des commandes astucieuses ; le système d’exploitation refuse l’appel système avant son exécution ³. Le préfixe danger- du mode plein accès reflète le fait que lever les restrictions du bac à sable est une action exceptionnelle, et non un réglage de routine.

La faiblesse : les restrictions du noyau sont binaires. Vous pouvez autoriser ou refuser les écritures sur le système de fichiers, mais vous ne pouvez pas dire « autorise les écritures dans src/ mais bloque celles dans config/ tant que la modification ne passe pas un linter ». Cette gouvernance fine exige une logique à la couche applicative.

Le compromis est bien réel. Les hooks offrent une sécurité granulaire et programmable, mais des frontières plus faibles. Le bac à sable offre des frontières plus solides, mais un contrôle plus grossier. Une heuristique de décision rapide :

• Confiance interne, code externe : utilisez Codex avec le bac à sable read-only pour relire les PR de contributeurs inconnus. Le noyau empêche toute modification de fichier, quoi que tente le modèle.
• Code de confiance, application de règles : utilisez les hooks de Claude Code lorsque vous avez confiance dans la base de code mais devez imposer des standards organisationnels : formats de messages de commit, analyse d’identifiants, barrières de linting.
• Les deux préoccupations : faites tourner les deux. Utilisez Codex pour la frontière de sécurité initiale, puis basculez vers Claude Code pour une revue à forte gouvernance.

Extensibilité

Les deux outils prennent en charge la personnalisation, mais la maturité varie selon le mécanisme.

Là où Claude Code mène : la profondeur des hooks. Le système de cycle de vie couvre PreToolUse, PostToolUse, UserPromptSubmit, SessionStart, SessionEnd, Stop, StopFailure, SubagentStart, SubagentStop, PreCompact, PermissionRequest, PermissionDenied, TaskCreated, TaskCompleted, CwdChanged, FileChanged, MessageDisplay, et plus encore. Cela représente plus de deux douzaines d’événements, et la liste s’allonge encore ². Codex dispose désormais de hooks lui aussi, mais le catalogue de Claude Code est plus large et plus éprouvé, et il s’associe à l’additionalContext du hook Stop pour le pilotage ainsi qu’aux /workflows dynamiques pour les grandes ramifications d’agents. Si vous devez imposer des barrières de qualité, détecter des fuites d’identifiants avant les commits, ou injecter du contexte automatiquement sur de nombreux types d’événements, l’architecture de hooks de Claude Code est l’option la plus aboutie.

Là où Codex a comblé un écart : les hooks ne sont plus l’apanage de Claude Code. La communauté réclamait des événements de hook élargis depuis la majeure partie de 2025 ¹⁸, et Codex a répondu : un véritable système de hooks de cycle de vie avec les événements AfterAgent et AfterToolUse, une TUI /hooks pour les découvrir et les activer en cours de session, et une API d’extension où les extensions observent le démarrage et l’arrêt des sous-agents, l’exécution des outils et les métadonnées de tour avec approbation asynchrone ⁹. L’ancien cadrage (Claude Code a des hooks, Codex n’a qu’une simple notification a posteriori) est dépassé. L’énoncé honnête de 2026 : les deux outils disposent de hooks de gouvernance programmable ; celui de Claude Code est plus large et plus mature, celui de Codex s’exécute aux côtés du bac à sable le plus robuste de la catégorie.

Là où Codex mène : la portabilité entre outils et les surfaces. AGENTS.md est un standard ouvert gouverné par l’Agentic AI Foundation sous l’égide de la Linux Foundation ¹³, adopté par plus de 60 000 projets ⁸. Le même fichier d’instructions fonctionne dans Codex, Cursor, GitHub Copilot, Amp, Windsurf et Gemini CLI (moyennant configuration) ¹⁴. CLAUDE.md est puissant, mais verrouillé à Claude Code. Codex s’exécute par ailleurs sur cinq surfaces (CLI, application de bureau, extension IDE, cloud, et une extension Chrome qui vous accompagne au fil de la navigation ordinaire ¹⁶), et codex cloud exec délègue les travaux de longue haleine à l’infrastructure d’OpenAI et renvoie des diffs ¹², un flux de travail que Claude Code n’offre pas en natif.

Là où chaque outil l’emporte

D’après 36 duels à l’aveugle, où j’ai envoyé des prompts identiques aux deux outils et noté les résultats à l’aveugle, et d’après un usage quotidien en production :

La méthodologie complète et le détail des notes par duel figurent dans Le juge à l’aveugle. Ces résultats sont antérieurs à Opus 4.8 et à GPT-5.5 ; traitez-les donc comme une orientation plutôt que comme un tableau de scores à jour : ils capturent la forme de chaque outil (Claude Code plus fort en revue et en raisonnement, Codex plus fort en DevOps et en isolation), forme qui s’est maintenue au fil des montées de version des modèles, et non les marges exactes sur les modèles d’aujourd’hui. Je rejouerai les duels sur les valeurs par défaut actuelles ; d’ici là, les tendances par catégorie restent le signal durable.

Là où Claude Code l’emporte

• Revue de code et vérification de sécurité. Claude Code a remporté 8 des 12 duels tranchés sur les tâches de revue ¹. Le système de philosophie de qualité et les barrières de preuve débusquent des problèmes qui échappent à l’approche plus procédurale de Codex.
• Flux de travail à forte gouvernance. Si votre flux de travail exige des vérifications avant commit, de l’analyse d’identifiants, de la validation de sortie ou des barrières de qualité qui bloquent avant l’exécution, le hook PreToolUse de Claude Code est le mécanisme adéquat. Codex possède désormais ses propres hooks de cycle de vie (AfterAgent, AfterToolUse) ⁹, mais ils observent a posteriori ; pour le blocage avant exécution, Codex s’appuie sur son bac à sable et sa politique d’approbation plutôt que sur un pré-hook programmable. Pour l’éventail des types d’événements et la logique de blocage en ligne, le catalogue de Claude Code reste la boîte à outils de gouvernance la plus complète.
• Orchestration multi-agents complexe. La délégation explicite aux sous-agents via l’outil Task ¹⁰, conjuguée aux /workflows dynamiques qui déploient des dizaines à des centaines d’agents en arrière-plan et aux systèmes de délibération, permet des flux de travail où de nombreux agents spécialisés collaborent avec un contexte isolé.
• Refactoring en profondeur d’une base de code. Opus excelle à conserver le contexte architectural au fil de longues sessions. Les schémas d’ingénierie du contexte qui régissent la hiérarchie hooks/skills/règles de Claude Code se transposent directement dans la manière dont le modèle raisonne sur de vastes bases de code.

Là où Codex l’emporte

• Environnements où le bac à sable est critique. Si vous exécutez un agent IA contre du code non fiable, traitez des PR externes, ou opérez dans une chaîne CI/CD où il vous faut des garanties strictes sur l’accès au système de fichiers et au réseau, le bac à sable au niveau du noyau de Codex est l’outil qu’il vous faut ³. Des hooks à la couche applicative ne peuvent offrir la même garantie.
• Équipes multi-outils. Si votre équipe utilise plusieurs outils de codage IA, AGENTS.md vous donne un seul fichier d’instructions qui fonctionne dans Codex, Cursor, Copilot, Amp, Windsurf et davantage ¹⁴. Aucune maintenance en double entre CLAUDE.md, .cursor/rules et les instructions Copilot.
• Flux de travail asynchrones dans le cloud. codex cloud exec délègue des tâches à l’infrastructure cloud et renvoie des diffs ¹². Pour l’intégration CI/CD ou le traitement par lots, c’est un flux de travail que Claude Code n’offre pas en natif.
• Pilotage en temps réel. Le mode de pilotage de Codex vous laisse injecter des instructions en cours de tâche avec Entrée (immédiat) ou mettre en file d’attente des suites avec Tab (tour suivant) ¹⁵. Claude Code prend en charge les messages de suivi, mais pas l’injection en cours de tour.
• Couverture des surfaces. Codex s’étend sur cinq surfaces : CLI, application de bureau (multitâche macOS entre plusieurs worktrees parallèles et fenêtres flottantes), extension IDE (VS Code, Cursor, Windsurf), tâches cloud, et une extension Chrome qui fonctionne aux côtés de votre navigation sans la monopoliser ¹⁶. Claude Code s’intègre à VS Code et JetBrains ¹⁷ mais reste avant tout CLI. Si vous voulez un seul agent qui vous suit du terminal à l’éditeur, du navigateur au cloud, Codex couvre plus de terrain.

Faire tourner les deux

Les deux outils n’entrent pas en conflit. CLAUDE.md et AGENTS.md cohabitent dans le même dépôt. Voici ma configuration :

my-project/
├── .claude/
│   └── settings.json     # Claude Code project config
├── CLAUDE.md              # Claude Code instructions
├── AGENTS.md              # Codex + Cursor + Copilot instructions
└── codex.md               # Codex project config (optional)

Un flux de travail concret à deux outils : j’utilise Claude Code pour le développement quotidien : implémentation de fonctionnalités, revue de code, refactorings multi-fichiers où les hooks imposent des barrières de qualité à chaque étape. Lorsqu’un contributeur externe ouvre une PR, je bascule vers Codex avec --sandbox read-only pour relire ses modifications contre du code non fiable. Quand j’ai besoin d’un second avis sur une décision d’architecture, j’envoie le même prompt aux deux outils et je compare les résultats à l’aveugle, selon l’approche du juge à l’aveugle.

L’approche à deux outils trouve un appui empirique au-delà de mes propres tests. Des recherches de Milvus ont montré que la revue contradictoire entre plusieurs modèles d’IA faisait passer la détection de bugs de 53 % à 80 % ²³. Une autre étude a constaté que des boucles itératives de revue Claude-Codex repéraient 14 problèmes sur 3 tours qu’aucun outil n’avait trouvés seul ²⁴. Aucun des deux outils ne remplace l’autre ; ils couvrent des modèles de menace et des profils de tâche différents.

Points clés à retenir

Si vous choisissez un outil :

• Partez de vos exigences de sécurité. Besoin d’une isolation au niveau du noyau ? Codex. Besoin de hooks de gouvernance programmable ? Claude Code.
• Tenez compte de votre équipe. Plusieurs outils d’IA en usage ? AGENTS.md évite la maintenance d’instructions en double entre outils ¹⁴.
• Essayez les deux sur une tâche réelle avant de décider. La méthodologie du juge à l’aveugle vaut aussi pour une évaluation personnelle.

Si vous êtes déjà investi :

• Utilisateurs de Claude Code : rédigez quand même un AGENTS.md. Cela prend vingt minutes et rend votre projet accessible aux utilisateurs de Codex, Cursor et Copilot.
• Utilisateurs de Codex : le système de hooks est arrivé. Parcourez-le avec /hooks, câblez AfterAgent/AfterToolUse, et appuyez-vous sur les profils de permission et le bac à sable pour le contrôle avant exécution ⁹. L’hypothèse « Codex n’a pas de hooks » que vous traînez peut-être depuis le début de 2026 est dépassée.
• Les deux outils progressent vite. La comparaison de cet article a une durée de vie qui se compte en semaines, non en années, ce qui explique précisément pourquoi elle porte une ligne de révision datée.

FAQ

Puis-je utiliser les deux outils dans le même projet ?

Oui. CLAUDE.md et AGENTS.md sont des fichiers distincts, sans conflit. Chaque outil lit son propre fichier d’instructions et ignore l’autre. Je maintiens les deux dans mes projets actifs.

Quel outil convient le mieux aux débutants ?

Codex présente une barrière de configuration plus basse : trois modes de bac à sable et trois politiques d’approbation couvrent la plupart des cas d’usage ⁵. La puissance de Claude Code vient de ses hooks et de ses skills, dont la mise en place demande de l’investissement. Commencez par le modèle (Claude ou GPT) avec lequel vous êtes déjà à l’aise.

Comment se comparent les coûts ?

Les deux reposent sur une tarification au token via leurs API respectives. Claude Code fonctionne sur la tarification d’Anthropic ; Codex sur le système de crédits d’OpenAI. Un test indépendant de Composio a constaté que Codex consommait 2 à 4 fois moins de tokens pour des résultats comparables. Sur une tâche de plugin Figma, Claude Code a utilisé 6,2M de tokens contre 1,5M pour Codex ²². L’efficacité en tokens ne se traduit pas directement en coût (la tarification par token diffère), mais la moindre consommation de tokens de Codex est un avantage mesurable pour les flux de travail à budget contraint.

AGENTS.md fonctionnera-t-il avec Claude Code ?

Pas pour l’instant. Claude Code lit CLAUDE.md ; Codex lit AGENTS.md. Les formats sont suffisamment proches pour que le contenu se transpose aisément de l’un à l’autre, mais il n’y a pas de lecture croisée automatique. Rédiger les deux ne demande qu’un effort minime, puisque le contenu se recoupe.

Lequel offre la meilleure intégration IDE ?

Codex dispose de la plus large surface : une application de bureau macOS avec multitâche et fenêtres flottantes, une extension IDE pour VS Code, Cursor et Windsurf, et une extension Chrome, le tout partageant un même modèle de session ¹⁶. Claude Code s’intègre à VS Code via une extension et à JetBrains via un plugin (bêta) ¹⁷. Les deux fonctionnent bien ; le choix dépend de votre préférence pour le tout-CLI (Claude Code) ou pour une empreinte GUI/multi-surface (Codex).

Références