Guide de la CLI Claude Code : installation, configuration, commandes et variables d’environnement

TL;DR : Claude Code est un CLI agentique qui lit votre base de code, exécute des commandes et modifie des fichiers grâce à un système à plusieurs niveaux composé d’autorisations, de hooks, d’intégrations MCP et de subagents. Maîtrisez cinq systèmes fondamentaux (configuration, autorisations, hooks, MCP et subagents) et vous décuplerez votre productivité. Choisissez le niveau de modèle adapté à chaque tâche — Opus pour les raisonnements complexes, Sonnet pour les travaux courants, Haiku pour l’exploration rapide — ou utilisez systématiquement Opus si la qualité est votre seul critère. Pour tout ce qui doit toujours s’exécuter, utilisez des hooks (et non des prompts). Depuis la v2.1.197 (30 juin 2026), Claude Sonnet 5 est le modèle par défaut dans Claude Code — contexte natif de 1M, tarif promotionnel de 2 $/10 $ jusqu’au 31 août — tandis qu’Opus reste accessible avec un simple /model opus (depuis la v2.1.219, cet alias sélectionne Claude Opus 5) ; la v2.1.198 (1er juillet) fait exécuter les subagents en arrière-plan par défaut, rend Claude dans Chrome disponible pour tous, permet aux agents en arrière-plan d’effectuer un commit, un push et d’ouvrir une draft PR lorsqu’ils terminent du code dans un worktree, et déclenche le hook Notification (agent_needs_input/agent_completed) pour les sessions en arrière-plan ; la v2.1.199 (2 juillet) charge jusqu’à 5 invocations empilées de slash-skills et relance automatiquement les requêtes après des erreurs 429 temporaires pour les abonnés ; la v2.1.200 (3 juillet) renomme le mode d’autorisation default en « Manual » dans le CLI, --help, VS Code et JetBrains (la valeur de configuration ne change pas et manual est accepté comme alias), et empêche par défaut les boîtes de dialogue AskUserQuestion de poursuivre automatiquement ; la v2.1.202 (6 juillet) ajoute un réglage /config « Dynamic workflow size » et rétablit /review <pr> comme revue rapide en un seul passage, tandis que le passage multi-agent est transféré vers /code-review <level> <pr#> ; les v2.1.203–205 (du 7 au 9 juillet) renforcent le mode auto — les fichiers de transcription sont protégés contre les altérations, rm -rf demande d’abord confirmation lorsqu’une variable ne peut pas être résolue, et les notifications des tâches en arrière-plan indiquent qu’aucune intervention humaine n’a eu lieu (les fausses approbations intégrées à une transcription ne peuvent donc pas être suivies d’effet) — et transforment /doctor en diagnostic complet avec correction (/checkup comme alias).^181182183 La v2.1.217 (21 juillet) a fait marche arrière sur les subagents imbriqués — les subagents ont cessé de créer leurs propres subagents par défaut (un choix que la v2.1.219 a de nouveau inversé trois jours plus tard, en fixant la profondeur à 3 ; voir ci-dessous), 20 subagents au maximum s’exécutent simultanément par défaut (CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS), et --max-budget-usd arrête désormais réellement les subagents en arrière-plan une fois le plafond atteint.¹⁹⁴ La v2.1.218 (22 juillet) transfère /code-review à un subagent en arrière-plan — le travail de revue n’encombre plus votre conversation —, exécute par défaut en arrière-plan les skills context: fork (désactivation possible pour chaque skill avec background: false), ne lance /deep-research que sur invocation explicite, confie les vérifications des commandes rm dangereuses, des processus d’arrière-plan & et des chemins Windows suspects au classificateur du mode auto plutôt qu’aux boîtes de dialogue d’autorisation, et empêche l’exécution des hooks définis dans le frontmatter des agents provenant de dossiers non fiables.¹⁹⁵ La v2.1.219 (24 juillet) fait de Claude Opus 5 (claude-opus-5) le modèle Opus par défaut — contexte de 1M, sortie maximale de 128K, 5 $/25 $ par MTok (tarif identique à Opus 4.8), thinking activé par défaut, effort réglé par défaut sur high, connaissances arrêtées en mai 2026 — et rectifie deux changements introduits par les versions précédentes : le mode rapide s’applique désormais à Opus 5 et Opus 4.8 au tarif de 10 $/50 $ par MTok (2× le tarif de base, tandis qu’Opus 4.7 est entièrement retiré du mode rapide), et les subagents imbriqués sont de nouveau activés par défaut, avec une profondeur de 3 (CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH=1 désactive l’imbrication). Cette même version ajoute l’événement de hook DirectoryAdded, le paramètre sandbox.network.strictAllowlist, une clé de paramètres workflowSizeGuideline, les workflows dynamiques adoptant désormais par défaut une recommandation de taille moyenne (visez moins de 15 agents), ainsi que la transmission des subagents imbriqués dans stream-json. La v2.1.220 (25 juillet) ne contient que des corrections de bugs et des améliorations de fiabilité.^196197198 Depuis les v2.1.174–176 (12 juin 2026), l’allowlist availableModels peut désormais restreindre le modèle Default grâce au nouveau paramètre géré enforceAvailableModels (les paramètres utilisateur ou de projet ne peuvent pas élargir une liste administrée), les titres de session sont générés dans la langue de votre conversation (fixez-en une avec le paramètre language), et la version est complétée par les nouveaux paramètres footerLinksRegexes et wheelScrollAccelerationEnabled, une boîte de dialogue d’attribution /usage dans VSCode, ainsi qu’une correction permettant aux conditions if des hooks de reconnaître les motifs de chemin Read/Edit/Write.¹⁷² Depuis la v2.1.173 (11 juin 2026), le suffixe [1m] ajouté au nom du modèle Fable 5 est automatiquement normalisé/supprimé — Fable 5 inclut déjà un contexte de 1M par défaut, ce suffixe est donc inutile (il n’a jamais eu de sens que pour Opus/Sonnet). Depuis la v2.1.172 (10 juin 2026), les subagents pouvaient créer récursivement leurs propres subagents, jusqu’à 5 niveaux de profondeur — un comportement par défaut maintenu jusqu’à la v2.1.216, puis désactivé dans la v2.1.217 (voir ci-dessus) —, Bedrock lit sa région depuis ~/.aws lorsque AWS_REGION n’est pas défini (/status indique la source), /plugin ajoute une barre de recherche pour la marketplace, et la métrique OTEL claude_code.lines_of_code.count reçoit un attribut model. Depuis la v2.1.170 (9 juin 2026), Claude Fable 5 — un nouveau niveau de modèle supérieur à Opus — peut être sélectionné dans Claude Code avec /model fable après claude update (il prend en charge toute l’échelle d’effort de low à max, mais son thinking ne peut pas être désactivé) ; Opus 4.8 reste le modèle agentique par défaut. Depuis la v2.1.169 (8 juin 2026), --safe-mode (ainsi que CLAUDE_CODE_SAFE_MODE) lance, à des fins de dépannage, une session vierge dans laquelle toutes les personnalisations sont désactivées, /cd déplace une session vers un nouveau répertoire de travail sans perturber le cache des prompts, et disableBundledSkills masque au modèle les skills et slash commands intégrés. Depuis la v2.1.166 (6 juin 2026), un paramètre fallbackModel enchaîne jusqu’à trois modèles de secours lorsque le modèle principal est surchargé, le glob "*" fonctionne dans les règles de refus MCP, et MAX_THINKING_TOKENS=0 / --thinking disabled désactivent entièrement le thinking sur les modèles où il est activé par défaut. Depuis la v2.1.154 (28 mai 2026), Opus 4.8 est le nouveau modèle par défaut, avec un effort élevé par défaut et un niveau /effort xhigh, les workflows dynamiques orchestrent des dizaines ou des centaines d’agents en arrière-plan via /workflows, le mode rapide sur Opus 4.8 coûte 2× le tarif standard pour une vitesse 2,5× supérieure, le lean system prompt est désormais utilisé par défaut pour tous les modèles sauf Haiku/Sonnet/Opus 4.7 et versions antérieures, /simplify est revenu à une revue limitée au nettoyage (distincte de /code-review --fix), claude agents accepte ! <command> pour créer des sessions shell en arrière-plan, les plugins peuvent déclarer defaultEnabled: false, l’exécution en streaming des outils est toujours activée, et les serveurs MCP stdio reçoivent CLAUDE_CODE_SESSION_ID ainsi que CLAUDECODE=1 dans leur environnement. La v2.1.153 a ajouté skipLfs aux marketplaces de plugins, fait en sorte que /model enregistre le modèle comme valeur par défaut (appuyez sur s pour l’appliquer uniquement à la session) et ajouté COLUMNS/LINES à l’environnement de la ligne d’état. La v2.1.152 a introduit /code-review --fix (qui applique les conclusions à l’arborescence de travail), disallowed-tools dans le frontmatter des skills, /reload-skills, le nouvel événement de hook MessageDisplay, les sorties reloadSkills/sessionTitle du hook SessionStart, le paramètre géré pluginSuggestionMarketplaces, le changement de --fallback-model en cours de session, et supprimé l’activation volontaire du mode auto.^{162 163 164 165 166 167 168 169 170 206 171}

Claude Code fonctionne comme un système agentique, et non comme une interface de chat dotée de connaissances en programmation. Le CLI lit votre base de code, exécute des commandes, modifie des fichiers, gère les workflows git, se connecte à des services externes via MCP et délègue les tâches complexes à des subagents spécialisés. Tout passe par une interface en ligne de commande qui s’intègre à la façon dont les développeurs travaillent réellement. En février 2026, 4 % des commits GitHub publics (environ 135 000 par jour) sont créés par Claude Code — soit une croissance de 42 896× en 13 mois depuis la research preview — et 90 % du propre code de Anthropic est écrit par l’IA.¹⁰³

La différence entre une utilisation occasionnelle et efficace de Claude Code repose sur cinq systèmes fondamentaux. Maîtrisez-les et Claude Code décuplera votre efficacité :

1. Hiérarchie de configuration : contrôle le comportement
2. Système d’autorisations : contrôle les opérations
3. Système de hooks : permet une automatisation déterministe
4. Protocole MCP : étend les capacités
5. Système de subagents : prend en charge les tâches complexes comportant plusieurs étapes

Points clés

• Cinq systèmes déterminent votre efficacité : la hiérarchie de configuration, les autorisations, les hooks, MCP et les subagents contrôlent tous les aspects, du comportement à l’automatisation.
• Transférez le travail vers la couche de délégation : les subagents évitent de saturer le contexte en isolant l’exploration dans des fenêtres de contexte vierges et en ne renvoyant que des synthèses.
• Les hooks garantissent l’exécution, contrairement aux prompts : utilisez des hooks pour le linting, le formatage et les contrôles de sécurité qui doivent s’exécuter à chaque fois, quel que soit le comportement du modèle.
• La répartition par niveau de modèle réduit les coûts sans sacrifier la qualité : confiez l’exploration des subagents à des modèles moins chers et réservez Opus aux véritables raisonnements architecturaux — ou utilisez systématiquement Opus si la qualité est votre seul critère.
• MCP connecte Claude à votre chaîne d’outils : les bases de données, GitHub, Sentry et plus de 3 000 intégrations étendent les capacités de Claude au-delà de la lecture de fichiers et des commandes bash.

J’ai passé des mois à pousser Claude Code dans ses retranchements sur des bases de code en production, des pipelines CI/CD et des déploiements en entreprise. Ce guide condense cette expérience dans la référence complète que j’aurais aimé avoir à mes débuts. Chaque fonctionnalité présente la syntaxe exacte, de véritables exemples de configuration et les cas limites qui piègent même les utilisateurs expérimentés.

Choisissez votre parcours

Comment utiliser ce guide

Cette référence compte plus de 5 000 lignes — nul besoin de la lire intégralement. Commencez par la section adaptée à votre niveau d’expérience :

Utilisez Ctrl+F / Cmd+F dans votre navigateur pour rechercher des flags, des commandes ou des clés de configuration spécifiques. La fiche de référence rapide, située à la fin, propose un résumé facile à parcourir de toutes les commandes principales.

Analyses connexes approfondies

Ces articles de blog explorent en détail certains aspects de Claude Code :

Démarrage rapide en 60 secondes

Si vous voulez simplement lancer Claude Code et voir une sortie, procédez dans cet ordre :

# 1. Install (pick one)
npm install -g @anthropic-ai/claude-code          # npm users
brew install anthropic/claude/claude              # macOS + Homebrew
curl -sL claude.ai/install.sh | sh                # native installer

# 2. Launch in any project directory
cd ~/your-project && claude

# 3. Authenticate (browser opens automatically on first run)
/login

# 4. Ask your first question
> What does this repo do? Read the key files and summarize.

C’est tout. Tout ce qui suit dans cette section détaille les options d’installation, configure les permissions et les hooks, connecte les serveurs MCP et couvre le déploiement en entreprise — mais rien de tout cela n’est nécessaire pour démarrer.

Prérequis : Node 18+ uniquement pour l’ancien chemin npm ; l’installateur natif recommandé ne dépend pas de Node. macOS / Linux / Windows 10+ sont pris en charge. Un abonnement Claude Pro, Max, Team ou Enterprise, ou une clé Anthropic API à paiement par token, couvre l’utilisation. Consultez Comment installer Claude Code ? pour les spécificités par plateforme, le dépannage et le chemin du binaire natif (par défaut depuis la v2.1.113). Les éléments de preuve de la dernière version dans ce guide ont été vérifiés avec la v2.1.154.²⁰⁶

Fonctionnement de Claude Code : le modèle mental

Avant d’entrer dans les fonctionnalités, comprenez comment l’architecture de Claude Code façonne tout ce que vous faites avec lui. Le système fonctionne en trois couches :

┌─────────────────────────────────────────────────────────┐
│                    CLAUDE CODE LAYERS                    │
├─────────────────────────────────────────────────────────┤
│  EXTENSION LAYER                                         │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐    │
│  │   MCP   │  │  Hooks  │  │ Skills  │  │ Plugins │    │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘    │
│  External tools, deterministic automation, domain       │
│  expertise, packaged extensions                          │
├─────────────────────────────────────────────────────────┤
│  DELEGATION LAYER                                        │
│  ┌─────────────────────────────────────────────────┐    │
│  │              Subagents (up to 10 parallel)       │    │
│  │   Explore | Plan | General-purpose | Custom      │    │
│  └─────────────────────────────────────────────────┘    │
│  Isolated contexts for focused work, returns summaries  │
├─────────────────────────────────────────────────────────┤
│  CORE LAYER                                              │
│  ┌─────────────────────────────────────────────────┐    │
│  │         Main Conversation Context                │    │
│  │   Tools: Read, Edit, Bash, Glob, Grep, etc.     │    │
│  └─────────────────────────────────────────────────┘    │
│  Your primary interaction; limited context; costs money │
└─────────────────────────────────────────────────────────┘

Couche centrale : votre conversation principale. Chaque message, lecture de fichier et sortie d’outil consomme du contexte dans une fenêtre partagée (200K tokens en standard⁹¹, 1M tokens avec Opus 4.6 ou les modèles à contexte étendu). Quand le contexte se remplit, Claude perd le fil des décisions précédentes et la qualité se dégrade. Cette couche coûte de l’argent par token.

Couche de délégation : les subagents démarrent avec des contextes propres, effectuent un travail ciblé et renvoient des résumés. Les résultats d’exploration ne gonflent pas votre conversation principale ; seules les conclusions reviennent. Orientez les subagents vers des niveaux de modèle moins coûteux pour l’exploration, ou utilisez votre modèle principal partout si la qualité compte davantage que le coût.

Couche d’extension : MCP connecte des services externes (bases de données, GitHub, Sentry). Les hooks garantissent l’exécution de commandes shell indépendamment du comportement du modèle. Les skills encodent l’expertise métier que Claude applique automatiquement. Les plugins regroupent tout cela pour la distribution.

L’idée clé : la plupart des utilisateurs travaillent entièrement dans la couche centrale, regardant le contexte gonfler et les coûts grimper. Les utilisateurs avancés transfèrent l’exploration et le travail spécialisé vers la couche de délégation, gardent la couche d’extension configurée pour leur workflow, et n’utilisent la couche centrale que pour l’orchestration et les décisions finales.

Table des matières

1. Comment installer Claude Code ?
2. Démarrage rapide : votre première session
3. Modes d’interaction principaux
4. Exploration approfondie du système de configuration
5. Quel modèle choisir ?
6. Combien coûte Claude Code ?
7. Cadres de décision
8. Comment fonctionne le système de permissions ?
9. Comment fonctionnent les hooks ?
10. Qu’est-ce que MCP (Model Context Protocol) ?
11. Que sont les subagents ?
12. Qu’est-ce que le mode Extended Thinking ?
13. Styles de sortie
14. Slash Commands
15. Comment fonctionnent les skills ?
16. Système de plugins
17. Comment fonctionne la mémoire ?
18. Entrée image et multimodale
19. Mode vocal
20. Comment fonctionne l’intégration Git ?
21. Comment utiliser Claude Code dans mon IDE ?
22. Modèles d’utilisation avancés
23. Agents distants et en arrière-plan [APERÇU DE RECHERCHE]
24. Claude dans Chrome
25. Claude Code dans Slack [APERÇU DE RECHERCHE]
26. Claude Code sur le Web [APERÇU DE RECHERCHE]
27. Optimisation des performances
28. Comment déboguer les problèmes ?
29. Déploiement en entreprise
30. Référence des raccourcis clavier
31. Bonnes pratiques
32. Recettes de workflow
33. Guide de migration
34. Conseils par public
35. Fiche de référence rapide
36. Changelog
37. Références

Comment installer Claude Code ?

Configuration système requise

Claude Code fonctionne sur macOS 13+, Ubuntu 20.04+/Debian 10+ et Windows 10+ (natif ou WSL). Le système nécessite au minimum 4 Go de RAM et une connexion internet active.⁹² La compatibilité shell est optimale avec Bash, Zsh ou Fish.

Pour Windows, WSL 1 et WSL 2 fonctionnent tous les deux. Git Bash fonctionne également si vous préférez Windows natif. Alpine Linux et les autres systèmes basés sur musl nécessitent des paquets supplémentaires :

