---
title: 'Code Mode de Claude Code : exécuter les outils en JavaScript et ce que ça change sur les tokens'
description: "Code Mode, la fonctionnalité expérimentale de Claude Code, fait écrire du JavaScript à l'agent pour piloter ses outils. Ce que ça change sur les tokens, ce que dit le benchmark MCP, les prérequis et comment l'activer."
pubDate: 2026-11-22
family: 'intelligence-artificielle'
tags: ['Claude']
heroImage: '/images/claude-code-code-mode-executer-les-outils-en-javascript.webp'
videoUrl: 'https://www.youtube.com/watch?v=xyPnDpf9EJA'
faq:
  - question: 'Code Mode est-il activé par défaut dans Claude Code ?'
    answer: "Non. Code Mode est expérimental et désactivé par défaut : il faut définir `CLAUDE_CODE_EXPERIMENTAL_CODE_MODE` à `1` dans ton shell ou dans `~/.claude/settings.json`. La documentation précise qu'il peut changer ou être supprimé dans n'importe quelle version."
  - question: 'Quelles versions et quels modèles faut-il pour Code Mode ?'
    answer: "Claude Code v2.1.323 ou plus récent (v2.1.326 pour les équipes d'agents), avec un modèle Opus 5.5, Sonnet 5.5, Haiku 5.5 ou Fable 5.2. Il faut aussi une session `claude` interactive dans un terminal, un abonnement Claude ou un compte Console, et le build natif de Claude Code."
  - question: 'Peut-on reprendre une session Code Mode plus tard ?'
    answer: 'Oui, mais uniquement dans le terminal et avec Code Mode activé : garde `CLAUDE_CODE_EXPERIMENTAL_CODE_MODE` à `1` quand tu lances `claude --continue` ou `claude --resume`. Sans la variable, Claude Code refuse de reprendre la session. Une session démarrée sans Code Mode reprend sans lui, même si la variable est définie.'
  - question: 'Code Mode fonctionne-t-il derrière une passerelle ou Amazon Bedrock ?'
    answer: "Non. La documentation exige l'API Anthropic directement : les passerelles, Amazon Bedrock, Claude Platform on AWS, Agent Platform de Google Cloud et Microsoft Foundry ne sont pas pris en charge, et l'organisation ne doit utiliser ni configuration HIPAA ni conservation zéro des données."
  - question: "Les 77 % de tokens en moins s'appliquent-ils à tous les usages ?"
    answer: "Non. Dans le benchmark de Bicameral AI, l'économie de tokens traités va de 62 % à 77 % pour totaliser 120 enregistrements récupérés via un outil, de 40 % à 68 % pour les lire et les juger, et de 15 % à 54 % sur le travail de fichiers selon le modèle (avec 9 % de plus sur Haiku 5.5). Le dépôt ne donne aucun pourcentage global et rappelle que « tokens traités » n'est pas un coût : la majorité de ces tokens vient du cache de prompt, facturé moins cher."
---

Code Mode est une fonctionnalité expérimentale de Claude Code : au lieu de demander ses appels d'outils un par un, Claude écrit un morceau de JavaScript qui effectue ces appels, et seul ce que ce code renvoie entre dans la conversation. L'objectif affiché est double : garder les résultats intermédiaires hors du contexte et réduire le nombre d'allers-retours avec le modèle.

Cet article s'appuie sur la vidéo, la [documentation officielle de Code Mode](https://code.claude.com/docs/fr/code-mode) et le [benchmark public de Bicameral AI](https://github.com/Bicameral-AI/claude-code-mode-benchmark). Aucune commande n'a été exécutée pour cet article : les étapes et les limites viennent de la documentation, les chiffres du dépôt de benchmark, et le test présenté dans la vidéo reste attribué à la vidéo.

## Ce que change Code Mode

Sans Code Mode, Claude demande directement des appels d'outils comme Bash, Read ou Edit, et lit chaque résultat avant de décider de la suite. Avec Code Mode, il écrit du JavaScript qui effectue les appels, et Claude Code exécute ce code dans ta session.

Un seul morceau de code peut lancer des commandes en parallèle, réutiliser un résultat dans l'appel suivant et ne renvoyer que la partie de la sortie que Claude doit lire. La documentation illustre le principe avec cet exemple de modification suivie d'un test (documenté, non exécuté pour cet article) :