apk add libgcc libstdc++ ripgrep
export USE_BUILTIN_RIPGREP=0

Matrice de prise en charge des plateformes

Installation, mise à jour et désinstallation en un coup d’œil

Référence à parcourir : chaque méthode, chaque commande, vérification de version sur un seul écran. Les sous-sections ci-dessous couvrent les spécificités et le dépannage par méthode.

Depuis la v2.1.113, le CLI canonique lance un binaire Claude Code natif via une dépendance optionnelle par plateforme au lieu de JavaScript intégré — utilisez l’installateur natif pour la distribution testée. La voie npm fonctionne toujours mais reçoit l’avis de dépréciation initialement ajouté dans la v2.1.15.

Méthodes d’installation

Installation native (recommandée)

Le binaire natif offre l’expérience la plus propre, sans dépendance à Node.js :

# macOS and Linux
curl -fsSL https://claude.ai/install.sh | bash

# Homebrew alternative
brew install --cask claude-code

# Windows PowerShell
irm https://claude.ai/install.ps1 | iex

# Windows CMD
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

Pour une installation d’une version spécifique :

# Install specific version
curl -fsSL https://claude.ai/install.sh | bash -s 1.0.58

# Install latest explicitly
curl -fsSL https://claude.ai/install.sh | bash -s latest

# Windows PowerShell - specific version
& ([scriptblock]::Create((irm https://claude.ai/install.ps1))) 1.0.58

Installation NPM (dépréciée)

Note : Depuis la v2.1.15, les installations npm affichent un avis de dépréciation. Le binaire natif est désormais la méthode d’installation recommandée. Migrez avec claude install.

Pour les environnements anciens où npm est encore nécessaire :

npm install -g @anthropic-ai/claude-code

N’utilisez jamais sudo avec l’installation npm. Cela crée des problèmes de permissions qui compliquent tout par la suite.

Migration depuis une installation existante

Si vous disposez d’une ancienne installation basée sur npm, migrez vers le binaire natif :

claude install

Options d’authentification

Claude Code prend en charge trois voies d’authentification, chacune avec des compromis différents :

Console Claude (facturation API)

Connectez-vous directement à la API d’Anthropic via platform.claude.com (anciennement console.anthropic.com). Créez un compte, configurez la facturation et authentifiez-vous via le CLI. La Console offre une facturation à l’usage avec un accès complet à l’API. Un espace de travail dédié « Claude Code » est créé automatiquement ; vous ne pouvez pas créer de clés API pour cet espace de travail, mais vous pouvez surveiller l’utilisation.

Abonnement Claude Pro ou Max

Utilisez les identifiants de votre compte claude.ai. L’abonnement couvre à la fois l’interface web et l’utilisation du CLI dans le cadre d’un seul forfait mensuel. L’abonnement simplifie la facturation pour les utilisateurs individuels qui souhaitent des coûts prévisibles.

Plateformes d’entreprise

AWS Bedrock, Google Vertex AI et Microsoft Foundry offrent chacune un accès de niveau entreprise avec des relations de facturation cloud existantes. Assistant de configuration Bedrock (v2.1.92+) : un assistant interactif sur l’écran de connexion vous guide à travers l’authentification AWS, la sélection de la région, la vérification des identifiants et l’épinglage du modèle.¹³⁷ Assistant de configuration Vertex AI (v2.1.98+) : un assistant équivalent pour Google Cloud, guidant l’authentification GCP, la configuration du projet et de la région, la vérification des identifiants et l’épinglage du modèle.¹⁴² Vertex AI mTLS Workload Identity Federation (v2.1.121+) : Vertex AI accepte désormais la Workload Identity Federation basée sur des certificats X.509 (mTLS Application Default Credentials) — des jetons GCP de courte durée frappés à partir d’un certificat client, sans JSON de compte de service requise.¹⁵⁴ Confiance des certificats CA du système d’exploitation (v2.1.101+) : les proxys TLS d’entreprise fonctionnent désormais par défaut — Claude Code fait confiance au magasin de certificats du système d’exploitation. Définissez CLAUDE_CODE_CERT_STORE=bundled pour utiliser uniquement les CA intégrées.¹⁴³

# AWS Bedrock
export CLAUDE_CODE_USE_BEDROCK=1
export AWS_REGION=us-east-1
export AWS_PROFILE=your-profile

# Google Vertex AI
export CLAUDE_CODE_USE_VERTEX=1
export CLOUD_ML_REGION=us-east5
export ANTHROPIC_VERTEX_PROJECT_ID=your-project

# Microsoft Foundry
export CLAUDE_CODE_USE_FOUNDRY=1
export ANTHROPIC_FOUNDRY_RESOURCE=your-resource-name
# Optional: API key auth (otherwise uses Entra ID)
export ANTHROPIC_FOUNDRY_API_KEY=your-key

# Amazon Bedrock via Mantle (v2.1.94+)
export CLAUDE_CODE_USE_MANTLE=1

Pour les déploiements en entreprise derrière des proxys ou via des passerelles LLM :

# Corporate proxy
export HTTPS_PROXY='https://proxy.example.com:8080'

# LLM gateway (skip native auth)
export CLAUDE_CODE_USE_BEDROCK=1
export ANTHROPIC_BEDROCK_BASE_URL='https://your-gateway.com/bedrock'
export CLAUDE_CODE_SKIP_BEDROCK_AUTH=1

Vérification

claude doctor

La commande indique le type d’installation, la version, la configuration système et tout problème détecté.

Gestion de l’authentification (v2.1.41+)

Gérez l’authentification sans entrer dans le REPL :⁹⁰

claude auth login          # Log in or switch accounts
claude auth status         # Check current auth state (account, plan, expiry)
claude auth logout         # Clear stored credentials

Flux de travail courant pour basculer entre des comptes ou organisations :

claude auth logout && claude auth login

Voir aussi : Comment déboguer les problèmes ? pour résoudre les échecs d’authentification.

Mises à jour

Claude Code se met à jour automatiquement par défaut, en vérifiant au démarrage et périodiquement pendant les sessions. Les mises à jour sont téléchargées en arrière-plan et appliquées au prochain lancement.

Désactiver les mises à jour automatiques :

export DISABLE_AUTOUPDATER=1

Ou dans settings.json :

{
  "env": {
    "DISABLE_AUTOUPDATER": "1"
  }
}

Mise à jour manuelle :

claude update

Désinstallation

Installation native (macOS/Linux/WSL) :

rm -f ~/.local/bin/claude
rm -rf ~/.claude-code

Installation native (Windows PowerShell) :

Remove-Item -Path "$env:LOCALAPPDATA\Programs\claude-code" -Recurse -Force
Remove-Item -Path "$env:LOCALAPPDATA\Microsoft\WindowsApps\claude.exe" -Force

Configuration propre (supprime tous les paramètres) :

rm -rf ~/.claude
rm ~/.claude.json
rm -rf .claude
rm -f .mcp.json

Démarrage rapide : votre première session

1. Installez et lancez :

claude                           # Launch in current directory

2. Accédez à un projet :

cd ~/my-project && claude        # Or launch from any git repo

3. Demandez à Claude d’effectuer une tâche :

> "Explain the architecture of this project"
> "Find all TODO comments and create a summary"
> "Add input validation to the signup form"

4. Utilisez les raccourcis clavier pendant votre session :

/cost                            # Check token usage and cost
/compact                         # Free up context when it gets large
Alt+T                            # Toggle extended thinking for hard problems
Ctrl+C                           # Cancel current response

5. Reprenez plus tard :

claude -c                        # Resume your most recent session
claude --resume                  # Pick from session list

Conseil d’expert : créez un fichier CLAUDE.md à la racine de votre projet avec les commandes de build, les conventions de codage et des notes sur l’architecture. Claude le lit à chaque session — c’est le moyen le plus efficace d’améliorer la qualité.

Modes d’interaction principaux

REPL interactif

Lancez Claude Code sans argument pour accéder à la boucle interactive de lecture-évaluation-affichage :

cd your-project
claude

Le REPL conserve le contexte de la conversation d’un échange à l’autre. Saisissez directement vos requêtes, recevez les réponses et poursuivez jusqu’à quitter avec /exit ou Ctrl+D.

Commencez par un prompt initial pour cibler la session :

claude "explain the authentication flow in this project"

Conseil d’expert : le REPL conserve son état lors des opérations de compactage. Lorsque le contexte devient trop volumineux, Claude résume automatiquement les échanges plus anciens tout en préservant les décisions clés et les extraits de code. Vous pouvez déclencher cette opération manuellement avec /compact ou ajouter des instructions personnalisées précisant les éléments à conserver.

Mode non interactif

Le mode d’affichage (-p) exécute une seule requête, puis se ferme :

# Direct query
claude -p "list all TODO comments in this project"

# Process piped input
cat error.log | claude -p "identify the root cause of these failures"

# Chain with other tools
claude -p "generate a README" > README.md

Pour obtenir une sortie structurée adaptée à l’analyse par des scripts :

claude -p "count lines by file type" --output-format json

La sortie JSON contient tout le nécessaire pour l’automatisation :

{
  "type": "result",
  "subtype": "success",
  "total_cost_usd": 0.0034,
  "is_error": false,
  "duration_ms": 2847,
  "duration_api_ms": 1923,
  "num_turns": 4,
  "result": "Response text here...",
  "session_id": "abc-123-def"
}

Pour traiter en temps réel une sortie en streaming :

claude -p "build the application" --output-format stream-json | while read line; do
  echo "$line" | jq -r 'select(.result) | .result'
done

Options de format de sortie :

Texte des subagents dans stream-json (v2.1.211+) : par défaut, la sortie stream-json ne contient que les événements de la session principale — le travail effectué dans les subagents apparaît sous forme de résumé. Le flag --forward-subagent-text (ou CLAUDE_CODE_FORWARD_SUBAGENT_TEXT=1) transmet également dans le flux le texte et le raisonnement des subagents, ce qui permet aux harnesses et aux pipelines de journaux d’observer le travail délégué au fur et à mesure, au lieu de voir uniquement le rapport final.¹⁸⁸

Les subagents imbriqués sont désormais transmis eux aussi (v2.1.219). À l’origine, seuls les subagents de profondeur 1 apparaissaient. Les subagents lancés à une profondeur de 2 ou plus figurent désormais également dans le flux transmis, chacun étant associé à l’identifiant tool_use de l’appel Agent qui l’a créé — un pipeline peut ainsi reconstruire l’arborescence de délégation au lieu de voir une simple liste de textes. Cette évolution va directement de pair avec le rétablissement, dans la même version, du lancement imbriqué jusqu’à une profondeur de 3 par défaut : sans cela, deux des trois niveaux seraient restés invisibles.¹⁹⁶

Codes de sortie :

Contrôle du comportement agentique en mode -p :

# Limit autonomous turns (prevents runaway loops)
claude -p "refactor the auth module" --max-turns 10

# Allow specific tools without prompting
claude -p "fix lint errors" --allowedTools "Edit,Bash(npm run lint)"

# Use with a specific model
claude -p "explain this code" --model claude-sonnet-4-5-20250929

# Bare mode: skip hooks, LSP, plugin sync, skill walks (v2.1.81+)
claude -p "count files" --bare

# Channel permission relay: send approval prompts to Telegram/Discord (v2.1.81+)
claude --channels

Modèle d’intégration CI/CD :

# In a GitHub Action or CI pipeline
result=$(claude -p "review this diff for security issues" --output-format json 2>/dev/null)
is_error=$(echo "$result" | jq -r '.is_error')
if [ "$is_error" = "true" ]; then
  echo "Review failed"
  exit 1
fi
echo "$result" | jq -r '.result'

Gestion des sessions

Les sessions conservent l’historique des conversations afin de pouvoir les poursuivre. Cette persistance est essentielle pour les tâches complexes réparties sur plusieurs sessions :

# Continue most recent session
claude -c

# Continue with additional prompt
claude -c -p "now add error handling"

# Resume specific session by ID
claude -r "abc123" "implement the remaining tests"

# Fork a session for parallel exploration
claude -r "base-session" --fork-session "try a different approach"

Sessions liées aux PR (v2.1.27+, étendu en v2.1.119+) : démarrez une session liée à une pull request ou merge request précise. Depuis la v2.1.119, --from-pr accepte les URL de MR GitLab, de PR Bitbucket et de PR GitHub Enterprise, en plus de celles de github.com :⁷⁴¹⁵²

claude --from-pr 123                                                # GitHub PR number (assumes current repo's remote)
claude --from-pr https://github.com/org/repo/pull/123               # GitHub URL
claude --from-pr https://gitlab.com/org/repo/-/merge_requests/45    # GitLab MR (v2.1.119+)
claude --from-pr https://bitbucket.org/org/repo/pull-requests/67    # Bitbucket PR (v2.1.119+)
claude --from-pr https://ghe.example.com/org/repo/pull/89           # GitHub Enterprise (v2.1.119+)

Les sessions sont également associées automatiquement aux PR lorsque vous les créez avec gh pr create au cours d’une session. Vous pouvez ainsi reprendre facilement, par la suite, le travail sur une PR précise. Le badge de PR dans le pied de page peut pointer vers une URL personnalisée de revue de code grâce au paramètre prUrlTemplate (v2.1.119+) — pratique lorsque votre équipe utilise les PR pour accéder à un outil de revue distinct.¹⁵²

/resume accepte les URL de PR (v2.1.122+). Coller une URL de PR dans le champ de recherche de /resume permet désormais de retrouver la session qui avait initialement créé cette PR — cette fonctionnalité est compatible avec github.com, GitHub Enterprise, gitlab.com (ainsi que les instances GitLab auto-hébergées) et bitbucket.org.¹⁵⁴

Sessions nommées : nommez les sessions au démarrage ou au cours d’une session :

# Name session at startup (v2.1.76+)
claude -n "auth-refactor"                  # --name flag sets display name[^125]

# Name current session
> /rename auth-refactor

# Resume by name or number
> /resume 1                    # Resume first session
> /resume auth-refactor        # Resume by name
claude --resume auth-refactor  # Resume from terminal
claude -r 3                    # Resume by number from terminal

# Fork for parallel exploration
claude --resume auth-refactor --fork-session

Remarque : --session-id exige un UUID valide (par exemple, 550e8400-e29b-41d4-a716-446655440000). Pour attribuer un nom lisible à une session, utilisez plutôt /rename et --resume.

/fork lance une session en arrière-plan ; /subtask correspond au fork au sein de la session (v2.1.212). La commande /fork copie désormais la conversation en cours dans une nouvelle session en arrière-plan — celle-ci dispose de sa propre ligne dans claude agents, ce qui vous permet d’envoyer la copie explorer une autre piste pendant que votre session principale se poursuit. L’ancien comportement — créer un fork dans la session actuelle — reste disponible sous le nouveau nom /subtask.¹⁸⁹ Depuis la v2.1.214, une session issue d’un fork indique "fork" comme source du hook SessionStart (contre "resume" auparavant), afin que les hooks filtrant par source puissent les distinguer.¹⁹⁰ La v2.1.216 réduit la confirmation de /fork à une seule ligne indiquant le nom de la nouvelle session et son identifiant claude attach.¹⁹²

Claude Code stocke les sessions sous forme de transcriptions JSONL. L’exécution des agents attribue des valeurs agentId uniques, avec des transcriptions stockées sous la forme agent-{agentId}.jsonl. La reprise conserve l’intégralité du contexte des conversations précédentes.

Mode plan

Le mode plan limite Claude à une exploration en lecture seule — aucune modification de fichier, aucune exécution de Bash et aucune action destructive. Claude conçoit une approche d’implémentation, la consigne dans un fichier de plan, puis attend votre approbation avant toute exécution.

Accéder au mode plan :

# Cycle through modes during a session
Shift+Tab           # Cycles: normal → plan → auto-accept

# Or use the /plan command with an optional description (v2.1.72+)
/plan                                     # Enter plan mode
/plan refactor the auth module            # Enter plan mode with a description

# Or ask Claude directly
"Plan how to refactor the auth module"   # Claude may enter plan mode automatically

Fonctionnement :

1. Claude accède au mode plan (automatiquement pour les tâches complexes ou avec Shift+Tab)
2. Explore la base de code à l’aide d’outils en lecture seule : Read, Glob, Grep, WebSearch, WebFetch
3. Écrit un plan dans .claude/plans/{session-slug}.md
4. Quitte le mode plan avec ExitPlanMode et vous présente le plan pour examen
5. Vous approuvez le plan, demandez des modifications ou le rejetez

Outils disponibles en mode plan : Read, Glob, Grep, LS, WebSearch, WebFetch, AskUserQuestion. Les outils de modification (Edit, Write, Bash, NotebookEdit) sont bloqués.

Après l’approbation du plan (v2.1.32+) : Claude propose trois options : - « Oui, effacer le contexte et accepter automatiquement les modifications » (Shift+Tab) — repart avec un contexte entièrement disponible pour le plan - « Oui, et approuver manuellement les modifications » — conserve le contexte et vous permet d’approuver chaque modification - « Oui, accepter automatiquement les modifications » — conserve le contexte et laisse Claude exécuter le plan sans approbation individuelle des modifications

L’effacement automatique du contexte lors de l’approbation constitue le workflow recommandé. Le plan bénéficie ainsi d’une nouvelle fenêtre de contexte, ce qui améliore considérablement son respect : Claude reste plus longtemps sur la bonne voie, sans être perturbé par les échanges précédents.

Quand utiliser le mode plan : - Implémentation de nouvelles fonctionnalités impliquant des décisions d’architecture - Refactorisations portant sur plusieurs fichiers, lorsque vous souhaitez d’abord examiner l’approche - Bases de code inconnues, lorsqu’une exploration doit précéder toute modification - Toute tâche offrant plusieurs approches valides et pour laquelle vous souhaitez donner votre avis

Conseil d’expert : plus vous consacrez de temps au mode plan, plus Claude a de chances de réussir l’implémentation. Le mode plan permet une exploration pratiquement sans coût — aucun appel d’outil risqué, aucune modification inutile. Utilisez-le généreusement.

Mode lecteur d’écran (v2.1.208)

Claude Code propose un mode lecteur d’écran dédié, qui adapte l’interface du terminal aux technologies d’assistance. Vous pouvez l’activer de trois manières :¹⁸⁶

# Flag at launch
claude --ax-screen-reader

# Environment variable
export CLAUDE_AX_SCREEN_READER=1

# Or persistently in settings.json
{ "axScreenReader": true }

Anthropic présente ce mode — ainsi que ses interactions — sur une nouvelle page consacrée à l’accessibilité dans la documentation officielle.¹⁸⁶

Présentation détaillée du système de configuration

Claude Code utilise un système de configuration en couches. Il est essentiel d’en comprendre la hiérarchie, car les niveaux supérieurs prévalent sur les niveaux inférieurs et les paramètres d’entreprise ne peuvent en aucun cas être contournés.

Hiérarchie de configuration

Conseil d’expert : utilisez .claude/settings.local.json pour vos préférences personnelles dans les projets partagés (ajoutez-le à .gitignore). Utilisez .claude/settings.json pour la configuration commune à toute l’équipe et enregistrée dans le système de gestion de versions.

Définir la configuration depuis le prompt : /config key=value (v2.1.181)

Depuis la v2.1.181, /config key=value définit n’importe quel paramètre directement depuis le prompt — par exemple, /config thinking=false — sans ouvrir l’interface interactive /config. Cette commande fonctionne dans les sessions interactives, -p et Remote Control. /config --help (v2.1.183) répertorie les clés abrégées disponibles. La v2.1.183 a également modifié l’interface interactive /config : Entrée et Espace activent ou désactivent désormais le paramètre sélectionné, tandis qu’Échap enregistre les modifications et ferme l’interface (auparavant, cette touche les annulait).¹⁷⁴

Référence complète de settings.json

Voici une configuration complète présentant toutes les options principales :

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "model": "claude-sonnet-4-5-20250929",
  "permissions": {
    "allow": [
      "Read",
      "Glob",
      "Grep",
      "Bash(npm run:*)",
      "Bash(git:*)",
      "Bash(make:*)",
      "Edit(src/**)",
      "mcp__github"
    ],
    "deny": [
      "Read(.env*)",
      "Read(secrets/**)",
      "Bash(rm -rf:*)",
      "Bash(sudo:*)",
      "Edit(package-lock.json)",
      "Edit(.git/**)"
    ],
    "ask": [
      "WebFetch",
      "Bash(curl:*)",
      "Bash(docker:*)"
    ],
    "additionalDirectories": [
      "../shared-lib",
      "../docs"
    ],
    "defaultMode": "acceptEdits"
  },
  "env": {
    "NODE_ENV": "development",
    "DEBUG": "app:*"
  },
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$FILE_PATH\""
          }
        ]
      }
    ]
  },
  "sandbox": {
    "enabled": false,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["git", "docker"]
  },
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh"
  },
  "includeCoAuthoredBy": true,
  "cleanupPeriodDays": 30,
  "outputStyle": "Explanatory",
  "language": "en",
  "respectGitignore": true,
  "showTurnDuration": true,
  "plansDirectory": ".claude/plans",
  "spinnerVerbs": ["Thinking", "Processing", "Analyzing"],
  "spinnerTipsOverride": {
    "tips": ["Custom tip 1", "Custom tip 2"],
    "excludeDefault": true
  },
  "skillOverrides": {
    "legacy-skill": "off",
    "manual-only-skill": "user-invocable-only",
    "compact-skill": "name-only"
  },
  "includeGitInstructions": false,
  "modelOverrides": {
    "bedrock": "us.anthropic.claude-opus-4-6-20260312-v1:0",
    "vertex": "claude-opus-4-6@20260312",
    "foundry": "anthropic.claude-opus-4-6"
  },
  "autoMemoryDirectory": ".claude/memory",
  "sandbox": {
    "enableWeakerNetworkIsolation": true
  }
}

skillOverrides est utile lorsqu’une équipe dispose d’une vaste bibliothèque de skills, mais souhaite mieux contrôler leur exposition lors de l’exécution. Utilisez off pour masquer une skill à la fois au modèle et au sélecteur de commandes slash, user-invocable-only pour permettre son appel explicite par son nom tout en empêchant le modèle de la sélectionner, et name-only pour ne rendre visible que le nom de la skill, sans sa description complète.¹⁵⁶

Paramètres plus récents (v2.1.174–176) :

• availableModels / enforceAvailableModels (gérés, v2.1.175+) : la liste d’autorisation availableModels limite les modèles qu’une session peut sélectionner. Avec enforceAvailableModels: true, elle s’applique également au modèle Default : si celui-ci devait correspondre à un modèle non autorisé, le premier modèle autorisé est utilisé à la place. En outre, les paramètres utilisateur ou de projet ne peuvent plus élargir une liste availableModels gérée. Un correctif associé (v2.1.176) élimine la possibilité qu’un alias redirige vers un modèle bloqué au moyen de ANTHROPIC_DEFAULT_*_MODEL, et /fast refuse désormais de basculer vers un modèle absent de la liste d’autorisation.¹⁷² Depuis la v2.1.187, les organisations peuvent appliquer directement des restrictions de modèles dans le sélecteur /model, --model, /model et ANTHROPIC_MODEL : la sélection d’un modèle restreint affiche un message indiquant qu’il est « restricted by your organization’s settings ».¹⁷⁶
• language (ajustement de la v2.1.176) : en plus de définir la langue des réponses, les titres des sessions sont désormais générés par défaut dans la langue de votre conversation ; définissez language pour imposer une langue précise aux titres.¹⁷²
• footerLinksRegexes (v2.1.176) : badges de liens correspondant à des expressions régulières dans la ligne de pied de page, configurables dans les paramètres utilisateur ou gérés.¹⁷²
• wheelScrollAccelerationEnabled (v2.1.174) : définissez ce paramètre sur false pour désactiver l’accélération du défilement à la molette en mode plein écran.¹⁷²

Paramètres plus récents (v2.1.207–v2.1.212) :

• vimInsertModeRemaps (v2.1.208) : remappages de touches personnalisés pour le mode insertion de vim — l’exemple classique consiste à associer jj à Échap (consultez Mode Vim).¹⁸⁶
• axScreenReader (v2.1.208) : active durablement le mode lecteur d’écran (consultez Mode lecteur d’écran).¹⁸⁶
• processWrapper (v2.1.208) : fait passer chaque processus que Claude Code lance pour son propre fonctionnement par un exécutable wrapper — conçu pour les lanceurs d’entreprise (consultez Lanceur d’entreprise).¹⁸⁶
• Restriction de la source de autoMode (v2.1.207) : le paramètre autoMode n’est plus lu depuis le fichier .claude/settings.local.json d’un dépôt ; configurez-le plutôt dans ~/.claude/settings.json. Cette modification empêche un dépôt cloné de fournir une configuration du mode automatique.¹⁸⁵

Paramètres plus récents (v2.1.217) :

• emojiCompletionEnabled (v2.1.217) : autocomplétion des codes courts d’emoji dans le champ du prompt — saisissez :heart: pour insérer ❤️, ou une chaîne partielle comme :hea pour afficher des suggestions. Cette fonctionnalité est activée par défaut ; définissez-la sur false pour la désactiver.¹⁹⁴

Paramètres plus récents (v2.1.219) :

• sandbox.network.strictAllowlist (v2.1.219) : refuse les hôtes absents de la liste d’autorisation pour les commandes exécutées dans la sandbox, sans demander de confirmation, au lieu d’afficher une boîte de dialogue d’autorisation. Consultez Mode sandbox.¹⁹⁶
• workflowSizeGuideline (v2.1.219) : définit la recommandation indicative relative à la taille des workflows Dynamic depuis n’importe quel fichier de paramètres — utilisateur, projet ou géré — et non plus uniquement au moyen de /config. Par défaut, les workflows Dynamic suivent une recommandation de taille medium (« visez moins de 15 agents ») ; la ligne correspondante dans /config se masque lorsqu’un fichier de paramètres fournit la valeur. Il s’agit d’une recommandation, et non d’une limite imposée. Consultez Subagents.¹⁹⁶

Référence des variables d’environnement

Authentification et API :

ANTHROPIC_API_KEY=sk-ant-...                    # Direct API authentication
ANTHROPIC_AUTH_TOKEN=token                      # Custom authorization header
ANTHROPIC_CUSTOM_HEADERS="X-Key: val"           # Additional request headers

Configuration du modèle :

ANTHROPIC_MODEL=claude-opus-4-7                 # Override default model (Apr 16, 2026)
ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-4-7    # Opus 4.7 (Max/Team Premium default)
ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-4-6
ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-4-5-20251001
CLAUDE_CODE_SUBAGENT_MODEL=sonnet               # Model for subagents
CLAUDE_CODE_WORKFLOWS=1                         # Enable Workflow tool for deterministic multi-agent orchestration (v2.1.147+)
MAX_THINKING_TOKENS=10000                       # (Opus 4.6 and Sonnet 4.6 only — removed in Opus 4.7)
CLAUDE_CODE_MAX_OUTPUT_TOKENS=4000              # Limit output length
CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1          # Enable agent teams (v2.1.32+)

Configuration du fournisseur cloud :

CLAUDE_CODE_USE_BEDROCK=1                       # Use AWS Bedrock
CLAUDE_CODE_USE_VERTEX=1                        # Use Google Vertex AI
CLAUDE_CODE_USE_FOUNDRY=1                       # Use Microsoft Foundry
ANTHROPIC_BEDROCK_BASE_URL=https://...          # Custom Bedrock endpoint
ANTHROPIC_BEDROCK_SERVICE_TIER=priority         # Bedrock service tier (v2.1.122+): 'default', 'flex', or 'priority'; sent as X-Amzn-Bedrock-Service-Tier header[^162]
CLAUDE_CODE_SKIP_BEDROCK_AUTH=1                 # Skip Bedrock auth (for gateways)
CLAUDE_CODE_SKIP_VERTEX_AUTH=1                  # Skip Vertex auth
AWS_BEARER_TOKEN_BEDROCK=token                  # Bedrock bearer token
VERTEX_REGION_CLAUDE_3_7_SONNET=us-west1        # Override Vertex region
CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1    # Opt in gateway /v1/models discovery for /model picker (v2.1.129+)[^164]

Contrôle du comportement :

DISABLE_AUTOUPDATER=1                           # Prevent automatic background updates
DISABLE_UPDATES=1                               # Block ALL update paths including manual `claude update` (v2.1.118+, stricter than DISABLE_AUTOUPDATER)[^160]
CLAUDE_CODE_PACKAGE_MANAGER_AUTO_UPDATE=1       # Homebrew/WinGet installs run package-manager upgrade in background, then prompt restart (v2.1.129+)[^164]
DISABLE_TELEMETRY=1                             # Opt out of usage telemetry
DISABLE_ERROR_REPORTING=1                       # Disable Sentry
DISABLE_BUG_COMMAND=1                           # Disable /bug command
DISABLE_COST_WARNINGS=1                         # Hide cost warnings
DISABLE_PROMPT_CACHING=1                        # Disable prompt caching globally
DISABLE_PROMPT_CACHING_SONNET=1                 # Disable for Sonnet only
DISABLE_PROMPT_CACHING_OPUS=1                   # Disable for Opus only
DISABLE_NON_ESSENTIAL_MODEL_CALLS=1             # Skip non-critical API calls
ENABLE_PROMPT_CACHING_1H=1                      # Opt into 1-hour prompt cache TTL (v2.1.108+, API/Bedrock/Vertex/Foundry)
ENABLE_PROMPT_CACHING_1H_BEDROCK=1              # Deprecated alias for the above; v2.1.108+ still honors it on Bedrock but logs a deprecation notice
FORCE_PROMPT_CACHING_5M=1                       # Force 5-minute cache TTL (v2.1.108+)
ENABLE_TOOL_SEARCH=true                         # Re-enable tool search on Vertex AI (disabled by default v2.1.119+ to avoid unsupported beta header). Valid values: true, false, auto, auto:N[^160]
CLAUDE_CODE_HIDE_CWD=1                          # Hide the working directory in the startup logo (v2.1.119+)[^160]
CLAUDE_CODE_FORK_SUBAGENT=1                     # Enable forked subagents on external builds (v2.1.117+)[^160]
CLAUDE_CODE_FORCE_SYNC_OUTPUT=1                 # Force synchronized terminal output when auto-detection misses it, such as Emacs eat (v2.1.129+)[^164]
CLAUDE_CODE_SESSION_ID=...                      # Read-only: present in the Bash tool subprocess; matches the session_id passed to hooks (v2.1.132+)[^168]
CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN=1          # Skip the fullscreen alternate-screen renderer; keep the conversation in the terminal's native scrollback (v2.1.132+)[^168]
CLAUDE_EFFORT=...                               # Read-only: current effort level inside hooks and Bash tool subprocess (v2.1.133+)[^169]
CLAUDE_CODE_FORWARD_SUBAGENT_TEXT=1             # Include subagent text + thinking in stream-json output; pairs with --forward-subagent-text (v2.1.211+). Covers depth-2+ nested subagents as of v2.1.219[^205][^213]
CLAUDE_CODE_MAX_WEB_SEARCHES_PER_SESSION=200    # Per-session WebSearch cap (default 200; v2.1.212+)[^206]
CLAUDE_CODE_MAX_SUBAGENTS_PER_SESSION=200       # Per-session subagent-spawn cap (default 200; /clear resets the budget; v2.1.212+)[^206]
CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS=20         # Cap on concurrently-RUNNING subagents (default 20; distinct from the per-session total above; v2.1.217+)[^211]
CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH=3          # Nested subagent spawn depth. Default 3 as of v2.1.219; set 1 to disable nesting. Default history: 5 (v2.1.172–v2.1.216) → 1 (v2.1.217) → 3 (v2.1.219). Set it explicitly[^211][^213]

Configuration des outils :

BASH_DEFAULT_TIMEOUT_MS=30000                   # Bash command timeout (30s)
BASH_MAX_TIMEOUT_MS=600000                      # Maximum bash timeout (10min)
BASH_MAX_OUTPUT_LENGTH=50000                    # Bash output limit
CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=1     # Reset CWD after each bash
MCP_TIMEOUT=5000                                # MCP server startup timeout
MCP_TOOL_TIMEOUT=30000                          # MCP tool execution timeout
MAX_MCP_OUTPUT_TOKENS=25000                     # MCP output limit
CLAUDE_CODE_MCP_AUTO_BACKGROUND_MS=120000       # Threshold before a long MCP tool call moves to the background (default 2 min; v2.1.212+)[^206]
SLASH_COMMAND_TOOL_CHAR_BUDGET=15000            # Slash command context limit

Réseau et proxy :

HTTP_PROXY=http://proxy:8080                    # HTTP proxy
HTTPS_PROXY=https://proxy:8080                  # HTTPS proxy
NO_PROXY=localhost,example.com                  # Bypass proxy for domains
CLAUDE_CODE_CLIENT_CERT=/path/to/cert           # mTLS certificate
CLAUDE_CODE_CLIENT_KEY=/path/to/key             # mTLS private key
CLAUDE_CODE_CLIENT_KEY_PASSPHRASE=pass          # mTLS passphrase

Interface utilisateur et terminal :

CLAUDE_CODE_DISABLE_TERMINAL_TITLE=1            # Don't update terminal title
CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL=1             # Skip IDE extension install
CLAUDE_CODE_SHELL=/bin/zsh                      # Override shell detection
USE_BUILTIN_RIPGREP=1                           # Use included ripgrep (default)
CLAUDE_CONFIG_DIR=~/.myconfig                   # Custom config directory
IS_DEMO=1                                       # Hide sensitive UI elements[^37]
CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1          # Disable background tasks and Ctrl+B[^46]
CLAUDE_CODE_TMPDIR=/path/to/tmp                 # Override temp directory[^50]
CLAUDE_CODE_DISABLE_1M_CONTEXT=1               # Disable 1M context window (use standard 200K)[^103]
CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS=120000       # Plugin marketplace git timeout (default 120s, was 30s)[^105]
CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS=1        # Remove built-in commit/PR instructions[^117]
CLAUDE_CODE_DISABLE_CRON=1                    # Stop scheduled cron jobs mid-session[^121]
CLAUDE_CODE_SESSIONEND_HOOKS_TIMEOUT_MS=30000 # SessionEnd hooks timeout (default varies)[^123]
CLAUDE_CODE_USE_POWERSHELL_TOOL=1             # Enable Windows PowerShell tool on Linux/macOS (requires pwsh on PATH; v2.1.111+)[^153]
CLAUDE_CODE_DISABLE_MOUSE_CLICKS=1           # Disable mouse click/drag/hover in fullscreen mode; wheel scroll still works (v2.1.195+)[^196]
CLAUDE_ENABLE_STREAM_WATCHDOG=0              # Disable the streaming idle watchdog (on by default for all providers since v2.1.196: aborts+retries after 5 min of silence)[^198]
CLAUDE_CODE_DISABLE_BG_SHELL_PRESSURE_REAP=1 # Turn off automatic memory-pressure reaping of idle background shell commands (v2.1.193+)[^196]
CLAUDE_CODE_ENABLE_AWAY_SUMMARY=1             # Force Session Recap when telemetry disabled (v2.1.108+)[^153]
CLAUDE_AX_SCREEN_READER=1                     # Enable screen reader mode; same as --ax-screen-reader or "axScreenReader": true (v2.1.208+)[^203]
OTEL_LOG_RAW_API_BODIES=1                     # Emit full API request/response bodies as OTel log events (v2.1.111+)[^153]
TRACEPARENT=00-...                            # W3C Trace Context parent (v2.1.110+, SDK/headless)[^153]
TRACESTATE=vendor=value                       # W3C Trace Context state (v2.1.110+, SDK/headless)[^153]

Exportateurs OpenTelemetry et contrôle des champs sensibles :²⁰⁷