```javascript
const files = await $`rg -l "function retryPolicy" src`.text();
const target = files.trim().split('\n')[0];
await edit(target, 'maxAttempts: 3', 'maxAttempts: 5');
({ edited: target, tests: $`npm test -- retryPolicy`.nothrow() });
```

Dans la conversation, tu vois les appels d'outils, comme le diff de la modification, et non le code. Pour lire le JavaScript, `Ctrl+O` ouvre la visionneuse de transcription : chaque morceau y apparaît sur une ligne **Code** que tu peux déplier.

L'idée n'est pas propre à Anthropic. D'après l'[aperçu du dépôt de benchmark](https://github.com/Bicameral-AI/claude-code-mode-benchmark/blob/main/CODE_MODE_OVERVIEW.md), Cloudflare a nommé le concept Code Mode en septembre 2025 et Anthropic a suivi en novembre, puis Codex CLI, OpenCode, goose et Claude Code l'ont intégré au fil de 2026. La maturité reste inégale : stable sur l'API Claude, expérimental dans Claude Code, et absent de Gemini CLI, Cursor et GitHub Copilot CLI d'après ce recensement.

## Le benchmark MCP : jusqu'à 77 % de tokens en moins, mais pas partout

Le dépôt de Bicameral AI est un benchmark reproductible : six petites tâches, chacune lancée deux fois avec Code Mode désactivé puis activé, sur quatre modèles (Opus 5.5, Sonnet 5.5, Haiku 5.5 et Fable 5.2), sur Claude Code 2.1.326. Chaque exécution passe par une nouvelle session, avec le même prompt, les mêmes fichiers de départ et un vérificateur qui note le résultat ; les chiffres sont lus dans la transcription enregistrée par Claude Code, pas à l'écran.

Dans la vidéo, le test du benchmark MCP donne -76,2 % de tokens traités, et Bicameral AI annonce jusqu'à 77 %. Le dépôt détaille d'où vient ce chiffre, et il ne s'applique pas à tous les types de travail :

- **Totaliser 120 enregistrements récupérés via un outil** (le cas visé) : 62 % à 77 % de tokens traités en moins selon le modèle.
- **Lire et juger ces mêmes enregistrements** : 40 % à 68 %.
- **Chercher et modifier des fichiers** : 15 % à 54 % d'économie sur trois modèles, et 9 % de tokens en plus sur Haiku 5.5.
- **La question de contrôle** (une question sur un fichier) : 29 % à 30 %, ce qui mesure surtout la taille du démarrage.

Le dépôt insiste sur plusieurs réserves avant de citer ces chiffres :

- **Aucun pourcentage global** n'est donné pour les six tâches réunies : le total dépend du mélange de tâches, et trois des six tests font 120 appels d'outils chacun, là où Code Mode est le plus à son avantage.
- **Tokens traités n'est pas un coût** : la majorité de ces tokens est relue depuis le cache de prompt, facturé à un tarif inférieur.
- **Sur le travail de fichiers**, l'économie vient surtout du démarrage : chaque session Code Mode commence environ 13 000 tokens plus petit, que Claude écrive déjà un script complet ou non.
- **L'anomalie de Haiku 5.5** tient à une seule exécution dont le script cherchait les fichiers dans le mauvais dossier, avec 344 de ses 349 commandes shell en échec.

Le chiffre à retenir n'est donc pas « 77 % » en général, mais « jusqu'à 77 % là où des appels d'outils ramènent de gros résultats intermédiaires ».

## Prérequis

Avant d'essayer, la documentation liste les conditions suivantes :

- **Version** : Claude Code v2.1.323 ou plus récent, sur l'un ou l'autre canal de publication ; une version antérieure démarre sans Code Mode.
- **Compte** : un abonnement Claude ou un compte Console. Code Mode ne passe pas par une passerelle, Amazon Bedrock, Claude Platform on AWS, Agent Platform de Google Cloud ni Microsoft Foundry.
- **Organisation** : ni configuration HIPAA ni conservation zéro des données.
- **Modèle** : Opus 5.5, Sonnet 5.5, Haiku 5.5 ou Fable 5.2.
- **Surface** : une session `claude` interactive dans un terminal. Le panneau VS Code, l'application Desktop et les sessions cloud ne fonctionnent pas.
- **Équipes d'agents** : la v2.1.326 ou plus récent pour l'utiliser avec les équipes d'agents activées.
- **Installation** : le build natif de Claude Code, et Git for Windows installé sous Windows.

## Activer Code Mode

1. **Vérifier la version** avec `claude --version`. Si elle est antérieure à la v2.1.323, lance `claude update` ; sur le canal `stable`, attends que la mise à jour arrive ou passe au canal `latest`.

2. **Démarrer avec la variable d'environnement** `CLAUDE_CODE_EXPERIMENTAL_CODE_MODE` à `1` :

```bash
CLAUDE_CODE_EXPERIMENTAL_CODE_MODE=1 claude
```

Sous Windows PowerShell :

```powershell
$env:CLAUDE_CODE_EXPERIMENTAL_CODE_MODE = "1"
claude
```

Pour l'activer à chaque nouvelle session, place ce bloc `env` dans `~/.claude/settings.json` :

```json
{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_CODE_MODE": "1"
  }
}
```

Claude Code ignore cette variable dans les fichiers de paramètres d'un projet : un dépôt que tu clones ne peut donc pas activer Code Mode à ta place.

3. **Confirmer** au premier lancement en choisissant « Yes, turn on Code Mode ». La session affiche alors la ligne `Code Mode (experimental) is on · this session can be resumed only with Code Mode on`. Une ligne différente indique une raison de non-démarrage, également visible dans `/status`.

4. **Confier une tâche avec beaucoup d'appels d'outils**, par exemple le prompt de la documentation : `Read every Markdown file in this project and list the links that point to local files that don't exist.`

5. **Lire le code** avec `Ctrl+O`, puis déplier une ligne **Code** pour voir le JavaScript derrière les appels d'outils.

Pour désactiver Code Mode, retire `CLAUDE_CODE_EXPERIMENTAL_CODE_MODE` de ton shell et de `~/.claude/settings.json`, ou passe sa valeur à `0`. Une organisation peut le bloquer avec `"CLAUDE_CODE_EXPERIMENTAL_CODE_MODE": "0"` dans les paramètres gérés ; en revanche, elle ne peut pas l'activer à distance depuis ces mêmes paramètres.

## Permissions, sandbox et code long

- **Modes de permission** : en mode auto et en mode `bypassPermissions`, le code peut s'exécuter du début à la fin sans demande de permission, sauf pour les actions qu'aucun mode n'approuve automatiquement. Chaque appel contenu dans le code passe tout de même par tes règles `deny` et `ask` et par tes hooks `PreToolUse`, sous le nom habituel de l'outil.
- **Le classifieur voit le code, pas chaque appel** : en mode auto, il examine le morceau de code avant son exécution et ne voit pas les valeurs calculées à l'exécution, comme un chemin tiré d'une sortie de recherche.
- **Inspecter ou masquer** : un hook `PreToolUse` sur `REPL` lit le JavaScript dans `tool_input.code` ; un hook `PostToolUse` sur `REPL` peut modifier `result`, `stdout`, `stderr` ou `error` via `updatedToolOutput`. Une règle `ask: ["REPL"]` te fait approuver chaque morceau de code avant son démarrage.
- **Sandbox** : tes paramètres de sandbox s'appliquent aux commandes shell lancées par le code ; le JavaScript lui-même et ses appels de fichiers, web et MCP s'exécutent en dehors.
- **Code long** : Claude attend la fin, avec un arrêt automatique à dix minutes, ou laisse le code tourner en arrière-plan jusqu'à deux heures si la session est en mode auto ou `bypassPermissions`. `Esc` arrête le code, et `/tasks` liste les commandes, sous-agents et appels MCP encore en cours.

## Limites à connaître

- **Expérimental et désactivé par défaut** : Code Mode peut changer ou être supprimé dans n'importe quelle version ; les retours passent par `/feedback`.
- **Reprise** : une session Code Mode ne se reprend que dans le terminal, avec Code Mode activé. Une session démarrée sans lui reprend sans lui, même si la variable est définie.
- **Fonctionnalités indisponibles** : Remote Control, Claude in Chrome et computer use. Tu ne peux pas non plus déplacer la session vers l'application Desktop ou en faire une session en arrière-plan, et `/fork` ne démarre pas de copie en arrière-plan.
- **Hooks** : un hook `PreToolUse` qui expire ou ne rend pas de décision peut produire des appels d'outils refusés.

## Faut-il l'activer ?

Code Mode vise un profil de tâche précis : beaucoup d'appels d'outils liés, dont les résultats intermédiaires n'ont pas besoin d'occuper la conversation. C'est là que les chiffres du benchmark sont les plus nets. Sur du travail de fichiers qu'un script shell sait déjà faire, le gain se limite surtout au démarrage plus léger, et un modèle a même consommé plus de tokens avec Code Mode.

Comme la fonctionnalité est expérimentale, indisponible derrière une passerelle ou Bedrock, et qu'un volume de tokens ne se traduit pas directement en facture (la majorité des tokens du benchmark viennent du cache de prompt), l'approche raisonnable est de l'essayer sur une tâche représentative de ton usage et de comparer, plutôt que de l'activer par défaut.

Pour situer Code Mode à côté des autres leviers d'économie sur Claude Code, tu peux le comparer au [mode Concise](/blog/claude-code-ce-nouveau-mode-economise-t-il-vraiment-des-tokens/), qui agit sur la longueur des réponses, à [RTK](/blog/claude-code-j-ai-reduit-mes-tokens-de-90-grace-a-rtk/), qui filtre les sorties shell verbeuses, ou à [Caveman](/blog/claude-code-jusqu-a-75-moins-cher-avec-caveman/), qui compresse le contexte envoyé au modèle. Si tu débutes avec l'outil, commence par le [guide complet de Claude Code](/blog/claude-code-le-guide-complet-pour-bien-debuter/).

La vidéo ci-dessous montre le test du benchmark MCP, ce que ça donne sur un vrai projet et comment activer Code Mode.

## Pour approfondir

**[Guide Claude Code](https://pentiminax.fr/blog/claude-code.md)**

Retrouve les guides du site dans un parcours unique : prise en main, coûts et tokens, usages avancés et écosystème.

[Explorer le guide Claude Code](https://pentiminax.fr/blog/claude-code.md)

## Questions fréquentes

**Code Mode est-il activé par défaut dans Claude Code ?**

Non. Code Mode est expérimental et désactivé par défaut : il faut définir `CLAUDE_CODE_EXPERIMENTAL_CODE_MODE` à `1` dans ton shell ou dans `~/.claude/settings.json`. La documentation précise qu'il peut changer ou être supprimé dans n'importe quelle version.

**Quelles versions et quels modèles faut-il pour Code Mode ?**

Claude Code v2.1.323 ou plus récent (v2.1.326 pour les équipes d'agents), avec un modèle Opus 5.5, Sonnet 5.5, Haiku 5.5 ou Fable 5.2. Il faut aussi une session `claude` interactive dans un terminal, un abonnement Claude ou un compte Console, et le build natif de Claude Code.

**Peut-on reprendre une session Code Mode plus tard ?**

Oui, mais uniquement dans le terminal et avec Code Mode activé : garde `CLAUDE_CODE_EXPERIMENTAL_CODE_MODE` à `1` quand tu lances `claude --continue` ou `claude --resume`. Sans la variable, Claude Code refuse de reprendre la session. Une session démarrée sans Code Mode reprend sans lui, même si la variable est définie.

**Code Mode fonctionne-t-il derrière une passerelle ou Amazon Bedrock ?**

Non. La documentation exige l'API Anthropic directement : les passerelles, Amazon Bedrock, Claude Platform on AWS, Agent Platform de Google Cloud et Microsoft Foundry ne sont pas pris en charge, et l'organisation ne doit utiliser ni configuration HIPAA ni conservation zéro des données.

**Les 77 % de tokens en moins s'appliquent-ils à tous les usages ?**

Non. Dans le benchmark de Bicameral AI, l'économie de tokens traités va de 62 % à 77 % pour totaliser 120 enregistrements récupérés via un outil, de 40 % à 68 % pour les lire et les juger, et de 15 % à 54 % sur le travail de fichiers selon le modèle (avec 9 % de plus sur Haiku 5.5). Le dépôt ne donne aucun pourcentage global et rappelle que « tokens traités » n'est pas un coût : la majorité de ces tokens vient du cache de prompt, facturé moins cher.