OTEL_LOGS_EXPORTER=none                       # OTel logs exporter (supports 'none' for disable; v2.1.85 fixed crash)
OTEL_METRICS_EXPORTER=none                    # OTel metrics exporter (supports 'none'; v2.1.85 fixed crash)
OTEL_TRACES_EXPORTER=none                     # OTel traces exporter (supports 'none'; v2.1.85 fixed crash)
OTEL_LOG_TOOL_CONTENT=1                       # Opt in to emitting tool content in OTel spans (v2.1.101+, sensitive by default)
OTEL_LOG_TOOL_DETAILS=1                       # Opt in to tool_parameters in OTel tool_result events (v2.1.85+)
OTEL_LOG_USER_PROMPTS=1                       # Opt in to emitting user prompts in OTel traces (v2.1.101+, sensitive by default)
OTEL_LOG_ASSISTANT_RESPONSES=0                # Gate the claude_code.assistant_response log event holding the model's response text (v2.1.193+)
CLAUDE_CODE_OTEL_CONTENT_MAX_LENGTH=60000     # Truncation limit for OTel content attributes (default 60 KB; v2.1.214+)[^207]
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1    # Disable release-notes fetch (v2.0.17+); v2.1.110 also stopped the auto-title Haiku request in headless/SDK when set

Attributs des spans de requête LLM à partir de la v2.1.121 : stop_reason, gen_ai.response.finish_reasons et user_system_prompt sont désormais émis sur les spans de requête LLM. user_system_prompt est conditionné par OTEL_LOG_USER_PROMPTS=1, car il peut contenir des données personnelles.¹⁵⁴

Modifications au niveau des événements à partir de la v2.1.122 : les attributs numériques des événements de journal api_request et api_error sont désormais émis sous forme de nombres (auparavant, il s’agissait de chaînes de caractères), ce qui corrige les problèmes rencontrés par les collecteurs OTel en aval appliquant un typage strict du schéma. Le nouvel événement de journal claude_code.at_mention se déclenche lorsque Claude Code résout une mention @.¹⁵⁴

Événement de journal claude_code.assistant_response à partir de la v2.1.193 : Claude Code peut émettre le texte intégral de la réponse du modèle sous la forme d’un événement de journal OTel, sous le contrôle de OTEL_LOG_ASSISTANT_RESPONSES. Ce mécanisme présente un piège à connaître lors d’une mise à niveau : lorsque OTEL_LOG_ASSISTANT_RESPONSES n’est pas défini, il suit OTEL_LOG_USER_PROMPTS. Ainsi, tout déploiement qui journalise déjà le contenu des prompts commencera à recevoir celui des réponses de l’assistant après la mise à niveau. Définissez OTEL_LOG_ASSISTANT_RESPONSES=0 pour limiter la télémétrie aux prompts.¹⁷⁹

Ajouts de télémétrie de la v2.1.214 : les événements de journal OTel comportent désormais les attributs message.uuid, client_request_id et tool_source, qui permettent respectivement de corréler les messages et de retracer la provenance des outils ; la charge utile subagentStatusLine inclut l’effort de raisonnement du subagent, afin que les lignes d’état personnalisées puissent afficher ensemble le modèle et l’effort ; enfin, la nouvelle variable d’environnement CLAUDE_CODE_OTEL_CONTENT_MAX_LENGTH configure la limite de troncature de 60 Ko appliquée aux attributs de contenu OTel.¹⁹⁰

API / Contrôle du modèle :²⁰⁷

CLAUDE_CODE_EXTRA_BODY='{...}'                # Inject extra body fields into API calls; v2.1.113 fixed 400 errors with output_config.effort on Vertex/subagent calls
CLAUDE_CODE_MAX_CONTEXT_TOKENS=200000         # Override max context tokens (pre-existing var; v2.1.98 fixed handling of DISABLE_COMPACT when both are set)
CLAUDE_CODE_FILE_READ_MAX_OUTPUT_TOKENS=25000 # Override default token limit for file read operations (v2.1.0+)
CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK=1   # Do not fall back to non-streaming API on streaming failures (v2.1.83+)
ANTHROPIC_BETAS=beta1,beta2                   # Enable beta API headers; v2.1.78 fixed silent ignore on Haiku models
ANTHROPIC_SMALL_FAST_MODEL=arn:...            # Fast model ID (Bedrock ARN supported; v0.2.125 stopped escaping slashes in ARN)

Plugins / MCP :²⁰⁷

CLAUDE_CODE_PLUGIN_CACHE_DIR=~/.claude/plugins # Plugin cache directory (v2.1.72 fixed literal '~' dir on some shells)
CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE=1 # Preserve plugin marketplace cache when git pull fails (offline-friendly; v2.1.90+)
CLAUDE_CODE_MCP_SERVER_NAME=server1           # Passed to MCP headersHelper scripts so one helper can serve multiple servers (v2.1.85+)
CLAUDE_CODE_MCP_SERVER_URL=https://...        # Passed to MCP headersHelper scripts alongside the name (v2.1.85+)

Shell / IDE :²⁰⁷

CLAUDE_CODE_SHELL_PREFIX="time "              # Wrap every Claude-invoked shell command with a prefix (v1.0.61+)
CLAUDE_CODE_GIT_BASH_PATH=C:\Program\ Files\Git\bin\bash.exe  # Custom Git Bash path on Windows (v2.1.98+)
CLAUDE_CODE_EXIT_AFTER_STOP_DELAY=60000       # SDK: exit after N ms idle (v2.0.35+)
CLAUDE_CODE_AUTO_CONNECT_IDE=false            # Disable IDE auto-connection (v1.0.61+)

Entreprise / authentification :²⁰⁷

CLAUDE_CODE_PROXY_RESOLVES_HOSTS=1            # Opt into proxy-side DNS resolution (v2.0.55 moved this from default-on to opt-in)
CLAUDE_CODE_API_KEY_HELPER_TTL_MS=300000      # TTL for dynamically generated API keys via apiKeyHelper (apiKeyHelper refresh added v0.2.74 with 5-min default; env var added v0.2.117)
CLAUDE_CODE_PROCESS_WRAPPER=/path/to/wrapper  # Route all Claude Code self-spawned processes through a wrapper executable; same as the processWrapper setting (v2.1.208+)[^203]

Variables des skills (v2.1.69+) :

${CLAUDE_SKILL_DIR}                            # Self-reference for skills to locate their own directory[^117]

Identité de l’appelant SDK (v2.1.51+) :

CLAUDE_CODE_ACCOUNT_UUID=uuid                  # Provide account UUID synchronously for SDK callers
CLAUDE_CODE_USER_EMAIL=user@example.com        # Provide user email for SDK callers
CLAUDE_CODE_ORGANIZATION_UUID=uuid             # Provide organization UUID for SDK callers

Débogage :

ANTHROPIC_LOG=debug                             # Enable API request logging

Quel modèle choisir ?

Choisir le bon modèle pour chaque tâche a une incidence considérable sur le coût comme sur la qualité. Claude Code permet de changer de modèle avec souplesse à plusieurs niveaux.

Modèles disponibles

Deux changements incompatibles lors de la migration d’un environnement d’Opus 4.8 vers Opus 5 :¹⁹⁷

1. Le raisonnement est activé par défaut. Avec Opus 4.8, une requête dépourvue de champ thinking s’exécutait sans raisonnement ; avec Opus 5, la même requête utilise le raisonnement adaptatif. max_tokens reste une limite stricte applicable à l’ensemble de la sortie — raisonnement et texte de réponse compris — ; vérifiez donc de nouveau la marge disponible pour toute charge de travail qui s’exécutait auparavant sans raisonnement. Transmettez thinking: {type: "disabled"} pour rétablir l’ancien comportement, sous réserve du point suivant.
2. La désactivation du raisonnement limite l’effort à high. L’association de thinking: {type: "disabled"} avec un effort xhigh ou max renvoie une erreur 400. Le contrôle s’applique à chaque requête : augmenter l’effort à xhigh lorsque le raisonnement est désactivé entraîne un rejet, même si des tours précédents de la même conversation ont été acceptés.

Dans Claude Code en particulier : avec Opus 5, effort prend par défaut la valeur high (comme sur le API Claude) et toute l’échelle est disponible — low, medium, high, xhigh, max. Les propres recommandations de migration de Anthropic préconisent de tester l’effort max lorsque les capacités importent davantage que la consommation de tokens. Le mode rapide couvre Opus 5 au tarif de 10 $/50 $ par MTok (voir Mode rapide).¹⁹⁷¹⁹⁸

Claude Fable 5 (9 juin 2026) : Un nouveau niveau de modèle supérieur à Opus — le modèle le plus puissant et le plus intelligent de Anthropic, à la pointe sur presque tous les benchmarks auxquels il a été soumis et conçu pour rester cohérent sur des contextes de plusieurs millions de tokens. Fable 5 est le modèle de pointe de classe « Mythos » rendu sûr pour un usage général : il intègre des classificateurs de sécurité qui basculent vers Opus 4.8 pour les requêtes liées à la cybersécurité, à la biochimie et à la distillation de modèles (Claude Mythos 5 est le même modèle sans ces protections, destiné aux chercheurs autorisés). Il est devenu sélectionnable dans Claude Code avec la v2.1.170 (9 juin 2026) — exécutez claude update, puis /model fable (l’alias court ; /model claude-fable-5 et l’alias best permettent également de le sélectionner) — et son déploiement dans les abonnements s’échelonne jusqu’au 22 juin 2026. ID de modèle : claude-fable-5. Fable 5 inclut une fenêtre de contexte de 1 M par défaut ; le suffixe [1m] est donc inutile — et depuis la v2.1.173 (11 juin 2026), un nom de modèle claude-fable-5[1m] est automatiquement normalisé en claude-fable-5 par suppression du suffixe (celui-ci n’a jamais eu de sens que pour Opus/Sonnet, où l’accès à un contexte de 1 M dépend de [1m]) ; sortie maximale de 128 K. Les tarifs sont de 10 $/MTok en entrée et de 50 $/MTok en sortie — soit environ 2 fois ceux d’Opus 4.8 — ; réservez-le donc aux raisonnements véritablement difficiles, et non aux modifications courantes. Il reprend l’interface de requête d’Opus 4.8 (raisonnement adaptatif uniquement ; suppression de temperature/top_p/top_k et de budget_tokens), avec une nouvelle particularité : définir explicitement thinking: {type: "disabled"} renvoie une erreur 400 ; omettez donc entièrement le paramètre thinking pour une exécution sans raisonnement.²⁰⁰

Dans Claude Code en particulier : Fable 5 prend en charge toute l’échelle d’effort (low/medium/high/xhigh/max, avec high par défaut), comme Opus 5. Le raisonnement ne peut pas être désactivé sur Fable 5 — le sélecteur de raisonnement de la session, le paramètre alwaysThinkingEnabled et MAX_THINKING_TOKENS=0 sont tous sans effet ; il raisonne toujours de manière adaptative. Une surface de configuration complète propre à la famille fable reprend les options d’Opus : ANTHROPIC_DEFAULT_FABLE_MODEL épingle le modèle vers lequel pointe l’alias fable (utile sur Bedrock/Vertex/Foundry), DISABLE_PROMPT_CACHING_FABLE exclut Fable de la mise en cache des prompts et un basculement automatique fondé sur le contenu s’applique sur les passerelles d’entreprise. /model opus sélectionne désormais Opus 5 (effort élevé par défaut, /effort xhigh pour les tâches les plus difficiles), tandis que Sonnet 5 est le modèle par défaut prêt à l’emploi depuis la v2.1.197 ; choisissez délibérément Fable 5 avec /model fable lorsque vous recherchez le niveau de capacité maximal.²⁰⁰¹⁹⁷

Opus 4.7 (16 avril 2026) : L’ancien modèle phare, toujours entièrement disponible. Fenêtre de contexte de 1 M de tokens au tarif standard — sans supplément pour les contextes longs. Sortie maximale de 128 K, raisonnement adaptatif uniquement (raisonnement étendu supprimé) et nouveau niveau d’effort xhigh, recommandé comme point de départ pour les charges de travail de développement et agentiques.¹⁴⁵ Date limite des connaissances fiables : janvier 2026. Date limite des données d’entraînement : janvier 2026. ID de modèle : claude-opus-4-7. Les tarifs sont identiques à ceux d’Opus 4.6, soit 5 $/25 $ par MTok, avec 6,25 $ pour une écriture en cache de 5 min, 10 $ pour une écriture en cache de 1 h et 0,50 $ par MTok pour une lecture depuis le cache.¹⁴⁴ Opus 4.7 résout 3 fois plus de tâches de production sur SWE-Bench qu’Opus 4.6, obtient un score de 70 % sur CursorBench (contre 58 % pour la version 4.6) et augmente de 13 % le taux de résolution sur le benchmark de développement interne de Anthropic, composé de 93 tâches.¹⁴⁴ Il utilise un nouveau tokenizer — attendez-vous à un nombre de tokens environ 1 à 1,35 fois supérieur pour un même texte ; augmentez la marge de max_tokens et ajustez les seuils de compaction.¹⁴⁵ La vision prend en charge des images allant jusqu’à 2 576 px / 3,75 MP, avec des coordonnées de pixels à l’échelle 1:1.¹⁴⁵

Benchmarks de développement d’Opus 4.7 (avril 2026) :¹⁵¹

Modèle par défaut selon l’abonnement (Claude Code) :¹⁴⁷

Changements incompatibles d’Opus 4.7 dans le API Messages (visibles par l’appelant) :¹⁴⁵ - Le paramètre budget_tokens de l’extended thinking a été supprimé. Utilisez plutôt thinking: {type: "adaptive"}. L’adaptive thinking est désactivé par défaut ; les requêtes sans champ thinking s’exécutent sans thinking. - Définir temperature, top_p ou top_k sur une valeur autre que celle par défaut renvoie une erreur HTTP 400. Omettez ces paramètres et orientez le modèle à l’aide du prompt. - Le contenu du thinking est omis des réponses par défaut. Définissez thinking.display: "summarized" pour rendre le raisonnement de nouveau visible (obligatoire si votre produit diffuse le thinking aux utilisateurs).

Les budgets de tâche (en-tête bêta task-budgets-2026-03-13) vous permettent d’indiquer au modèle un objectif de tokens pour l’ensemble d’une boucle agentique via output_config.task_budget ; minimum de 20K tokens.¹⁴⁵

Opus 4.6 (ancienne version) : Toujours disponible sous l’identifiant claude-opus-4-6, avec un contexte de 1M et une sortie maximale de 128K. Envisagez de migrer vers Opus 4.7 pour bénéficier de meilleures performances en programmation agentique. Opus 4.6 est initialement sorti le 5 février 2026.⁷⁹¹⁴⁴ Depuis la v2.1.117 (22 avril 2026), l’effort par défaut des abonnés Pro et Max est défini sur high avec Opus 4.6 et Sonnet 4.6 (contre medium auparavant) ; Opus 4.7 reste sur xhigh. Ce changement a rétabli le niveau d’intelligence après la réduction de l’effort du 4 mars au 7 avril, documentée dans l’analyse rétrospective du 23 avril.¹⁵²¹⁵³

Sonnet 5 (30 juin 2026) : Le modèle actuel de la gamme Sonnet, présenté comme offrant « la meilleure combinaison de rapidité et d’intelligence ». Anthropic indique que ses performances sont proches de celles d’Opus 4.8, mais à moindre coût, et qu’il améliore considérablement Sonnet 4.6 pour le raisonnement agentique, l’utilisation d’outils, la programmation et les tâches intellectuelles, tout en affichant globalement moins de comportements indésirables et des capacités de cybersécurité bien inférieures à celles des modèles Opus (le compromis de sécurité qui a permis sa commercialisation sans restrictions liées au contrôle des exportations). Identifiant du modèle : claude-sonnet-5 (snapshot épinglé sans date). Fenêtre de contexte de 1M tokens, sortie maximale de 128K (jusqu’à 300K avec API Batches et l’en-tête bêta output-300k-2026-03-24), adaptive thinking uniquement. Limite fiable des connaissances : janvier 2026. Tarification : 3 $/15 $ par MTok en entrée/sortie, avec un tarif de lancement de 2 $/10 $ jusqu’au 31 août 2026, soit environ 40 % de moins que les 5 $/25 $ d’Opus 4.8. Dans Claude Code, le paramètre effort est défini par défaut sur high avec Sonnet 5 (définissez-le explicitement pour le modifier). Sélectionnez-le avec /model sonnet (ou /model claude-sonnet-5).¹⁸⁰ Depuis la v2.1.197 (30 juin 2026), Sonnet 5 est le modèle par défaut dans Claude Code pour les nouvelles sessions, remplaçant Opus 4.8 comme choix initial ; Opus reste entièrement disponible à la sélection.¹⁸¹

Sonnet 4.6 (17 février 2026, désormais remplacé par Sonnet 5) : Modèle équilibré ; il a remplacé Sonnet 4.5 comme modèle par défaut sur claude.ai et dans Claude Cowork.⁹³ Même tarification que Sonnet 4.5 (3 $/15 $ par MTok). Amélioration des performances de recherche agentique avec une consommation de tokens réduite. Prend en charge l’extended thinking, l’adaptive thinking et une fenêtre de contexte de 1M tokens (bêta). Sortie maximale de 64K (limite supérieure de 128K dans la v2.1.77).¹¹⁹ Limite des connaissances : août 2025 (fiable), janvier 2026 (données d’entraînement). Identifiant du modèle : claude-sonnet-4-6.

Claude Mythos Preview (7 avril 2026) : Un modèle de pointe en préversion de recherche, destiné aux travaux de cybersécurité défensive et proposé dans le cadre du Project Glasswing.¹³⁹ Sur invitation uniquement ; il n’est pas disponible au grand public. Anthropic présente Opus 4.7 comme délibérément moins performant que Mythos dans le domaine de la cybersécurité — un compromis de sécurité — et a ouvert un Cyber Verification Program à l’adresse https://claude.com/form/cyber-use-case pour les chercheurs légitimes en sécurité qui ont besoin d’un accès étendu.¹⁴⁶

Pourquoi ces différences de prix sont importantes : Une session de programmation type consomme entre 50K et 200K tokens en entrée et entre 10K et 50K tokens en sortie. Avec Haiku, cela représente entre 0,10 $ et 0,45 $ par session. Avec Opus, la même session coûte entre 0,50 $ et 2,25 $, soit 5 fois plus. Réservez Opus aux problèmes réellement difficiles.¹

Quand utiliser chaque modèle

Haiku : Utilisez-le pour les subagents chargés de l’exploration, les recherches simples de fichiers et les questions rapides. Il est environ 5 fois moins cher qu’Opus et répond plus rapidement. Idéal pour les tâches d’arrière-plan qui ne nécessitent pas de raisonnement approfondi.

Sonnet : Le modèle de référence pour le développement quotidien lorsque le coût compte. Il prend en charge la plupart des tâches de programmation : implémentation de fonctionnalités, correction de bugs, rédaction de tests et revue de code. Sonnet 4.6 améliore la recherche agentique et l’efficacité en tokens par rapport à Sonnet 4.5, avec la prise en charge de l’adaptive thinking et une fenêtre de contexte de 1M au tarif standard.⁹³ Depuis Opus 4.7 (16 avril 2026), Claude Code utilise Opus par défaut uniquement avec les offres Max et Team Premium ; les comptes Pro, Team Standard, Enterprise et API conservent Sonnet 4.6 par défaut jusqu’au passage des offres Enterprise et API à Opus 4.7 le 23 avril 2026.¹⁴⁷ Utilisez Sonnet lorsque vous avez besoin de tokens moins coûteux, d’une latence plus faible ou d’une meilleure maîtrise du coût des subagents.

Opus : Le modèle phare depuis le 16 avril 2026, utilisé par défaut avec les offres Max et Team Premium.¹⁴⁴¹⁴⁷ Réservez son raisonnement plus coûteux aux tâches où il apporte une réelle valeur : décisions d’architecture, débogage complexe, compréhension de systèmes sophistiqués, analyse de sécurité et travaux agentiques de longue durée. Opus 4.7 résout 3 fois plus de tâches de production sur SWE-Bench qu’Opus 4.6, obtient un score de 70 % sur CursorBench (contre 58 %) et améliore de 13 % le taux de résolution sur un benchmark interne de programmation comportant 93 tâches.¹⁴⁴ Claude Code utilise par défaut un effort xhigh avec Opus 4.7, réglable via /effort (v2.1.111+).¹⁴⁶¹⁴⁷ Auto Mode est disponible pour les abonnés Max avec Opus 4.7 via Anthropic API, sans nécessiter --enable-auto-mode ; pour les autres offres et fournisseurs, sa disponibilité dépend de l’abonnement et des paramètres administrateur.¹⁴⁶ Contexte de 1M au tarif standard, sans supplément pour le contexte long. Changements de comportement à connaître : Opus 4.7 suit les instructions plus littéralement, adapte la longueur de ses réponses à la complexité de la tâche, exécute moins de subagents par défaut et adopte un ton plus direct, avec moins de formulations axées sur la validation. Si vos prompts comportent des instructions visant à imposer des messages de progression intermédiaires ou des doubles vérifications, essayez de les supprimer.¹⁴⁵

Opusplan : Un mode hybride qui utilise Opus pour la planification, là où la qualité du raisonnement compte le plus, et Sonnet pour l’exécution, là où la rapidité est déterminante. Excellent pour les refactorisations complexes lorsque vous souhaitez bénéficier du meilleur plan sans avoir besoin du niveau de raisonnement d’Opus pour chaque modification.

Changer de modèle

Pendant une session :

> /model opus
> /model sonnet
> /model haiku

Au démarrage :

claude --model opus

Via l’environnement :

export ANTHROPIC_MODEL=opus

Dans settings.json :

{
  "model": "claude-sonnet-4-5-20250929"
}

Spécifiquement pour les subagents :

export CLAUDE_CODE_SUBAGENT_MODEL=haiku

Chaîne de modèles de secours (v2.1.166+) : le paramètre fallbackModel permet de configurer jusqu’à trois modèles de secours, essayés dans l’ordre lorsque le modèle principal est surchargé ou indisponible. L’option --fallback-model (qui ne permettait auparavant qu’un changement en cours de session) s’applique désormais également aux sessions interactives dès leur démarrage.²⁰²

{
  "model": "claude-opus-4-8",
  "fallbackModel": ["claude-sonnet-4-6", "claude-haiku-4-5"]
}

Lorsque API renvoie une erreur inattendue non réessayable, Claude Code réessaie désormais également le tour une fois avec le modèle de secours avant de signaler l’échec ; ainsi, un problème temporaire du modèle principal entraîne une dégradation progressive au lieu d’interrompre le tour.²⁰²

Depuis la v2.1.178, la compaction respecte également la chaîne de secours : si le modèle principal est surchargé ou indisponible pendant la compaction, cette étape utilise la chaîne fallbackModel/--fallback-model configurée au lieu de faire échouer le tour. Pour une longue exécution autonome, cela comble la lacune qui permettait à une erreur temporaire du modèle d’interrompre la session pendant une compaction qui aurait autrement pu être récupérée.¹⁷³

Contexte étendu

Pour les grandes bases de code ou les longues sessions, activez le contexte de 1M tokens :

claude --model sonnet[1m]
claude --model opus[1m]           # Opus 4.7 with 1M context

Ou au cours d’une session :

> /model sonnet[1m]
> /model opus[1m]

Opus 4.7, Opus 4.6 et Sonnet 4.6 incluent tous la fenêtre de contexte complète de 1M tokens au tarif standard, sans supplément pour le contexte long.¹⁴⁸ Une requête de 900K tokens est facturée au même tarif par token qu’une requête de 9K tokens. Les réductions liées à la mise en cache des prompts et au traitement par lots s’appliquent aux tarifs standard sur l’ensemble de la fenêtre de contexte.

Avec les abonnements Max, Team et Enterprise, Opus avec un contexte de 1M est inclus automatiquement : aucun suffixe [1m] n’est nécessaire (activé par défaut depuis la v2.1.75, le 13 mars 2026).¹¹⁷¹⁴⁷ Avec l’offre Pro, le contexte de 1M est accessible via l’utilisation supplémentaire. Les utilisateurs de API et des offres avec paiement à l’usage disposent d’un accès complet au contexte de 1M aux tarifs standard par token.¹⁴⁷

Pour désactiver les variantes à contexte de 1M dans le sélecteur de modèle, définissez CLAUDE_CODE_DISABLE_1M_CONTEXT=1.

Vérifier le modèle actuel

> /status

La commande affiche le modèle actuel, les informations du compte, les paramètres appliqués et d’autres éléments sur l’état de la session. Libellés du sélecteur de modèles (v2.1.51+) : le sélecteur /model affiche désormais des libellés lisibles (par exemple, « Sonnet 4.6 ») au lieu des identifiants bruts pour les versions épinglées, ainsi que des suggestions de mise à niveau lorsque des versions plus récentes sont disponibles.⁹⁸ La v2.1.219 corrige l’affichage de la ligne Opus fusionnée, qui indique maintenant simplement « Opus » au lieu de « Opus (contexte de 1M) », et limite la mise en évidence d’une nouvelle version au seul nom du modèle le plus récent. Elle signale ainsi ce qui vient réellement de sortir plutôt qu’une portion arbitraire de la liste.¹⁹⁶

Fast Mode (v2.1.36+)

Fast mode fournit une sortie nettement plus rapide avec le même modèle ; il ne bascule pas vers un modèle moins coûteux. Activez-le ou désactivez-le pendant une session avec /fast.⁸⁶

> /fast            # Toggle fast mode on/off

Modèles concernés (à partir de la v2.1.219) : fast mode s’applique à Claude Opus 5 et Claude Opus 4.8. La v2.1.219 a retiré Opus 4.7 de fast mode, et cette fonctionnalité n’a jamais été disponible sur Sonnet, Haiku ou Fable. Elle reste proposée en version expérimentale de recherche uniquement sur Claude API (y compris Claude Managed Agents), et non sur Amazon Bedrock, Google Cloud, Microsoft Foundry ou Claude Platform on AWS. L’accès est restreint : contactez votre responsable de compte ou inscrivez-vous sur la liste d’attente.¹⁹⁶¹⁹⁸

Tarification (fast mode d’Opus 5 / Opus 4.8) :¹⁹⁸

Le piège d’Opus 4.7 (v2.1.219). Les modèles non pris en charge n’adoptent pas tous le même comportement. Une requête envoyée à claude-opus-4-7 avec speed: "fast" renvoie désormais une erreur : elle ne revient pas discrètement à la vitesse standard. Opus 4.6 constitue l’exception qui rend cette distinction importante : il accepte speed: "fast", s’exécute malgré tout à la vitesse standard, est facturé aux tarifs standards et indique usage.speed: "standard". Si votre harnais épinglait la version 4.7 et comptait sur le retour silencieux des requêtes fast mode au mode standard, celles-ci échouent désormais purement et simplement ; migrez l’épinglage vers Opus 5 ou 4.8.¹⁹⁸

Quand utiliser fast mode : - Pour itérer rapidement sur de petites modifications lorsque la latence constitue le principal frein - Pour générer des tests, du code passe-partout ou du code répétitif lorsque la rapidité compte davantage que le coût - Pour traiter successivement une liste de tâches similaires

Quand NE PAS utiliser fast mode : - Pour les tâches agentiques de longue durée (le coût reste doublé sur l’ensemble de l’exécution) - Pour le travail des subagents en arrière-plan (personne n’attend leur sortie) - Pour les sessions soumises à des contraintes budgétaires

Fast mode inclut la fenêtre de contexte complète de 1M (v2.1.50+). La tarification applique un multiplicateur fixe à l’ensemble du contexte, y compris aux requêtes dépassant 200K tokens d’entrée, sans supplément pour les longs contextes. Ce multiplicateur s’ajoute à ceux de la mise en cache des prompts et de la résidence des données.⁹⁶¹⁹⁸

Notes opérationnelles. Fast mode possède sa propre limite de débit, distincte des limites standards d’Opus ; son dépassement renvoie une erreur 429 avec retry-after (les en-têtes de réponse anthropic-fast-*-tokens-* indiquent la capacité restante). Le passage entre fast mode et le mode standard invalide le cache des prompts : les requêtes exécutées à des vitesses différentes ne partagent pas les préfixes mis en cache. Activer ou désactiver /fast en cours de session provoque donc un défaut de cache. Fast mode n’est pas disponible avec Batch API ni avec un engagement Priority Tier.¹⁹⁸

Conseil d’expert : fast mode ne fonctionne pas avec opusplan (opusplan combine déjà Opus et Sonnet ; fast mode ne concerne que la partie exécutée par Opus). Utilisez-le lorsque la latence compte davantage que le coût et désactivez-le pour les tâches autonomes ou par lots. /fast nécessite une utilisation supplémentaire ; les administrateurs Team/Enterprise peuvent devoir l’activer au préalable (correctif de la v2.1.37). Désactivez-le complètement avec CLAUDE_CODE_DISABLE_FAST_MODE=1. Depuis la v2.1.218, Claude Code vous signale lorsqu’un changement de modèle via /config model=<x> ou Remote Control modifie l’état de fast mode. La v2.1.219 a également corrigé le maintien d’un état obsolète de fast mode dans les clients Remote Control après un changement, une reconnexion ou l’échec d’une vérification de l’organisation.^86149195196

Contrôle de l’effort (v2.1.111+, Opus 4.7)

Opus 4.7 introduit un nouveau réglage de l’effort permettant d’ajuster le compromis entre rapidité et intelligence. Utilisez /effort pendant une session :

> /effort              # opens an interactive slider (arrow keys + Enter)
> /effort xhigh        # set directly

Auto Mode sur Max (v2.1.111+)

Auto Mode, qui remplace --dangerously-skip-permissions de manière plus sûre, est accessible aux abonnés Max avec Opus 4.7 via Anthropic API, sans --enable-auto-mode.¹⁴⁶ Un classificateur Sonnet 4.6 examine chaque action avant son exécution afin de vérifier qu’elle correspond à l’intention et qu’elle est sûre. Remarque (v2.1.111+) : l’option --enable-auto-mode a été supprimée ; démarrez plutôt une session en Auto Mode avec --permission-mode auto. Auto Mode n’est pas disponible avec Pro ; selon la documentation de Anthropic sur les modes d’autorisation, il est directement disponible par défaut sur Anthropic API. Bedrock/Vertex/Foundry (v2.1.158+) : Auto Mode est devenu une option à activer sur Opus 4.7 et Opus 4.8 par l’intermédiaire de ces passerelles avec CLAUDE_CODE_ENABLE_AUTO_MODE=1.²⁰⁵ Depuis la v2.1.207, cette activation n’est plus nécessaire : Auto Mode fonctionne sur AWS Bedrock, Google Vertex AI et Microsoft Foundry sans CLAUDE_CODE_ENABLE_AUTO_MODE. Les administrateurs qui souhaitent le désactiver peuvent utiliser le paramètre géré disableAutoMode. Cette même version définit Claude Opus 4.8 comme modèle par défaut sur Bedrock, Vertex AI et Claude Platform on AWS, et cesse de lire le paramètre autoMode dans le fichier .claude/settings.local.json d’un dépôt : configurez plutôt les règles d’Auto Mode dans ~/.claude/settings.json.¹⁸⁵

Règles personnalisées sans perdre les valeurs par défaut (v2.1.118+). Dans les versions précédentes, autoMode.allow, autoMode.soft_deny et autoMode.environment imposaient un choix exclusif : définir votre propre liste supprimait les règles de sécurité intégrées. La sentinelle $defaults résout ce problème : elle se développe à l’endroit exact où vous la placez pour insérer la liste intégrée, ce qui vous permet d’ajouter vos règles personnalisées autour de celle-ci :¹⁵²

// .claude/settings.json
{
  "autoMode": {
    "allow": [
      "Bash(npm test:*)",        // your additions, prepended
      "$defaults",                // built-in allow list inserted here
      "Bash(git push:origin/feature/*)"  // appended after
    ]
  }
}

Option « Ne plus demander » (v2.1.118+). L’invite d’activation d’Auto Mode propose désormais l’option « Ne plus demander », qui permet aux utilisateurs réguliers de masquer les explications sans devoir automatiser une option.¹⁵²

Garde-fous contre les commandes destructrices (v2.1.183). Auto Mode bloque désormais systématiquement certaines commandes irréversibles, sauf si vous les avez explicitement demandées pendant la session : les opérations git destructrices (git reset --hard, git checkout -- ., git clean -fd, git stash drop) lorsque vous n’avez pas demandé d’abandonner le travail local ; git commit --amend lorsque le commit n’a pas été créé par l’agent pendant cette session ; et la destruction d’infrastructures (terraform destroy, pulumi destroy, cdk destroy), sauf si vous avez nommé la pile concernée. Cela limite le rayon d’impact du classificateur précisément pour les opérations susceptibles d’effacer silencieusement du travail ou de détruire des environnements. L’agent peut toujours les exécuter, mais uniquement sur votre instruction explicite, jamais de sa propre initiative.¹⁷⁴

Classification de chaque commande shell (v2.1.193). Par défaut, le classificateur d’Auto Mode n’examine que les commandes shell correspondant à des schémas d’exécution de code arbitraire ; les commandes courantes lui échappent. Le nouveau paramètre autoMode.classifyAllShell soumet au contraire toutes les commandes Bash/PowerShell au classificateur, au prix d’une légère latence supplémentaire, pour renforcer la sécurité lorsque vous souhaitez faire contrôler chaque appel au shell. Cette même version affiche également les motifs de refus d’Auto Mode dans la transcription, la notification de refus et les refus récents de /permissions. Une commande bloquée explique donc désormais pourquoi elle l’a été.¹⁷⁹ Trois règles de durcissement supplémentaires (v2.1.205). Le mode auto bloque désormais toute altération des fichiers de transcription de session — la piste d’audit elle-même est inaccessible à l’agent ; il demande une confirmation avant d’exécuter rm -rf sur une variable qu’il ne peut pas résoudre à partir du contexte — ce qui élimine la catégorie d’accidents liés à rm -rf $DIR lorsque $DIR est inconnu ; enfin, les notifications des tâches en arrière-plan indiquent désormais explicitement qu’aucune intervention humaine n’a eu lieu, de sorte qu’une fausse ligne « user approved » insérée dans une transcription ne puisse pas être utilisée comme une véritable autorisation.¹⁸³ La troisième règle constitue une défense contre l’injection de prompt qu’il convient de bien comprendre : l’approbation doit parvenir par le canal prévu à cet effet, et le harness rend désormais cette exigence explicite.

La substitution de commande ne peut pas dissimuler une catastrophe (v2.1.208). Les suppressions catastrophiques telles que rm -rf ~ déclenchent désormais une demande de confirmation même lorsqu’elles sont dissimulées dans $(...), des backticks ou une substitution de processus (<(...)) — et cette demande apparaît même avec --dangerously-skip-permissions et en mode auto. Encapsuler une commande destructrice dans une substitution ne permet donc plus de contourner le filet de sécurité.¹⁸⁶

Réinitialiser l’état du mode auto : claude auto-mode reset (v2.1.212). Une nouvelle sous-commande permet de réinitialiser l’état de votre mode auto depuis le terminal ; ajoutez --yes pour ignorer la demande de confirmation :¹⁸⁹

claude auto-mode reset          # Confirmation prompt
claude auto-mode reset --yes    # Skip confirmation (scripts)

Moins de boîtes de dialogue, une vigilance identique (v2.1.218). Trois vérifications qui interrompaient auparavant le mode auto avec une boîte de dialogue d’autorisation — rm dangereux, & en arrière-plan et chemins Windows suspects — ne le font plus ; le classificateur du mode auto les évalue à la place, de sorte que le contrôle de sécurité reste effectué sans vous solliciter à chaque détection. La même version étend ce fonctionnement au mode plan avec auto : les commandes Bash dont l’analyseur statique ne peut pas établir qu’elles sont en lecture seule ne déclenchent plus de demande — le classificateur les évalue au lieu de revenir à une boîte de dialogue.¹⁹⁵

Nouvelles commandes des versions v2.1.105 à v2.1.114¹⁴⁶¹⁵⁰

Notifications push (v2.1.110+)

Lorsque Remote Control est configuré avec l’option « Push when Claude decides » activée, Claude peut désormais envoyer de sa propre initiative des notifications push sur mobile au moyen d’un nouvel outil dédié. Cette fonctionnalité complète l’interface mobile/web Remote Control existante.¹⁴⁶ /context, /exit et /reload-plugins fonctionnent désormais également depuis les clients Remote Control.

Outil Windows PowerShell (v2.1.111+, déploiement progressif)

Claude Code déploie progressivement un outil Windows PowerShell natif. Sous Linux/macOS, activez-le avec CLAUDE_CODE_USE_POWERSHELL_TOOL=1 (nécessite pwsh dans PATH). Sous Windows, la même variable permet d’activer ou de désactiver la fonctionnalité pendant son déploiement.¹⁴⁶

Approbation automatique en mode permission (v2.1.119+). Les commandes de l’outil PowerShell peuvent désormais être approuvées automatiquement en mode permission, comme les commandes Bash. Les règles d’autorisation telles que PowerShell(Get-*:*) et la syntaxe de motifs existante permettent désormais d’éviter la demande de confirmation pour les opérations en lecture seule, offrant ainsi la même ergonomie aux équipes que sous Linux/macOS.¹⁵²

Réduction des demandes d’autorisation : Bash en lecture seule (v2.1.111+)

Les motifs Bash en lecture seule comportant des arguments glob (par exemple ls *.ts, cat src/*.md) et les commandes commençant par cd <project-dir> && ne déclenchent plus de demande d’autorisation.¹⁴⁶ Avec /less-permission-prompts, les interruptions devraient être nettement moins nombreuses dans les workflows quotidiens.

Traçage distribué (v2.1.110+)

Les sessions SDK et headless lisent désormais TRACEPARENT et TRACESTATE dans l’environnement, ce qui rattache les exécutions de Claude Code aux traces distribuées. Associez cette fonctionnalité à OTEL_LOG_RAW_API_BODIES=1 (v2.1.111+) pour émettre l’intégralité des corps de requête et de réponse API sous forme d’événements de journal OpenTelemetry à des fins de débogage.¹⁴⁶

Distribution sous forme de binaire natif (v2.1.113+)¹⁵⁰

La v2.1.113 modifie la manière dont CLI se lance : claude génère désormais un processus exécutant un binaire Claude Code natif par l’intermédiaire d’une dépendance facultative propre à chaque plateforme, au lieu d’exécuter le JavaScript inclus. Les commandes d’installation et de mise à jour restent inchangées, et les équipes n’ont pas besoin de modifier leurs scripts de déploiement.

Raccourcis de l’éditeur de prompt (v2.1.113+)¹⁵⁰

L’éditeur de prompt bénéficie d’une navigation de type readline dans les saisies multilignes, ainsi que du défilement de la fenêtre d’affichage en plein écran :

Délai d’expiration en cas de blocage d’un subagent (v2.1.113+)¹⁵⁰

Les subagents qui se bloquent en cours de flux échouent désormais avec un message d’erreur clair au bout de 10 minutes, au lieu de rester silencieusement suspendus. Associez cette fonctionnalité à CLAUDE_STREAM_IDLE_TIMEOUT_MS (v2.1.84+) pour une couverture plus étendue des processus bloqués lors du streaming de APIs.

Correctif de stabilité de la v2.1.114¹⁵⁰

La v2.1.114 (18 avril 2026) apporte un seul correctif : la boîte de dialogue d’autorisation pouvait planter lorsqu’un membre d’Agent Teams demandait l’autorisation d’utiliser un outil. Effectuez la mise à niveau si vous utilisez Agent Teams.

Combien coûte Claude Code ?

Comprendre et maîtriser les coûts est essentiel pour utiliser Claude Code de manière durable. Consultez également Sélection du modèle pour découvrir les capacités des modèles et Cadres de décision pour choisir le modèle adapté à chaque tâche.

Consultation des coûts

> /cost

Résultat :

Total cost:            $0.55
Total duration (API):  6m 19.7s
Total duration (wall): 6h 33m 10.2s
Total code changes:    247 lines added, 89 lines removed

Dans /cost, les utilisateurs disposant d’un abonnement voient une ventilation par modèle et par accès au cache, indiquant précisément quels modèles ont consommé des tokens et quelle quantité a été fournie depuis le cache (v2.1.92+).¹³⁷

Formules d’abonnement

Limites de débit (août 2025) : Anthropic a instauré des limites de débit hebdomadaires pour les abonnés payants. Les abonnés Max peuvent acheter de l’utilisation supplémentaire au-delà de la limite, aux tarifs API standard.¹⁴

Doublement des limites de débit (6 mai 2026) : lors de l’événement Code with Claude SF, Anthropic a doublé les limites de débit de Claude Code sur 5 heures pour les formules Pro, Max, Team et Enterprise par siège, supprimé la réduction appliquée aux heures de pointe sur les comptes Pro et Max, et augmenté « considérablement » les limites de débit de API pour les modèles Claude Opus. L’accord SpaceX Colossus 1 constitue la garantie de capacité : « plus de 300 mégawatts de nouvelle capacité (plus de 220 000 GPUs NVIDIA) dans le mois ».¹⁵⁷

Tarification des tokens API (avril 2026)¹¹⁴⁴

Pour les utilisateurs facturés via API, voici le prix par million de tokens :

Tarification du contexte de 1M (avril 2026) : Opus 4.7, Opus 4.6, Sonnet 4.6 et Mythos Preview incluent tous 1M aux tarifs standard par million de tokens — sans supplément pour contexte long.¹⁴⁸ Cette uniformisation est récente ; les anciennes recommandations indiquant qu’Opus 4.6 ou Sonnet 4.6 coûtaient 2× plus cher en entrée et 1,5× plus cher en sortie au-delà de 200K tokens d’entrée ne sont plus d’actualité. Opus 4.5 et les modèles antérieurs conservent leurs structures tarifaires d’origine.

Tarification liée à la résidence des données : imposer une inférence exclusivement aux États-Unis via inference_geo applique un multiplicateur de 1,1× à l’ensemble de la tarification des tokens, y compris aux lectures et écritures du cache (modèles Opus 4.6+).¹⁴⁸

La mise en cache des prompts réduit considérablement les coûts des entrées répétées : les écritures dans le cache coûtent 1,25× le tarif de base (cache de 5 min) ou 2× (cache de 1 h), mais les lectures ne coûtent que 0,1×, soit une économie de 90 %. Pour les systèmes RAG et les assistants de programmation utilisant un contexte répété, la mise en cache peut réduire les coûts de 88 à 95 %.

Batch API offre une réduction de 50 % avec un délai de traitement de 24 heures pour les tâches non urgentes, telles que les suites de tests exécutées pendant la nuit.

Politique relative aux comptes multiples⁵²

Pouvez-vous posséder plusieurs comptes Claude ? Oui, pour des cas d’usage légitimes. Anthropic autorise explicitement plusieurs comptes lorsqu’ils répondent à des besoins distincts.

Ce qui est autorisé :

Limites techniques : - Jusqu’à 3 comptes peuvent être vérifiés avec le même numéro de téléphone - Plusieurs abonnements payants provenant de la même adresse IP ou du même réseau sont explicitement pris en charge - Les comptes sont entièrement distincts ; aucun transfert de conversation ou de projet n’est possible entre eux

Ce qui est interdit (conformément à la Politique d’utilisation) : - Créer des comptes pour contourner une interdiction après avoir été banni - Coordonner des activités malveillantes entre plusieurs comptes afin d’échapper à la détection - Utiliser plusieurs comptes pour contourner les limites de débit ou les crédits de la formule gratuite

Exemple concret : en janvier 2026, les 22 comptes Max de l’utilisateur intensif Jeffrey Emanuel (@doodlestein) ont été automatiquement signalés et temporairement suspendus. Thariq (@trq212), employé de Anthropic, a résolu le problème en moins de 4 heures après avoir confirmé que l’utilisation était légitime. Si vous utilisez intensivement Claude Code pour vos projets professionnels et personnels avec plusieurs comptes, le service est précisément conçu pour cela ; n’essayez toutefois pas de détourner le système.

En cas de doute : contactez l’assistance Anthropic afin d’obtenir une confirmation écrite pour votre configuration particulière.

Facteurs de coût

Exemples de coûts réels

Conseil pour réduire les coûts : utiliser Haiku pour les subagents chargés de l’exploration et Sonnet pour l’implémentation réduit généralement les coûts de 40 à 50 % par rapport à l’utilisation systématique de Sonnet.

Gestion des coûts d’équipe

TPM/RPM recommandés selon la taille de l’équipe :

Frais cachés des outils

Au-delà de la tarification par token, certains outils entraînent des frais distincts :⁹

Ces frais s’accumulent dans les boucles d’agents. Un cycle de débogage de 100 itérations avec Bash coûte à lui seul environ 24 500 tokens d’entrée supplémentaires en surcoût.

Stratégies de réduction des coûts

1. Utilisez Haiku pour les subagents : la plupart des tâches d’exploration ne nécessitent pas Sonnet
2. Activez la mise en cache des prompts : elle l’est par défaut, mais vérifiez qu’elle n’a pas été désactivée
3. Définissez un nombre maximal de tours : claude --max-turns 5 évite les conversations incontrôlées
4. Définissez un plafond en dollars : claude --max-budget-usd 5 interrompt définitivement la session lorsqu’elle atteint le plafond de dépenses. Depuis la v2.1.217, ce plafond s’applique également aux subagents en arrière-plan : une fois atteint, les nouveaux lancements sont refusés et les agents en arrière-plan déjà actifs sont arrêtés (auparavant, ils échappaient à cette limite budgétaire)¹⁹⁴
5. Utilisez le mode plan pour l’exploration : aucune exécution = aucune opération coûteuse accidentelle
6. Compactez de manière proactive : moins de contexte = moins de tokens
7. Limitez la sortie : export CLAUDE_CODE_MAX_OUTPUT_TOKENS=2000
8. Utilisez Batch API pour les tâches non urgentes : 50 % de réduction sur les tokens d’entrée comme de sortie

Suivi de l’utilisation

• Console Claude : platform.claude.com (rôle Admin ou Billing requis)
• Limites de l’espace de travail : définissez des plafonds de dépenses par espace de travail
• Bedrock/Vertex : utilisez les outils natifs de suivi des coûts du cloud
• LiteLLM : pour un suivi détaillé par utilisateur avec des fournisseurs tiers

Consommation de tokens en arrière-plan

Certaines opérations consomment des tokens en arrière-plan : - Résumé des conversations pour /resume - Commandes /cost et /status - Compactage automatique

Généralement moins de 0,04 $ par session.

API d’analyse de Claude Code (Team/Enterprise)⁴⁶

Accédez par programmation aux données d’utilisation de Claude Code et aux indicateurs de productivité de votre organisation via l’Admin API.

Endpoint : GET /v1/organizations/usage_report/claude_code

Conditions requises : - Clé Admin API (sk-ant-admin...) - Formule Team ou Enterprise - Rôle Admin, Billing ou Developer

Indicateurs disponibles :

Exemple de requête :

curl "https://api.anthropic.com/v1/organizations/usage_report/claude_code?starting_at=2026-01-15" \
  -H "x-api-key: sk-ant-admin..." \
  -H "anthropic-version: 2023-06-01"

Cas d’usage : - Analyse de la productivité des développeurs (sessions, commits, PR) - Indicateurs d’utilisation des outils (taux d’acceptation/de rejet pour Edit, Write, etc.) - Suivi et répartition des coûts entre les équipes - Justification du ROI pour les outils de programmation assistée par l’IA

Remarque : les données apparaissent dans l’heure suivant la fin de l’activité. Pour garantir la cohérence, seules les données datant de plus d’une heure sont incluses dans les réponses.

Cadres de décision

Connaître les fonctionnalités ne suffit pas. Vous devez savoir quand utiliser chacune d’elles. Ces arbres de décision transforment vos connaissances en actions.

Quel modèle utiliser ?

START → Is the task simple? (file search, quick question, formatting)
         │
         ├── YES → Use Haiku
         │         Cost: ~$0.03/task
         │         Speed: Fastest
         │
         └── NO → Does it require deep reasoning?
                  (architecture, complex debugging, security analysis)
                  │
                  ├── YES → Use Opus 4.7 (xhigh effort default)
                  │         Cost: ~$2.00/task
                  │         Quality: Highest (1M context at standard price, adaptive reasoning)
                  │
                  └── NO → Use Sonnet
                           Cost: ~$0.75/task
                           Balance: Best overall when cost matters

Règle générale : Opus 4.7 est le modèle par défaut pour Max et Team Premium. Avec Pro/Team Standard/Enterprise/API, Sonnet 4.6 est le modèle par défaut (Enterprise + Anthropic API passeront à Opus 4.7 le 23 avril 2026).¹⁴⁷ Passez à Haiku pour les subagents. Passez à Opus lorsque la réponse de Sonnet vous paraît superficielle. Avec les équipes d’agents (v2.1.32+), Opus peut coordonner plusieurs agents travaillant en parallèle sur différentes sous-tâches.⁷⁹

Commande, skill, subagent ou équipe d’agents ?

Do you want explicit control over when it runs?
│
├── YES → Use Slash Command
│         Example: /deploy, /test, /security-review
│         You invoke it. You control timing.
│
└── NO → Should the expertise apply automatically based on context?
         │
         ├── YES → Use Skill
         │         Example: Security patterns, domain rules, code standards
         │         Claude recognizes context and applies expertise.
         │
         └── NO → Does the work need isolated context?
                  │
                  ├── YES → Is there one subtask or many parallel subtasks?
                  │         │
                  │         ├── ONE → Use Subagent (Task tool)
                  │         │         Example: Deep exploration, parallel analysis
                  │         │         Prevents context bloat in main conversation.
                  │         │
                  │         └── MANY → Use Agent Team (v2.1.32+)
                  │                   Example: 5 agents reviewing different modules simultaneously
                  │                   Opus coordinates; each agent works independently.
                  │
                  └── NO → Just prompt directly
                           Not everything needs abstraction.

Hook ou prompt ?

Must the action ALWAYS happen, regardless of Claude's judgment?
│
├── YES → Use Hook (deterministic)
│         Examples:
│         - Format code after every edit
│         - Log all bash commands
│         - Block access to .env files
│         Claude cannot skip, forget, or decide otherwise.
│
└── NO → Use Prompt (probabilistic)
         Examples:
         - "Consider adding tests"
         - "Think about edge cases"
         - "Review for security if relevant"
         Claude decides based on context.

Quand utiliser la réflexion approfondie ?

Is this a genuinely hard problem?
│
├── Architectural decision with many tradeoffs → YES, use thinking
├── Complex debugging with unclear root cause → YES, use thinking
├── Security analysis requiring careful reasoning → YES, use thinking
├── Understanding unfamiliar codebase → YES, use thinking
│
├── Routine bug fix → NO, skip thinking
├── Simple refactoring → NO, skip thinking
├── Code formatting → NO, skip thinking
└── Quick questions → NO, skip thinking

Activez-la ou désactivez-la avec Alt+T pendant la session. Les budgets de réflexion plus élevés coûtent plus cher ; commencez par le minimum et augmentez-le uniquement si les réponses vous semblent précipitées.

Réflexion adaptative d’Opus 4.6 : Opus 4.6 ajuste automatiquement la profondeur de sa réflexion en fonction de la complexité du problème. Pour la plupart des tâches, il n’est pas nécessaire de contrôler explicitement le budget de réflexion — Opus approfondit son analyse pour les problèmes difficiles et reste rapide pour les plus simples. Le réglage manuel de la réflexion est surtout utile avec Sonnet lorsque vous souhaitez imposer une analyse plus approfondie.

Quelle interface d’exécution ?

Where should this work happen?
│
├── Requires YOUR local files and tools
│   │
│   ├── Interactive, iterative work → Main REPL session
│   ├── One-shot scripted task → claude -p "prompt" (print mode)
│   ├── CI/CD automation → claude -p --json (non-interactive + structured output)
│   └── Parallel isolated tasks → Subagents via Task tool
│
├── Requires SOMEONE ELSE'S environment
│   │
│   └── Remote codebase or server → Background agent (cloud)
│
└── Doesn't require any environment
    │
    ├── Research or analysis → Subagent with Explore type
    └── Web content extraction → WebFetch / WebSearch tools

Équipes d’agents, subagents ou sessions parallèles

Do you need multiple agents working on related subtasks?
│
├── YES → Are the subtasks independent (no shared state)?
│         │
│         ├── YES → Can they share the same codebase?
│         │         │
│         │         ├── YES → Use Agent Team (v2.1.32+)
│         │         │         Opus coordinates. Agents share repo access.
│         │         │         Example: "Review auth, API, and DB modules in parallel"
│         │         │
│         │         └── NO → Use Parallel Sessions (separate terminals)
│         │                  Each has its own working directory.
│         │                  Example: "Fix repo-A and repo-B simultaneously"
│         │
│         └── NO → Use Sequential Subagents
│                  Results from one feed into the next.
│                  Example: "Explore → Plan → Implement"
│
└── NO → Use Single Subagent or Main REPL

Quel type de hook ?

What kind of automation do you need?
│
├── Run a shell command at a specific event?
│   │
│   └── Use Command Hook
│       Trigger: PreToolUse, PostToolUse, Notification, Stop, SubagentStop
│       Example: "Run prettier after every file edit"
│       Config: hooks.PostToolUse[].command = "prettier --write $FILE"
│
├── Modify Claude's system prompt based on context?
│   │
│   └── Use Prompt Hook (v2.1.35+)
│       Trigger: Same events
│       Example: "Inject project rules when working in /src/auth/"
│       Config: hooks.PreToolUse[].prompt = "When editing auth files..."
│
└── Have Claude make a judgment call before proceeding?
    │
    └── Use Agent Hook (v2.1.35+)
        Trigger: Same events
        Example: "Evaluate if this bash command is safe before running"
        Config: hooks.PreToolUse[].agent = { prompt: "Is this safe?" }

Quand utiliser /fast ?

Is response speed more important than depth right now?
│
├── YES → Use /fast   (Opus 5 or Opus 4.8 only, v2.1.219+)
│         Same model, ~2.5× output speed at 2× price
│         Good for: quick questions, simple edits, code explanations,
│                   file searches, formatting tasks
│
└── NO → Stay in normal mode
         Good for: architecture decisions, complex debugging,
                   security reviews, multi-file refactors,
                   anything requiring deep reasoning

/fast active ou désactive le mode rapide pour la session en cours. Il utilise le même modèle — Opus 5 ou Opus 4.8, les deux seuls modèles compatibles avec le mode rapide depuis la v2.1.219 — avec une vitesse de génération optimisée. Il ne passe PAS à un modèle moins cher et, à 10 $/50 $ par MTok, il n’est pas non plus plus économique.¹⁹⁶¹⁹⁸

Comment fonctionne le système d’autorisations ?

Le système d’autorisations de Claude Code offre un contrôle précis sur les opérations qui peuvent être exécutées. Il est essentiel de le comprendre pour garantir à la fois la sécurité et l’efficacité du workflow. Consultez également Déploiement en entreprise pour découvrir les paramètres gérés qui imposent des autorisations à l’échelle de l’organisation.

Niveaux d’autorisation

Outils en lecture seule (approuvés automatiquement) : - Read - Lire le contenu des fichiers - Glob - Rechercher des fichiers selon un motif - Grep - Rechercher dans le contenu des fichiers - WebSearch - Effectuer une recherche sur le Web - LSP - Intelligence de code (accéder à la définition, rechercher les références, afficher la documentation au survol)¹⁸

Fonctionnalités de l’outil LSP (v2.0.74+) : L’outil LSP offre une intelligence de code comparable à celle d’un IDE : - Accès à la définition : accéder à l’emplacement où un symbole est défini - Recherche des références : répertorier toutes les utilisations d’un symbole dans l’ensemble de la base de code - Documentation au survol : obtenir les informations de type et la documentation de n’importe quel symbole - Compatible avec TypeScript, Python, Go, Rust et d’autres langages prenant en charge LSP - Nécessite la disponibilité d’un serveur de langage (généralement installé avec votre chaîne d’outils)

Outils de modification (approbation requise) : - Edit - Modifier des fichiers existants - Write - Créer de nouveaux fichiers - Bash - Exécuter des commandes shell - WebFetch - Récupérer le contenu d’URL - NotebookEdit - Modifier des notebooks Jupyter

Lors de la première exécution d’un outil de modification, Claude Code vous demande votre approbation. Les approbations restent valables pendant toute la session, sauf configuration explicite contraire.

Outil EndConversation (v2.1.214). Claude Code dispose désormais de la même capacité à mettre fin à une conversation que Claude sur claude.ai depuis 2025 : dans de rares cas de saisies extrêmement abusives ou de tentatives persistantes de jailbreak, Claude peut mettre fin immédiatement à la session grâce à l’outil intégré EndConversation. Il s’agit d’une mesure de résistance aux abus et de protection du bien-être du modèle, pas d’une fonctionnalité de workflow : elle ne se déclenche jamais au cours des sessions de développement normales.¹⁹⁰¹⁹³

Modes d’autorisation

Le mode default est intitulé « Manual » depuis la v2.1.200. Ce changement de nom concerne CLI, --help, VS Code et JetBrains ; la valeur de configuration n’a pas changé, si bien que "defaultMode": "default" fonctionne toujours, tandis que --permission-mode manual et "defaultMode": "manual" sont désormais acceptés comme alias. Le comportement reste identique — une confirmation est demandée lors de la première utilisation de chaque outil — mais l’intitulé ne donne plus l’impression qu’il s’agit du « mode appliqué par défaut », alors qu’il s’agit en réalité du mode d’approbation manuelle. Dans cette même version, les boîtes de dialogue AskUserQuestion ne poursuivent plus automatiquement par défaut ; un subagent qui pose une question attend désormais votre réponse au lieu de continuer après un délai d’expiration. Vous pouvez réactiver ce délai d’inactivité via /config.

Les fichiers de configuration permettant l’exécution de code déclenchent désormais une demande de confirmation, même avec acceptEdits (v2.1.160). acceptEdits approuve automatiquement les modifications ordinaires, mais depuis la v2.1.160, il s’interrompt et demande une confirmation avant d’écrire dans des fichiers susceptibles d’autoriser l’exécution silencieuse de commandes : fichiers de démarrage du shell (.zshenv, .zlogin, .bash_login), ~/.config/git/ et configurations d’outils de build (.npmrc, .yarnrc*, bunfig.toml, .bazelrc, .pre-commit-config.yaml, .devcontainer/ et fichiers similaires). En effet, toute modification de l’un de ces fichiers transforme le prochain lancement du shell, la prochaine installation ou le prochain commit en vecteur d’exécution ; ils font donc l’objet d’un contrôle délibéré, même dans un mode destiné aux projets de confiance qui autorise normalement les modifications sans intervention. Ce modèle de menace est le même que celui des protections existantes contre les écritures dans .claude/, .git/ et .vscode/, mais il est étendu à la catégorie plus large des fichiers dont la « modification entraîne une exécution ».²⁰⁴

Auto Mode (v2.1.85+) : une solution de remplacement plus sûre pour --dangerously-skip-permissions. Un modèle de classification distinct (Sonnet 4.6) examine chaque action avant son exécution afin de vérifier qu’elle correspond à l’intention de l’utilisateur et qu’elle est sûre.¹²⁴

Fonctionnement : - Les actions en lecture seule et les modifications de fichiers dans le répertoire de travail sont approuvées automatiquement - Les règles personnalisées d’autorisation et de refus sont évaluées en premier - Toutes les autres actions sont soumises au classificateur pour évaluation - En cas de blocage, Claude tente automatiquement une autre approche

Actions bloquées automatiquement par défaut : curl | bash, push forcé vers la branche principale, déploiements et migrations en production, suppressions massives dans le cloud, modifications des IAM ou des autorisations et envoi externe de données sensibles.¹²⁵

Coupe-circuit : après 3 blocages consécutifs ou 20 blocages au total au cours d’une session, le système revient aux demandes d’approbation manuelles.¹²⁵

# Enable at startup
claude --enable-auto-mode

# Or cycle into it during a session
Shift+Tab  # Cycles through: Manual (aka default) → acceptEdits → auto → plan

Disponibilité : d’abord pour les utilisateurs de l’offre Team, puis pour Enterprise et API. Nécessite Sonnet 4.6 ou Opus 4.6.¹²⁴

Mode YOLO (v2.0.68+) : pour un fonctionnement entièrement autonome sans aucun classificateur de sécurité, utilisez le flag --dangerously-skip-permissions. Ce flag accepte tout : modifications de fichiers, commandes Bash et tous les appels d’outils. Le mot « dangerously » est volontaire. Auto Mode constitue la solution recommandée pour la plupart des cas d’usage.⁵⁴

claude --dangerously-skip-permissions

Définissez le mode via CLI :

claude --permission-mode auto  # or acceptEdits, plan, bypassPermissions

Changez de mode pendant la session :

Shift+Tab  # Cycles through modes

Dans settings.json :

{
  "permissions": {
    "defaultMode": "acceptEdits"
  }
}

Syntaxe des règles d’autorisation

Des règles précises contrôlent des opérations spécifiques. Elles sont évaluées dans l’ordre : la première correspondance l’emporte.

Motifs de commandes Bash :

{
  "allow": [
    "Bash(npm run build)",
    "Bash(npm run test:*)",
    "Bash(git commit:*)",
    "Bash(make:*)"
  ],
  "deny": [
    "Bash(rm -rf:*)",
    "Bash(sudo:*)",
    "Bash(curl|wget:*)"
  ]
}

L’astérisque permet une correspondance par préfixe : Bash(npm run test:*) autorise npm run test, npm run test:unit et npm run test:integration.

Limitation importante : les motifs Bash correspondent uniquement à des préfixes, et non à des expressions régulières. Un motif comme Bash(curl http:*) ne correspondra pas à curl -X GET http://..., car les options précèdent l’URL. Pour un blocage fiable, refusez entièrement la commande : Bash(curl:*).

Motifs d’opérations sur les fichiers :

{
  "allow": [
    "Edit(src/**)",
    "Read(docs/**)"
  ],
  "deny": [
    "Read(.env*)",
    "Read(secrets/**)",
    "Edit(.git/**)",
    "Edit(node_modules/**)"
  ]
}

Syntaxe des chemins : - Chemins relatifs : Edit(src/**) - relatifs au répertoire de travail - Chemins absolus depuis le fichier de paramètres : Edit(/build/**) - relatifs à l’emplacement du fichier de paramètres - Chemins véritablement absolus : Edit(//tmp/**) - commencent par // - Répertoire personnel : Read(~/.zshrc)

Les règles d’autorisation dir/** à segment unique ne correspondent désormais qu’à <cwd>/dir (v2.1.214) — vérifiez vos règles existantes. Avant la v2.1.214, une règle d’autorisation comme Edit(src/**) approuvait automatiquement les écritures dans n’importe quel répertoire nommé src de l’arborescence — vendor/src/, packages/foo/src/, entre autres. Elle correspond désormais uniquement au répertoire src situé directement sous le répertoire de travail. Si vous dépendiez de l’ancien comportement à profondeur quelconque, réécrivez la règle sous la forme Edit(**/src/**). Les règles deny et ask conservent leur correspondance à n’importe quelle profondeur : ce changement restreint ce qui est approuvé automatiquement, jamais ce qui est bloqué. Lorsqu’une règle cesse silencieusement de correspondre, de nouvelles demandes d’autorisation apparaissent après la mise à niveau, sans message d’erreur. Vérifiez donc toutes les règles d’autorisation écrites sous cette forme à segment unique. Les conditions if: des hooks ont reçu la même portée limitée au répertoire de travail dans cette version (consultez Matchers).¹⁹⁰

Utilisez Edit(path)/Read(path), et non Write(path)/NotebookEdit(path)/Glob(path) (v2.1.210). Claude Code affiche désormais au démarrage un avertissement pour les règles d’autorisation visant Write(path), NotebookEdit(path) ou Glob(path). Les formes canoniques sont les deux familles de règles qui contrôlent réellement l’accès aux fichiers : Edit(path) couvre tous les outils d’écriture de fichiers, y compris Write et NotebookEdit, tandis que Read(path) couvre tous les outils de lecture de fichiers, y compris Glob. Migrez vos anciennes règles pour supprimer l’avertissement et rendre leur intention explicite.¹⁸⁷

« Always allow » enregistre les règles à la racine du dépôt (v2.1.211). Les règles d’autorisation créées à l’aide de l’option « Always allow » dans la demande de confirmation sont désormais écrites à la racine du dépôt plutôt que dans le worktree actuel. Une approbation accordée dans un worktree persiste ainsi entre les sessions et dans tous les worktrees de ce dépôt : vous n’avez plus à approuver de nouveau la même commande dans chaque checkout parallèle.¹⁸⁸

Motifs des outils MCP :

{
  "allow": [
    "mcp__github",
    "mcp__database__query",
    "mcp__myserver__*"
  ],
  "deny": [
    "mcp__dangerous_server",
    "mcp__untrusted__*"
  ]
}

Utilisez la syntaxe générique mcp__server__* pour autoriser ou refuser tous les outils d’un serveur MCP donné.³² Cette syntaxe permet d’activer rapidement tous les outils de serveurs de confiance ou de bloquer des serveurs entiers provenant de sources non fiables.

Depuis la v2.1.166, les règles de refus acceptent également un glob à la place du nom de l’outil : un simple "*" dans l’emplacement réservé au nom de l’outil refuse tous les outils, ce qui permet de tout bloquer avant d’en autoriser un ensemble restreint. En revanche, les règles d’autorisation rejettent les globs qui ne concernent pas MCP : vous ne pouvez pas tout autoriser aussi largement, ce qui maintient une posture restrictive par défaut.²⁰²

Correspondance au niveau des paramètres — Tool(param:value) (v2.1.178) :

Au-delà du nom de l’outil, une règle peut cibler les paramètres d’entrée de celui-ci, avec * comme caractère générique dans la valeur :

{
  "deny": [
    "Agent(model:opus)"
  ]
}

Agent(model:opus) bloque tout subagent lancé avec le niveau Opus : le lancement lui-même est refusé, et il ne s’agit pas d’une simple consigne dans le prompt demandant de l’éviter. Le contrôle des autorisations passe ainsi de « quel outil » à « comment il est appelé », sous la forme d’une règle déterministe plutôt que d’une requête au niveau du prompt. Ce mécanisme fonctionne avec le paramètre géré enforceAvailableModels : la liste d’autorisation définit les niveaux de modèles disponibles pour la session, tandis que les règles Tool(model:...) limitent la façon dont les subagents peuvent les utiliser.¹⁷³

Depuis la v2.1.186, ces règles Agent(...) s’appliquent également aux lancements de subagents nommés : les règles de refus Agent(agent_type) et les restrictions de types autorisés Agent(x,y) s’appliquent lorsqu’un agent nommé spécifique est lancé (via un workflow, --agents ou une équipe d’agents), et plus uniquement aux lancements anonymes de type Task. Le lancement est bloqué dès son déclenchement, ce qui comble une lacune permettant à un agent nommé de contourner une règle censée le restreindre.¹⁷⁵

Motifs WebFetch :

{
  "allow": [
    "WebFetch(domain:github.com)",
    "WebFetch(domain:api.example.com)"
  ]
}

Répertoires supplémentaires

Étendez l’accès de Claude au-delà du projet actuel :

{
  "permissions": {
    "additionalDirectories": [
      "../shared-lib",
      "../docs",
      "~/reference-projects/design-system"
    ]
  }
}

Les répertoires supplémentaires sont essentiels pour les monorepos ou lorsque Claude doit consulter du code situé dans des répertoires voisins.

Mode sandbox

Activez l’isolation du système de fichiers et du réseau :

> /sandbox

Ou configurez-la dans les paramètres :

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["git", "docker"],
    "network": {
      "allowUnixSockets": ["~/.ssh/agent-socket"],
      "allowLocalBinding": true,
      "deniedDomains": ["pastebin.com", "transfer.sh", "0x0.st"]
    }
  }
}

Depuis la v2.1.187, le paramètre sandbox.credentials empêche les commandes exécutées dans la sandbox de lire les fichiers d’identifiants et les variables d’environnement secrètes : une protection en profondeur contre l’exfiltration de secrets par une commande isolée.¹⁷⁶

Depuis la v2.1.216, le paramètre sandbox.filesystem.disabled désactive l’isolation du système de fichiers tout en conservant le contrôle des communications réseau sortantes. Il est utile lorsque la prison du système de fichiers perturbe un outil de build, mais que vous souhaitez toujours appliquer la liste d’autorisation des domaines au trafic sortant.¹⁹²

Depuis la v2.1.219, le paramètre sandbox.network.strictAllowlist refuse immédiatement les hôtes absents de la liste d’autorisation, sans demander de confirmation. Par défaut, lorsqu’une commande exécutée dans la sandbox tente de joindre un hôte qui ne figure pas dans allowedDomains, une demande d’autorisation apparaît ; lorsque strictAllowlist est activé, la connexion est simplement refusée. Ce paramètre est particulièrement adapté aux exécutions sans surveillance — CI, agents en arrière-plan, boucles nocturnes — où une demande à laquelle personne ne répond provoque un blocage et où « m’interroger en cas de trafic sortant inattendu » constitue de toute façon une politique inadaptée. Il complète la triade réseau : allowedDomains indique ce qui est autorisé, deniedDomains (ci-dessous) exclut certaines destinations d’une autorisation large et strictAllowlist détermine si tout le reste déclenche une demande ou échoue.¹⁹⁶

Dans la sandbox : - L’accès au système de fichiers est limité au répertoire du projet - L’accès au réseau est contrôlé - Certaines commandes sont exclues des restrictions de la sandbox - Les commandes Bash sont autorisées automatiquement si autoAllowBashIfSandboxed vaut true

Conseil d’expert : le mode sandbox est excellent pour exécuter Claude sur des bases de code non fiables. Activez-le lorsque vous explorez des projets inconnus ou souhaitez bénéficier d’une couche de protection supplémentaire. Des tests internes menés par Anthropic ont montré que la sandbox réduit les demandes d’autorisation de 84 %.³⁸ Elle utilise des mécanismes du système d’exploitation (seatbelt sur macOS, bubblewrap sous Linux) pour isoler le système de fichiers et le réseau. Même une injection de prompt réussie reste donc entièrement confinée. Anthropic a publié le runtime de la sandbox en open source pour les équipes qui développent leurs propres agents.⁸²

Notes de sécurité (v2.1.34+) : les commandes exclues de la sandbox via sandbox.excludedCommands ou dangerouslyDisableSandbox pouvaient auparavant contourner la règle demandant une autorisation pour Bash lorsque autoAllowBashIfSandboxed était activé ; ce problème a été corrigé dans la v2.1.34.⁸⁷ Depuis la v2.1.38, les écritures dans .claude/skills sont bloquées en mode sandbox, ce qui empêche une injection de prompt de modifier les définitions des skills.⁸⁸ La v2.1.77 ajoute le paramètre de système de fichiers allowRead à la sandbox afin de réautoriser la lecture dans les zones couvertes par denyRead — utile lorsque vous souhaitez bloquer la majeure partie d’une arborescence tout en plaçant certains sous-répertoires sur liste d’autorisation.¹¹⁹

Exemption de la configuration des agents dans .claude/ (v2.1.121+) : --dangerously-skip-permissions ne demande plus de confirmation pour les écritures dans .claude/skills/, .claude/agents/ et .claude/commands/.¹⁵⁴

Résolution des répertoires .claude/ imbriqués (v2.1.178) : les skills présents dans des répertoires .claude/skills imbriqués sont désormais chargés automatiquement lorsque vous travaillez sur des fichiers situés sous le répertoire concerné, et plus uniquement depuis la racine du dépôt ; en cas de conflit de noms, le skill imbriqué reste accessible sous la forme <dir>:<name>, de sorte que les deux restent disponibles. Le reste de la surface du projet est résolu de la même manière : lorsqu’un nom d’agent, de workflow ou de style de sortie entre en conflit entre plusieurs répertoires .claude/ imbriqués, celui qui est le plus proche du répertoire de travail l’emporte. De même, l’enregistrement d’un workflow à l’échelle du projet cible le répertoire .claude/workflows/ existant le plus proche. Dans un monorepo ou un dépôt composé de plusieurs dépôts, cela permet d’utiliser des outils propres à chaque package, activés selon le contexte, au lieu d’une surface globale unique.¹⁷³

Chemins personnalisés pour bubblewrap et socat (v2.1.133+) : les paramètres gérés sandbox.bwrapPath et sandbox.socatPath permettent aux administrateurs d’indiquer aux déploiements Linux/WSL des emplacements non standard pour les exécutables bubblewrap et socat. Cela s’avère utile lorsque les distributions installent ces outils hors de $PATH ou lorsque l’organisation fournit ses propres builds renforcés.¹⁶⁰

Renforcement de la sécurité dans la v2.1.113 :¹⁵⁰

• sandbox.network.deniedDomains bloque des hôtes spécifiques même lorsqu’un caractère générique plus large dans allowedDomains les autoriserait normalement. Utilisez cette liste de blocage pour interdire les sites de partage de texte, les services de dépôt de fichiers ou les hôtes malveillants connus sans réécrire l’ensemble de votre politique d’autorisation. Associez-la à sandbox.network.strictAllowlist (v2.1.219, ci-dessus) si vous souhaitez que tout ce qui se trouve hors de la liste d’autorisation soit refusé silencieusement au lieu de déclencher une demande.
• Règles de refus pour les commandes enveloppées. Les règles de refus Bash reconnaissent désormais les commandes enveloppées par env, sudo, watch, ionice, setsid et des wrappers d’exécution similaires. Les règles comme Bash(rm:*) interceptent maintenant env rm -rf, sudo rm -rf et les méthodes de contournement apparentées.
• Les règles d’autorisation Bash(find:*) n’approuvent plus automatiquement find -exec ni find -delete. Ces flags exécutent des commandes et suppriment des fichiers ; Claude Code les soumet donc au processus d’autorisation normal.
• Protection contre les suppressions sous macOS. Les règles d’autorisation Bash(rm:*) considèrent désormais /private/etc, /private/var, /private/tmp et /private/home comme des cibles de suppression dangereuses. /var, /etc et /tmp sont des liens symboliques vers /private/ ; la forme précédente de la règle ne détectait donc pas les cibles canoniques.

Renforcement du refus par défaut des autorisations dans la v2.1.214 :¹⁹⁰

Plusieurs lacunes des contrôles d’autorisation ont été corrigées dans une même version, toutes dans le sens d’un refus par défaut : lorsque l’analyseur ne peut pas statuer avec certitude, il demande une confirmation :

• Correction d’un contournement sous Windows PowerShell 5.1. Les commandes exécutées dans des sessions PowerShell 5.1 pouvaient auparavant échapper au contrôle des autorisations.
• Les redirections de descripteurs de fichiers Bash échouent désormais de manière sûre. Les formes de redirection interprétées différemment par Bash et par l’analyseur d’autorisations déclenchent désormais une demande de confirmation au lieu d’être exécutées.
• Les commandes dépassant 10 000 caractères déclenchent toujours une demande. Les commandes très longues étaient auparavant mal évaluées ; elles ne sont désormais jamais exécutées automatiquement.
• Les indices et modificateurs zsh dans [[ ]] déclenchent une demande. Les indices et modificateurs de variables dans les comparaisons [[ ]] étaient considérés comme du texte inerte ; puisqu’ils peuvent exécuter du code, ils nécessitent désormais une approbation.
• Les variantes dangereuses de help/man ne sont plus approuvées automatiquement. Certaines invocations pouvaient exécuter des options dangereuses, des substitutions de commandes ou des chemins contenant des barres obliques inverses sous couvert de consultation de la documentation.
• Ordre des demandes dans les sessions distantes. Les demandes d’autorisation des sessions distantes ne peuvent plus être validées avant la boîte de dialogue de confirmation locale.
• Les flags de redirection du daemon docker déclenchent une demande. Les commandes docker — y compris le shim docker de Podman — comportant --url, --connection, --identity ou le mode distant de Podman s’exécutaient auparavant sans demande de confirmation ; ces flags dirigent pourtant la commande vers un daemon entièrement différent.
• file perd son autorisation automatique en lecture seule lorsqu’une destination d’écriture lui est indiquée. file -m/--magic-file et -f/--files-from nécessitent désormais une autorisation au lieu d’être automatiquement considérés comme des opérations en lecture seule.

Comment fonctionnent les hooks ?

Les hooks exécutent des commandes shell déterministes à des étapes précises du workflow de Claude Code. Contrairement aux instructions demandant à Claude d’effectuer des actions, les hooks garantissent leur exécution quel que soit le comportement du modèle. Ils sont essentiels pour faire respecter les normes de l’équipe et automatiser les tâches répétitives. Consultez Cadres de décision pour découvrir l’arbre de décision « Quel type de hook ? », qui couvre les hooks de commande, de prompt et d’agent.

Pourquoi utiliser des hooks plutôt que des prompts : demander à Claude de « toujours exécuter Prettier après la modification de fichiers » fonctionne parfois. Mais Claude peut oublier, privilégier la rapidité ou estimer que la modification est « trop petite ». Les hooks garantissent l’exécution : chaque appel à Edit ou Write déclenche votre outil de formatage, systématiquement et sans exception. Pour la conformité, la sécurité et les normes d’équipe, le déterminisme l’emporte sur les probabilités.⁴

Événements disponibles

Valeurs source de SessionStart. L’entrée du hook SessionStart comprend un champ source qui indique comment la session a commencé : "startup", "resume", "clear" ou "compact". Depuis la version v2.1.214, une session créée comme fork indique source: "fork" au lieu de "resume" — il s’agit du pendant, côté hook, de la modification apportée en v2.1.212 au passage de /fork en arrière-plan. Si un hook SessionStart crée des branches selon source (par exemple, pour ne réinjecter le contexte qu’avec "resume"), mettez à jour sa liste de correspondances afin d’inclure également "fork".¹⁹⁰

Configuration des hooks

Définissez les hooks dans settings.json ou dans un fichier hooks.json dédié :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$FILE_PATH\""
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/validate-bash.sh"
          }
        ]
      }
    ],
    "UserPromptSubmit": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/inject-context.sh"
          }
        ]
      }
    ]
  }
}

Matchers

Le champ matcher détermine quels outils déclenchent un hook :

{"matcher": "*"}              // Match all tools
{"matcher": "Bash"}           // Match Bash only
{"matcher": "Edit|Write"}     // Match Edit or Write
{"matcher": "mcp__github"}    // Match MCP server tools
{"matcher": ""}               // Match for events without tools (like UserPromptSubmit)

Utilisez | pour faire correspondre plusieurs outils (Edit|Write). Depuis la version v2.1.191, les matchers séparés par des virgules (par exemple Bash,PowerShell) se déclenchent également correctement — les versions antérieures les ignoraient silencieusement, si bien qu’un hook doté d’un matcher avec virgule ne s’exécutait jamais.¹⁷⁸ Depuis la version v2.1.195, les matchers comportant des identifiants avec trait d’union (par exemple code-reviewer, mcp__brave-search) utilisent une correspondance exacte au lieu d’une correspondance accidentelle par sous-chaîne ; un matcher ne se déclenche donc plus pour des outils non prévus qui contiennent simplement la chaîne. Pour faire correspondre tous les outils d’un serveur MCP dont l’identifiant contient un trait d’union, utilisez un motif explicite tel que mcp__brave-search__.*.¹⁷⁹

Depuis la version v2.1.214, les conditions de chemin if: des hooks sont limitées au cwd. La même modification de portée à segment unique qui concerne les règles d’autorisation (consultez Syntaxe des règles d’autorisation) s’applique aux conditions if: des hooks : une condition telle que dir/** ne correspond désormais qu’à <cwd>/dir, et non à tous les dossiers dir/ de l’arborescence. Utilisez **/dir/** pour rétablir une correspondance à n’importe quelle profondeur.¹⁹⁰

Protocole d’entrée/sortie des hooks

Les hooks reçoivent du JSON sur stdin :

{
  "tool_name": "Bash",
  "tool_input": {
    "command": "npm test",
    "description": "Run test suite"
  },
  "session_id": "abc-123"
}

Enrichissement des événements de hook (v2.1.69+) : tous les événements de hook incluent désormais les champs agent_id et agent_type lorsqu’ils sont déclenchés depuis un subagent ou une session --agent, ainsi qu’un champ worktree dans les commandes de hook de la ligne d’état.¹¹⁰

Les hooks Stop/SubagentStop (v2.1.47+) reçoivent un champ last_assistant_message supplémentaire contenant le texte de la réponse finale de Claude, afin que les hooks puissent inspecter la sortie sans analyser les fichiers de transcription :

{
  "session_id": "abc-123",
  "last_assistant_message": "I've completed the refactoring. Here's what changed..."
}

Retour souple sans blocage (v2.1.163+) : les hooks Stop et SubagentStop peuvent renvoyer hookSpecificOutput.additionalContext dans leur sortie JSON afin de transmettre des indications à Claude et de poursuivre le tour, sans que la réponse soit étiquetée comme une erreur de hook. Auparavant, le seul véritable levier d’un hook Stop était le blocage par code de sortie 2 (présenté comme une erreur et comptabilisé dans la limite de blocages consécutifs) ; additionalContext ajoute un canal de pilotage pour les indications du type « voici ce que vous avez oublié, poursuivez », sans perturber la boucle.²⁰³

Les codes de sortie contrôlent le comportement : - 0 : réussite : l’opération se poursuit. La sortie stdout est affichée en mode détaillé (Ctrl+O). Pour UserPromptSubmit et SessionStart, stdout est ajouté au contexte. - 2 : erreur bloquante : l’opération s’arrête. Stderr devient le message d’erreur renvoyé à Claude. - 1, 3, etc. : erreur non bloquante : l’opération se poursuit. Stderr est affiché comme avertissement en mode détaillé.

Pour un contrôle avancé, les hooks peuvent produire du JSON :

{
  "decision": "allow",
  "message": "Command validated and modified",
  "modifications": {
    "tool_input": {
      "command": "npm test -- --coverage"
    }
  }
}

Contrôle des décisions PreToolUse (format recommandé) : les hooks PreToolUse utilisent hookSpecificOutput pour offrir un contrôle plus précis : trois résultats possibles (autoriser/refuser/demander), ainsi que la possibilité de modifier l’entrée de l’outil et d’injecter du contexte :⁸⁹

{
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": "allow",
    "permissionDecisionReason": "Command validated and modified",
    "updatedInput": {
      "command": "npm test -- --coverage --ci"
    },
    "additionalContext": "Note: This database has a 5-second query timeout."
  }
}

Remarque : les champs de premier niveau decision et reason sont obsolètes pour PreToolUse. Utilisez plutôt hookSpecificOutput.permissionDecision et hookSpecificOutput.permissionDecisionReason. Les autres événements (PostToolUse, Stop, etc.) utilisent toujours le champ de premier niveau decision.⁸⁹

Titre de session UserPromptSubmit (v2.1.94+) : les hooks UserPromptSubmit peuvent définir le titre de la session via hookSpecificOutput.sessionTitle.¹⁴⁰

Hooks asynchrones (janvier 2026)

Les hooks peuvent désormais s’exécuter en arrière-plan sans bloquer l’exécution de Claude Code. Ajoutez async: true à la configuration de votre hook :⁸¹

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/notify-slack.sh",
            "async": true
          }
        ]
      }
    ]
  }
}

Quand utiliser des hooks asynchrones : - Notifications (Slack, e-mail, Pushover) qui ne doivent pas ralentir la session - Journalisation et télémétrie pouvant s’exécuter en arrière-plan - Post-traitement non critique (analyse, sauvegardes)

Quand NE PAS utiliser de hooks asynchrones : - Formatage (doit être terminé avant la modification suivante) - Validation (doit bloquer en cas d’échec) - Tout hook devant modifier l’entrée ou la sortie d’un outil

Hooks basés sur des prompts et des agents (v2.1.32+)

Outre les hooks de commande shell (type: "command"), Claude Code prend en charge deux types de hooks reposant sur LLM, qui évaluent les conditions à l’aide d’un raisonnement d’IA plutôt que de scripts.⁸⁹

Les hooks de prompt (type: "prompt") envoient un prompt à tour unique à un modèle Claude rapide. Le modèle renvoie { "ok": true } pour autoriser l’opération ou { "ok": false, "reason": "..." } pour la bloquer :

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "prompt",
            "prompt": "Evaluate if Claude should stop: $ARGUMENTS. Check if all requested tasks are complete and tests pass.",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

Les hooks HTTP (type: "http") envoient l’entrée JSON de l’événement sous forme de requête POST à une URL et reçoivent du JSON en retour. Utilisez-les pour les webhooks, les services de notification externes ou la validation basée sur API (v2.1.63+) :¹⁰⁴

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "http",
            "url": "https://api.example.com/notify",
            "headers": {
              "Authorization": "Bearer $MY_TOKEN"
            },
            "allowedEnvVars": ["MY_TOKEN"]
          }
        ]
      }
    ]
  }
}

Les hooks HTTP utilisent le même format de décision que les hooks de commande (ils renvoient du JSON avec decision et reason). Ils transitent par le proxy réseau de la sandbox lorsque celle-ci est activée. Ils ne sont pas pris en charge pour les événements SessionStart/Setup.

Les hooks d’agent (type: "agent") lancent un subagent ayant accès aux outils (Read, Grep, Glob) pour effectuer une vérification en plusieurs tours. Utilisez-les lorsque la vérification nécessite d’inspecter des fichiers réels ou la sortie des tests :

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "agent",
            "prompt": "Verify all unit tests pass. Run the test suite and check results. $ARGUMENTS",
            "timeout": 120
          }
        ]
      }
    ]
  }
}

Utilisez $ARGUMENTS comme placeholder pour l’entrée JSON du hook. Les deux types prennent en charge les champs model (modèle rapide par défaut) et timeout. Événements pris en charge : PreToolUse, PostToolUse, PostToolUseFailure, PermissionRequest, UserPromptSubmit, Stop, SubagentStop, TaskCompleted. TeammateIdle ne prend pas en charge les hooks de prompt/d’agent.

Hooks d’outil MCP (v2.1.118+)

Les hooks peuvent désormais invoquer directement un outil MCP via type: "mcp_tool", sans devoir envelopper dans un sous-processus Bash l’appel au serveur.¹⁵²

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          {
            "type": "mcp_tool",
            "server": "linear",
            "tool": "create_comment",
            "input": {"issue_id": "ENG-123", "body": "Auto-updated by Claude Code"}
          }
        ]
      }
    ]
  }
}

Cette fonctionnalité s’intègre bien aux serveurs MCP déjà configurés par les utilisateurs : tout outil accessible depuis /mcp peut être appelé par un hook.

duration_ms dans les hooks PostToolUse (v2.1.119+)

Les entrées des hooks PostToolUse et PostToolUseFailure incluent désormais duration_ms, le temps d’exécution de l’outil hors demandes d’autorisation et hooks PreToolUse.¹⁵² Cette valeur est utile pour détecter les outils lents, alimenter les journaux d’audit et mesurer la latence par outil :

# Stderr-flagged warning when an Edit takes more than 10 seconds
DUR=$(jq -r '.duration_ms')
if [ "$DUR" -gt 10000 ]; then
  echo "[slow-edit] ${DUR}ms — investigate $TOOL_INPUT_FILE_PATH" >&2
fi

updatedToolOutput pour tous les outils (v2.1.121+)

Dans la version v2.1.118, les hooks d’outil MCP ont obtenu la possibilité de remplacer la sortie d’un outil via hookSpecificOutput.updatedToolOutput. Depuis la version v2.1.121, ce même champ fonctionne pour n’importe quel hook PostToolUse : outils intégrés (Bash, Read, Edit, Glob, Grep, etc.), outils de subagents et outils MCP. Cas d’usage : masquer le contenu sensible de la sortie de n’importe quel outil, normaliser la structure pour les traitements en aval, injecter des métadonnées avant que l’agent ne lise le résultat.¹⁵⁴

Variables d’environnement des hooks

Les hooks ont accès à des variables d’environnement pour résoudre les chemins :⁸⁹

Conserver les variables d’environnement depuis SessionStart :

#!/bin/bash
if [ -n "$CLAUDE_ENV_FILE" ]; then
  echo 'export NODE_ENV=production' >> "$CLAUDE_ENV_FILE"
fi
exit 0

Sécurité des hooks HTTP (v2.1.51+) : les hooks HTTP qui interpolent des variables d’environnement dans les en-têtes exigent désormais une liste explicite allowedEnvVars. Cela empêche l’exfiltration arbitraire de variables d’environnement par l’intermédiaire des valeurs d’en-tête. Les hooks HTTP transitent également par le proxy réseau de la sandbox lorsque celle-ci est activée, ce qui impose la liste des domaines autorisés. Les hooks HTTP ne sont pas pris en charge pour les événements SessionStart/Setup.⁹⁸

{
  "hooks": {
    "PostToolUse": [{
      "hooks": [{
        "type": "command",
        "command": "curl -H 'Authorization: Bearer $MY_TOKEN' https://api.example.com/notify",
        "allowedEnvVars": ["MY_TOKEN"]
      }]
    }]
  }
}

Confiance accordée à l’espace de travail pour les hooks (v2.1.51+) : les commandes de hook statusLine et fileSuggestion nécessitent désormais l’acceptation de la confiance accordée à l’espace de travail avant de s’exécuter en mode interactif, ce qui élimine un vecteur de sécurité potentiel.⁹⁸

Exemples pratiques de hooks

Formater automatiquement les fichiers TypeScript après leur modification :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c '[[ \"$FILE_PATH\" == *.ts ]] && npx prettier --write \"$FILE_PATH\" || true'"
          }
        ]
      }
    ]
  }
}

Journaliser toutes les commandes bash :

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.command' >> ~/.claude/bash-history.log"
          }
        ]
      }
    ]
  }
}

Bloquer l’accès aux fichiers sensibles :

#!/bin/bash
# .claude/hooks/protect-files.sh
data=$(cat)
path=$(echo "$data" | jq -r '.tool_input.file_path // empty')

if [[ "$path" == *".env"* ]] || [[ "$path" == *"secrets/"* ]] || [[ "$path" == *".pem"* ]]; then
  echo "Blocked: Cannot access sensitive file $path" >&2
  exit 2  # Exit 2 = block the tool call. Exit 1 = non-blocking error (hook failure only).
fi
exit 0