Guide de Claude Code CLI : 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 de permissions, de hooks, d’intégrations MCP et de subagents. Maîtrisez cinq systèmes fondamentaux (configuration, permissions, 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 adoptez systématiquement Opus si la qualité est votre seul critère. Utilisez des hooks (et non des prompts) pour tout ce qui doit toujours s’exécuter. Le mode Auto est le mode de permission par défaut des nouvelles sessions Pro, Max et Team depuis le 14 août 2026 (annoncé le 7 août et vérifié en production à la date de bascule ; autonomie contrôlée par un classificateur — un defaultMode que vous avez défini reste actif, sauf si vous acceptez l’invite de changement unique, Shift+Tab change le mode de n’importe quelle session et disableAutoMode le désactive dans toute l’organisation).²⁰³ Le modèle par défaut dépend de votre offre : Max, Team Premium, Enterprise (par poste depuis la v2.1.251) et le Anthropic API utilisent Claude Opus 5 par défaut, tandis que Pro et Team Standard utilisent Sonnet 5 — contexte natif de 1M, 2 $/10 $ par MTok au tarif standard (le tarif de lancement, désormais permanent : l’augmentation prévue le 1er septembre n’aura pas lieu)²²²²⁰⁷ — le choix de Sonnet 5 partout introduit par la v2.1.197 (30 juin 2026) appartient au passé, et l’alias opus pointe vers Claude Opus 5 (v2.1.219+) ; la v2.1.198 (1er juillet) fait s’exécuter les subagents en arrière-plan par défaut, rend Claude dans Chrome accessible à tous, permet aux agents en arrière-plan d’effectuer un commit, de pousser les changements et d’ouvrir une PR en brouillon 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 appels empilés de slash-skills et relance automatiquement les erreurs 429 temporaires pour les abonnés ; la v2.1.200 (3 juillet) renomme le mode de permission default en « Manual » dans le CLI, --help, VS Code et JetBrains (la valeur de configuration ne change pas, manual étant 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 une commande « Dynamic workflow size » à /config et distingue /review <pr> (passe unique rapide) de /code-review <level> <pr#> — distinction annulée par la v2.1.223 : /review est de nouveau un alias de /code-review, tandis que /code-review sans argument réutilise votre dernier niveau d’effort ; les v2.1.203–205 (7–9 juillet) renforcent le mode Auto — les fichiers de transcription sont protégés contre les altérations, rm -rf demande d’abord confirmation si sa variable ne peut pas être résolue, et les notifications des tâches en arrière-plan précisent qu’aucune intervention humaine n’a eu lieu (les fausses approbations fabriquées dans la transcription ne peuvent donc pas être suivies d’effet) — et transforment /doctor en diagnostic complet avec corrections (alias /checkup).^181182183 La v2.1.217 (21 juillet) a fait marche arrière sur les subagents imbriqués — par défaut, les subagents ont cessé de pouvoir créer leurs propres subagents (décision de nouveau inversée trois jours plus tard par la v2.1.219, avec une profondeur de 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 interrompt désormais réellement les subagents en arrière-plan une fois le plafond atteint.¹⁹⁴ La v2.1.218 (22 juillet) confie /code-review à un subagent en arrière-plan — le travail de revue n’encombre plus votre conversation —, exécute par défaut les skills context: fork en arrière-plan (désactivation possible pour chaque skill avec background: false), ne lance /deep-research qu’en cas d’appel explicite, confie au classificateur du mode Auto les contrôles liés aux commandes rm dangereuses, aux tâches en arrière-plan avec & et aux chemins Windows suspects plutôt qu’aux boîtes de dialogue de permission, et empêche l’exécution des hooks du frontmatter des agents provenant de dossiers non approuvés.¹⁹⁵ 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 (comme Opus 4.8), réflexion activée par défaut, effort réglé par défaut sur high, connaissances arrêtées en mai 2026 — et rectifie deux changements introduits dans des versions antérieures : le mode Fast 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 Fast), 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 taille moyenne recommandée (visez moins de 15 agents), ainsi que le transfert des subagents imbriqués dans stream-json. La v2.1.220 (25 juillet) apporte uniquement des corrections de bugs et des améliorations de fiabilité. Les v2.1.221–226 (4–7 août) ajoutent la messagerie entre sessions (SendMessage/ListAgents entre vos sessions, sous macOS/Linux), des runners autohébergés pour les sessions cloud (Team/Enterprise), la source de plugin archive avec verrouillage SHA-256, le masquage des identifiants JWT/SigV4 dans le sandbox, la vue Focus de VSCode, ainsi qu’un worktree propre pour chaque copie créée avec /fork — et suppriment la limite de 200 subagents par session ainsi qu’ultraplan.^{199200201202196197198} Les v2.1.227–229 (10–12 août) sont principalement consacrées aux corrections, avec quelques améliorations pratiques : les marketplaces de plugins prennent désormais en charge les sources command (un programme local renvoie le dossier du plugin, lequel est de nouveau résolu à chaque session ; mode: "link" l’utilise directement), claude remote-control --continue reprend votre session Remote Control la plus récente, ListAgents marque les pairs Remote Control déconnectés comme offline et vos sessions cloud comme cloud, /commit-push-pr cesse d’approuver automatiquement les options git dangereuses (--force, --amend, --no-verify), et l’outil Write adopte les mêmes règles qu’Edit sur les modèles récents — écraser un fichier non lu ne nécessite plus de l’avoir lu au préalable pendant la session.^229227228 La v2.1.232 (13 août) fait du fork des subagents le comportement par défaut (subagent_type: "fork" hérite de l’intégralité de la conversation et du cache de prompts ; dans les sessions interactives, les créations d’agents qui ne sont pas des coéquipiers s’exécutent en arrière-plan), vous permet de mentionner avec @ une autre session active par son nom dans le prompt (Claude achemine le message via SendMessage, et un nom seul correspondant exactement à une session active est désormais transmis sans confirmation de référence), garantit l’unicité des noms de sessions interactives sur chaque machine (variantes name-word-word), affiche les contrôles de réception intersessions sous forme de lignes dans /config et apporte la parité avec GitLab — neuf familles de jetons GitLab masquées dans le sandbox, protection des identifiants du CLI glab et clonage des URL de marketplace gitlab.com simples (sous-groupes imbriqués compris) comme celles de GitHub.²²⁶ La v2.1.233 (14 août) étend la parité avec GitLab à --worktree (URL de MR affichées sous la forme !N dans claude agents), ajoute des limites de mémoire Linux pour les commandes Bash (CLAUDE_CODE_TOOL_MEMORY_LIMIT) ainsi qu’un réglage du TTL du cache WebFetch, et désactive par défaut les outils de suivi des tâches et des listes de tâches sur Opus 4.8, Sonnet 5, Fable 5 et les modèles plus récents (CLAUDE_CODE_ENABLE_TODO_TOOLS=1 les réactive) — elle annule également une partie des changements de permissions Bash sous Windows introduits par la v2.1.232 après une régression du mode Auto.²²⁵ La v2.1.234 (17 août) permet à Claude Code de reprendre automatiquement votre session après la réinitialisation d’une limite d’utilisation de claude.ai (désactivation dans /config : « Continue automatically at usage limit »), permet d’ouvrir /permissions et /add-dir en cours de tour, ajoute CLAUDE_CODE_PROJECT_DIR_NAME ainsi qu’un point de contrôle de tâche en arrière-plan /goal (CLAUDE_CODE_GOAL_CHECKIN_MINUTES), affiche un badge de MR GitLab (!N) dans le pied de page des dépôts disposant d’un CLI glab authentifié et réduit le coût contextuel du skill intégré claude-api d’environ 200k à 25k tokens en chargeant la documentation de référence à la demande.²²⁴ Les v2.1.235–238 (18–20 août) ajoutent un style de sortie intégré « Concise » (résultats d’abord, sans préambule ni narration — sélectionnez-le sous Output style dans /config), la variable d’environnement ANTHROPIC_DEFAULT_MODEL (elle définit le modèle utilisé au démarrage des nouvelles sessions ; un choix effectué avec /model reste prioritaire et persistant, contrairement à ANTHROPIC_MODEL), un paramètre facultatif spellcheck (il souligne les mots mal orthographiés dans le prompt au moyen de votre installation de aspell, hunspell ou ispell), un paramètre keybindingFlavor ("readline" permet à Ctrl+W de supprimer jusqu’à l’espace précédent, comme dans Bash), headersHelper dans les marketplaces de plugins et dans le fichier .mcp.json du projet (une commande génère des en-têtes HTTP à courte durée de vie ; les assistants associés aux entrées de catalogue ne s’exécutent qu’à l’installation ou à la mise à jour, après affichage de leur commande, tandis que ceux associés au projet, au plugin ou à l’agent s’exécutent sans hériter des variables d’environnement contenant les identifiants, derrière la boîte de dialogue d’approbation du dossier), notify_when_idle pour SendMessage entre sessions (une notification unique lorsque l’autre session locale redevient inactive), ainsi que deux changements de comportement des permissions : le mode Auto écarte désormais les règles d’autorisation Monitor (les commandes Monitor sont soumises au même contrôle du classificateur que Bash), et les règles génériques de refus de lecture du sandbox macOS (**/.env) prévalent dans les zones de lecture autorisées et ne peuvent pas être contournées en renommant le fichier refusé — le classificateur du mode Auto utilisant désormais les valeurs par défaut de Claude API sur Bedrock, Vertex AI et Foundry, ainsi que lorsque la télémétrie est désactivée.²¹⁷ La v2.1.239 (21 août) ajoute /claude-api upgrade (migration des projets Python de anthropic 0.x vers 1.x), intègre la majoration de 1,1× liée à l’inférence exclusivement américaine pour les espaces de travail soumis à la résidence des données dans les estimations de coûts (/cost, ligne d’état, --max-budget-usd), étend la messagerie entre sessions à Windows, affiche les plugins synchronisés depuis claude.ai sous la forme name@synced (gérables avec claude plugin enable/disable, sans jamais remplacer une installation locale du même nom), permet à ListAgents de connaître le nom de sa propre session et les coéquipiers actifs, étend "readline" aux raccourcis par mot de Bash, espace progressivement les points de contrôle /goal (30 min → 1 h → 2 h) et propose le moteur de rendu plein écran sur Bedrock/Vertex/Foundry ; les v2.1.240–241 (22–23 août) sont des versions correctives. Le récapitulatif documentaire de cette même semaine signale deux changements de statut : /design — un skill en aperçu de recherche qui publie via artifacts un canevas composé de plans de travail d’interface modifiables (Pro/Max/Team/Enterprise, nécessite la v2.1.233+) — et la sortie de Remote Control de l’aperçu de recherche, les machines exécutant claude remote-control apparaissant comme des cartes d’appareil dans l’application Claude.²⁰⁵ Depuis les v2.1.174–176 (12 juin 2026), la liste d’autorisation availableModels peut désormais limiter le modèle Default grâce au nouveau paramètre administré enforceAvailableModels (les paramètres utilisateur ou 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 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 complètent cette version.¹⁷² Depuis la v2.1.173 (11 juin 2026), un nom de modèle Fable 5 portant le suffixe [1m] est automatiquement normalisé et ce suffixe est supprimé — Fable 5 inclut déjà un contexte de 1M par défaut, le 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 — 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 dans ~/.aws lorsque AWS_REGION n’est pas défini (/status en indique la source), /plugin ajoute une barre de recherche de marketplace et la métrique OTEL claude_code.lines_of_code.count gagne 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 sa réflexion ne peut pas être désactivée) ; 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 de 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 la réflexion sur les modèles qui l’activent 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 à des centaines d’agents en arrière-plan via /workflows, le mode Fast sur Opus 4.8 coûte 2× le tarif standard pour une vitesse 2,5× supérieure, le prompt système allégé est désormais utilisé par défaut pour tous les modèles, à l’exception de Haiku/Sonnet/Opus 4.7 et antérieurs, /simplify est redevenu une revue consacrée uniquement 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 de la sélection effectuée avec /model le modèle par défaut (appuyez sur s pour la session uniquement) et ajouté COLUMNS/LINES à l’environnement de la ligne d’état. La v2.1.152 a introduit /code-review --fix (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 administré 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 238 171}

Claude Code fonctionne comme un système agentique, et non comme une interface de discussion 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 intégrée aux véritables méthodes de travail des développeurs. En février 2026, 4 % des commits publics sur GitHub (environ 135 000 par jour) étaient créés par Claude Code — une croissance de 42 896× en 13 mois depuis l’aperçu de recherche — et 90 % du propre code de Anthropic était écrit par l’IA.¹⁰³

La différence entre un usage occasionnel et un usage 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 de permissions : encadre 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 en plusieurs étapes

Points clés

• Cinq systèmes déterminent votre efficacité : la hiérarchie de configuration, les permissions, les hooks, MCP et les subagents contrôlent tout, du comportement à l’automatisation.
• Confiez les tâches à la couche de délégation : les subagents évitent de surcharger 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 systématiquement, 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 coûteux et réservez Opus aux véritables raisonnements architecturaux — ou adoptez systématiquement Opus si la qualité est votre seul critère.
• MCP connecte Claude à votre chaîne d’outils : 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 d’entreprise. Ce guide condense cette expérience dans la référence complète que j’aurais aimé trouver à mes débuts. Chaque fonctionnalité est accompagnée de sa syntaxe réelle, d’exemples de configuration concrets et des 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 : vous n’avez pas besoin de la lire intégralement. Commencez par la partie qui correspond à votre niveau d’expérience :

Utilisez Ctrl+F / Cmd+F dans votre navigateur pour rechercher des options, des commandes ou des clés de configuration précises. La fiche de référence rapide, située à la fin, offre un récapitulatif facile à parcourir de toutes les commandes principales.

Analyses approfondies connexes

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

Démarrage rapide en 60 secondes

Si vous souhaitez simplement lancer Claude Code et voir le résultat, 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. La suite détaille les options d’installation, la configuration des autorisations et des hooks, la connexion des serveurs MCP et le déploiement en entreprise — mais rien de tout cela n’est nécessaire pour commencer.

Prérequis : Node 22+ uniquement pour l’ancienne méthode via npm (version minimale relevée de 18 à partir de la v2.1.198 ; la documentation d’installation actuelle indique « Node.js 22 ou version ultérieure », vérifié le 7 août 2026) ; le programme d’installation 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 avec facturation à l’usage, couvre l’utilisation. Consultez Comment installer Claude Code ? pour connaître les spécificités de chaque plateforme, les procédures de dépannage et la méthode utilisant le binaire natif (adoptée par défaut depuis la v2.1.113). Les informations relatives à la dernière version présentées dans ce guide sont actualisées à chaque publication ; consultez la ligne la plus récente du journal des modifications pour connaître la date de la dernière vérification.²³⁸

Fonctionnement de Claude Code : le modèle mental

Avant d’examiner les fonctionnalités, vous devez comprendre comment l’architecture de Claude Code façonne toutes vos interactions avec l’outil. Le système repose sur trois couches :

┌─────────────────────────────────────────────────────────┐
│                    CLAUDE CODE LAYERS                    │
├─────────────────────────────────────────────────────────┤
│  EXTENSION LAYER                                         │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐    │
│  │   MCP   │  │  Hooks  │  │ Skills  │  │ Plugins │    │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘    │
│  External tools, deterministic automation, domain       │
│  expertise, packaged extensions                          │
├─────────────────────────────────────────────────────────┤
│  DELEGATION LAYER                                        │
│  ┌─────────────────────────────────────────────────┐    │
│  │           Subagents (20 concurrent default)      │    │
│  │   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 principale : votre conversation principale. Chaque message, lecture de fichier et résultat d’outil consomme une partie du contexte d’une fenêtre partagée (200 000 tokens en standard⁹¹, 1 million de tokens avec Opus 4.6 ou les modèles à contexte étendu). Lorsque cette fenêtre est pleine, Claude perd le fil des décisions antérieures et la qualité se dégrade. Cette couche est facturée au token.

Couche de délégation : les subagents démarrent avec un contexte vierge, accomplissent une tâche ciblée et renvoient une synthèse. Les résultats de leurs recherches n’alourdissent pas votre conversation principale ; seules leurs conclusions y sont intégrées. Confiez les recherches à des subagents utilisant des modèles moins coûteux, ou conservez votre modèle principal pour toutes les tâches si la qualité prime sur 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 formalisent une expertise métier que Claude applique automatiquement. Les plugins regroupent tous ces éléments afin de les distribuer.

L’idée essentielle : la plupart des utilisateurs travaillent exclusivement dans la couche principale, tandis que le contexte s’alourdit et que les coûts augmentent. Les utilisateurs expérimentés confient les recherches et les tâches spécialisées à la couche de délégation, configurent la couche d’extension selon leur flux de travail et réservent la couche principale à l’orchestration et aux décisions finales.

Table des matières

1. Comment installer Claude Code ?
2. Démarrage rapide : votre première session
3. Principaux modes d’interaction
4. Analyse 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 d’autorisations ?
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 de réflexion étendue ?
13. Styles de sortie
14. Slash commands
15. Comment fonctionnent les skills ?
16. Système de plugins
17. Comment fonctionne la mémoire ?
18. Images et entrées multimodales
19. Mode vocal
20. Comment fonctionne l’intégration à Git ?
21. Comment utiliser Claude Code dans mon IDE ?
22. Modes 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. Claude dans Microsoft 365 (mai 2026)
28. Optimisation des performances
29. Comment résoudre les problèmes ?
30. Déploiement en entreprise
31. Référence des raccourcis clavier
32. Bonnes pratiques
33. Recettes de flux de travail
34. Guide de migration
35. Conseils adaptés à chaque public
36. Fiche de référence rapide
37. Journal des modifications
38. Références

Comment installer Claude Code ?

Configuration requise

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

Sous Windows, WSL 1 et WSL 2 fonctionnent tous deux. Git Bash fonctionne également si vous préférez utiliser Windows en 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

Tableau de référence rapide — toutes les méthodes, toutes les commandes et la vérification de la version sur un seul écran. Les sous-sections ci-dessous détaillent chaque méthode et la résolution des problèmes.

Depuis la v2.1.113, le CLI canonique lance un binaire Claude Code natif au moyen d’une dépendance facultative propre à chaque plateforme, au lieu de la version groupée de JavaScript — utilisez le programme d’installation natif pour bénéficier de la distribution testée. L’installation via npm fonctionne toujours, mais affiche l’avis d’obsolescence introduit initialement dans la v2.1.15.

Méthodes d’installation

Installation native (recommandée)

Le binaire natif offre l’expérience la plus fluide, 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 installer une version précise :

# 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 avec NPM (obsolète)

Remarque : depuis la v2.1.15, les installations avec npm affichent un avis d’obsolescence. Le binaire natif constitue désormais la méthode d’installation recommandée. Effectuez la migration avec claude install.

Pour les environnements anciens dans lesquels npm reste nécessaire :

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

N’utilisez jamais sudo pour une installation avec npm. Cela crée des problèmes d’autorisations qui compliquent toutes les étapes ultérieures.

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 propose trois modes d’authentification, chacun présentant des avantages et des inconvénients différents :

Console Claude (facturation API)

Connectez-vous directement au service API de Anthropic via platform.claude.com (anciennement console.anthropic.com). Créez un compte, configurez la facturation et authentifiez-vous via le CLI. La Console propose une facturation à l’usage avec un accès complet à API. Un espace de travail « Claude Code » dédié est créé automatiquement ; vous ne pouvez pas créer de clés API pour cet espace de travail, mais vous pouvez surveiller son utilisation. Depuis la v2.1.243, /login → Console Anthropic propose une méthode sans clé, « Se connecter avec votre compte Console » (recommandée), en plus de la création d’une clé API. Ainsi, les organisations qui n’autorisent pas les clés API peuvent tout de même se connecter avec leurs identifiants Console.²²¹

Abonnement Claude Pro ou Max

Utilisez les identifiants de votre compte claude.ai. L’abonnement couvre à la fois l’interface web et l’utilisation de CLI dans le cadre d’une formule mensuelle unique. Il simplifie la facturation pour les utilisateurs individuels qui souhaitent maîtriser leurs coûts.

Plateformes d’entreprise

AWS Bedrock, Google Vertex AI et Microsoft Foundry proposent chacun un accès adapté aux entreprises, intégré aux relations de facturation cloud existantes. Assistant de configuration de Bedrock (v2.1.92+) : un assistant interactif accessible depuis l’écran de connexion vous guide dans l’authentification AWS, la sélection de la région, la vérification des identifiants et l’épinglage du modèle.¹³⁷ Assistant de configuration de Vertex AI (v2.1.98+) : un assistant équivalent pour Google Cloud vous accompagne dans l’authentification GCP, la configuration du projet et de la région, la vérification des identifiants et l’épinglage du modèle.¹⁴² Fédération d’identité des charges de travail mTLS de Vertex AI (v2.1.121+) : Vertex AI accepte désormais la Fédération d’identité des charges de travail fondée sur des certificats X.509 (identifiants par défaut d’application mTLS), avec des jetons GCP de courte durée générés à partir d’un certificat client, sans nécessiter de JSON de compte de service.¹⁵⁴ Approbation des certificats d’autorité de certification du système d’exploitation (v2.1.101+) : les proxys TLS d’entreprise fonctionnent désormais par défaut, car Claude Code approuve le magasin de certificats du système d’exploitation. Définissez CLAUDE_CODE_CERT_STORE=bundled pour utiliser uniquement les autorités de certification fournies.¹⁴³

# 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 d’entreprise derrière des proxys ou passant par 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 du système et tous les problèmes détectés.

Gestion de l’authentification (v2.1.41+)

Gérez l’authentification sans accéder au 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

Procédure courante pour passer d’un compte ou d’une organisation à l’autre :

claude auth logout && claude auth login

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

Mises à jour

Claude Code se met à jour automatiquement par défaut, en recherchant les mises à jour au démarrage puis régulièrement au cours des sessions. Elles sont téléchargées en arrière-plan et appliquées au lancement suivant.

Pour 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

Nettoyage de la configuration (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 tour à l’autre. Saisissez directement vos requêtes, recevez les réponses, puis poursuivez jusqu’à quitter avec /exit ou Ctrl+D.

Commencez par une invite initiale pour cibler la session :

claude "explain the authentication flow in this project"

Conseil d’expert : le REPL conserve son état au fil des opérations de compactage. Lorsque le contexte devient trop volumineux, Claude résume automatiquement les échanges antérieurs 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 sur les éléments à conserver.

Mode non interactif

Le mode d’impression (-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 diffusée en continu :

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é. L’option --forward-subagent-text (ou CLAUDE_CODE_FORWARD_SUBAGENT_TEXT=1) transmet également le texte et les raisonnements des subagents dans le flux, afin que les harnais d’évaluation et les pipelines de journaux puissent observer le travail délégué à mesure de son exécution, au lieu de n’en voir que le rapport final.¹⁸⁸

Les subagents imbriqués sont désormais également transmis (v2.1.219). À l’origine, seuls les subagents de profondeur 1 apparaissaient. Ceux créés à une profondeur de 2 ou plus figurent désormais eux aussi 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, de la création imbriquée jusqu’à une profondeur de 3 par défaut : sans elle, 2 des 3 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-5

# 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

# Restricted mode for eval harnesses and shared machines (v2.1.248+)
claude --restricted -p "query" --tools "Read,Grep,Glob"

# Unattended hosts: deny anything that would prompt (v2.1.259+)
claude -p "run the nightly checks" --permission-prompts none

Mode restreint (v2.1.248+) : --restricted (ou CLAUDE_CODE_RESTRICTED=1) est conçu pour les harnais d’évaluation qui pilotent claude sur une machine partagée. Il supprime les outils intégrés qui exécutent des commandes ou du code, ainsi que WebFetch, sauf si vous les nommez individuellement dans --tools — le préréglage default ne compte pas —, limite les outils de fichiers intégrés aux répertoires de travail, ne charge que les paramètres gérés et --settings (les fichiers de paramètres utilisateur, de projet et locaux sont ignorés), refuse bypassPermissions et interdit la création de sessions cloud.²⁰⁶²⁰⁹

--permission-prompts none (v2.1.259) : le complément destiné aux hôtes sans surveillance. Toute action qui déclencherait une demande d’autorisation est automatiquement refusée, tandis que le mode d’autorisation actif — mode automatique compris — continue de prendre toutes les décisions qu’il peut prendre sans vous. Ne le confondez pas avec --permission-prompt-tool, qui délègue les demandes à un outil MCP au lieu de les refuser. La documentation de référence CLI ne répertorie pas encore cette nouvelle option ; le CHANGELOG fait foi.²¹¹

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 de la conversation afin de pouvoir la reprendre. 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"

Déplacement d’une session en cours avec /cd (v2.1.169+ ; configuration immédiate depuis la v2.1.246) : /cd path change le répertoire de travail sans interrompre le cache d’invite. Depuis la v2.1.246, les paramètres de projet, hooks, serveurs .mcp.json (après la demande d’autorisation habituelle), skills et agents du nouveau répertoire prennent effet immédiatement après le déplacement, sans attendre --resume.²³³²²⁰

Sessions liées à une 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 liées automatiquement aux PR lorsque vous les créez avec gh pr create au cours d’une session. Il devient ainsi facile de reprendre ultérieurement 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, depuis les PR, des liens vers 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 a créé cette PR. Cela fonctionne avec github.com, GitHub Enterprise, gitlab.com (y compris les instances GitLab auto-hébergées) et bitbucket.org.¹⁵⁴

Sessions nommées : nommez les sessions au démarrage ou pendant leur exécution :

# 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 à une session un nom lisible, utilisez plutôt /rename et --resume.

/fork crée une session en arrière-plan ; /subtask est le 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 obtient sa propre ligne dans claude agents, ce qui vous permet d’envoyer la copie explorer une autre approche pendant que votre session principale se poursuit. L’ancien comportement — créer un fork dans la session en cours — subsiste sous le nouveau nom /subtask.¹⁸⁹ Depuis la v2.1.214, une session démarrée comme fork indique "fork" comme source du hook SessionStart (auparavant "resume"), ce qui permet aux hooks qui filtrent selon la source de les distinguer.¹⁹⁰ La v2.1.216 réduit la confirmation de /fork à une seule ligne affichant le nom de la nouvelle session et son identifiant claude attach.¹⁹² Depuis la v2.1.221, une session issue d’un fork crée son propre worktree au lieu de travailler dans le checkout de la session d’origine. Le fork qui explore une autre approche ne peut donc plus entrer en conflit avec les fichiers non commités de la session principale, ce qui constituait le principal risque lorsque vous envoyiez une copie expérimenter de son côté.¹⁹⁹ Avec la v2.1.232, le fork devient également le comportement par défaut des subagents : un subagent subagent_type: "fork" hérite de l’intégralité de la conversation et du cache d’invite, tandis que les créations d’agents hors coéquipiers dans les sessions interactives s’exécutent désormais en arrière-plan par défaut.²²⁶

Claude Code stocke les sessions sous forme de transcriptions JSONL. L’exécution des agents attribue des valeurs agentId uniques, avec des transcriptions enregistrées sous la forme agent-{agentId}.jsonl. La reprise préserve 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 bash et aucune action destructive. Claude conçoit une approche d’implémentation, l’enregistre dans un fichier de plan, puis attend votre approbation avant toute exécution.

Activation du 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 passe en 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. Enregistre 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 l’approuvez, 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 de zéro avec tout l’espace contextuel disponible pour le plan - « Oui, et approuver manuellement les modifications » — conserve le contexte et vous permet d’approuver chaque changement - « Oui, accepter automatiquement les modifications » — conserve le contexte et laisse Claude procéder sans approbation pour chaque modification

L’effacement automatique du contexte lors de l’approbation constitue le processus recommandé. Le plan bénéficie ainsi d’une nouvelle fenêtre de contexte, ce qui améliore considérablement son respect : Claude reste concentré plus longtemps, sans interférence des échanges précédents.

Quand utiliser le mode plan : - Implémentation de nouvelles fonctionnalités impliquant des décisions architecturales - Refactorisations portant sur plusieurs fichiers lorsque vous souhaitez d’abord examiner l’approche - Bases de code inconnues qu’il convient d’explorer avant toute modification - Toute tâche offrant plusieurs approches valables et pour laquelle vous souhaitez intervenir dans le choix

Conseil d’expert : plus vous consacrez de temps au mode plan, plus Claude a de chances de réussir l’implémentation. Ce mode offre 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 façons :¹⁸⁶

# 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 modèles d’interaction — sur une nouvelle page consacrée à l’accessibilité dans la documentation officielle.¹⁸⁶

Analyse approfondie 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 remplacent les niveaux inférieurs et les paramètres d’entreprise ne peuvent en aucun cas être contournés.

Hiérarchie de configuration

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

Depuis la v2.1.181, /config key=value permet de définir n’importe quel paramètre directement depuis le prompt — par exemple, /config thinking=false — sans ouvrir l’interface interactive de /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 de /config : les touches Entrée et Espace basculent désormais toutes deux le paramètre sélectionné, tandis qu’Échap enregistre et ferme l’interface (auparavant, cette touche annulait les modifications).¹⁷⁴

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

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

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "model": "claude-sonnet-5",
  "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": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
          }
        ]
      }
    ]
  },
  "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": {
    "label": "Team tips",
    "tips": [
      "Custom tip 1",
      {"id": "tip-2", "text": "Custom tip 2", "cooldownSessions": 5, "priority": 1}
    ],
    "tipsFile": "~/.claude/team-tips.json",
    "excludeDefault": true
  },
  "skillOverrides": {
    "legacy-skill": "off",
    "manual-only-skill": "user-invocable-only",
    "compact-skill": "name-only"
  },
  "includeGitInstructions": false,
  "modelOverrides": {
    "bedrock": "us.anthropic.claude-opus-5",
    "vertex": "claude-opus-5",
    "foundry": "claude-opus-4-8"
  },
  "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 disponibilité à 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 qu’elle reste appelable par son nom tout en étant retirée de la sélection du modèle, et name-only pour que seul son nom demeure visible, 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, cette liste restreint également le modèle Par défaut : si celui-ci correspond à 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) comble la faille qui permettait à un alias de rediriger vers un modèle bloqué par l’intermédiaire 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 les restrictions de modèles dans le sélecteur /model, avec --model, /model et ANTHROPIC_MODEL : la sélection d’un modèle restreint affiche un message indiquant qu’il est « restreint par les paramètres de votre organisation ».¹⁷⁶
• language (amélioration 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 particulière 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) : activez le mode lecteur d’écran de manière persistante (consultez Mode lecteur d’écran).¹⁸⁶
• processWrapper (v2.1.208) : faites transiter chaque processus que Claude Code lance pour son propre fonctionnement par un exécutable d’encapsulation — 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. Cela 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 forme partielle comme :hea pour afficher des suggestions. Activée par défaut ; définissez ce paramètre sur false pour la désactiver.¹⁹⁴

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

• sandbox.network.strictAllowlist (v2.1.219) : refusez 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éfinissez la recommandation indicative de taille des workflows Dynamic depuis n’importe quel fichier de paramètres — utilisateur, projet ou géré — plutôt qu’uniquement avec /config. Par défaut, les workflows Dynamic suivent une recommandation de taille moyenne (« visez moins de 15 agents ») ; la ligne correspondante de /config se masque lorsqu’un fichier de paramètres fournit la valeur. Il s’agit d’une recommandation, pas d’une limite imposée. Consultez Subagents.¹⁹⁶

Paramètres plus récents (v2.1.242–243) :

• modelPicker (utilisateur ou géré, v2.1.242+) : personnalisez le sélecteur /model avec une liste ordonnée et libellée de modèles. Il s’agit d’un objet doté d’un tableau options (chaque ligne comprend obligatoirement un model, ainsi qu’un label et une description facultatifs ; model est repris tel quel, si bien que les alias, les identifiants Anthropic et les identifiants Bedrock/Vertex/Foundry/gateway fonctionnent tous) et d’un booléen facultatif replaceBuiltInOptions (false, la valeur par défaut, ajoute les lignes après la liste intégrée ; true affiche uniquement vos lignes, Par défaut et le modèle déjà utilisé par la session). Claude Code lit cette clé dans les paramètres gérés, --settings et les paramètres utilisateur, mais l’ignore dans les paramètres de projet et locaux, afin qu’un dépôt cloné ne puisse pas modifier les libellés du sélecteur ; la source de priorité la plus élevée qui définit la clé fournit l’intégralité de la liste. Une liste d’autorisation availableModels continue de s’appliquer à chaque ligne, et un libellé modifie ce qu’affiche le sélecteur, pas le modèle exécuté.²²¹²¹⁹
• promptCacheTtl / subagentPromptCacheTtl (n’importe quel fichier, v2.1.242+) : "5m" ou "1h" par catégorie de requêtes, afin que les utilisateurs de clés API et de fournisseurs cloud puissent conserver un cache d’une heure pour la conversation principale, tandis que les subagents restent à cinq minutes. Consultez Stratégies de mise en cache.²²¹²¹⁹
• modelPricing (géré, v2.1.243+) : tarifs contractuels par modèle et coefficient de remise d’une organisation, utilisés par /cost, la ligne d’état et les données de coût de télémétrie à la place du prix catalogue. Consultez Consulter les coûts.²²¹

Paramètres plus récents (v2.1.247) : - feedbackDrafts (v2.1.247) : contrôle le nouvel outil SendFeedback – lorsqu’un problème survient pendant une session, Claude peut rédiger un rapport de retour que vous pourrez examiner et envoyer depuis /feedback ; désactivez cette rédaction avec ce paramètre. Consultez la ligne /feedback dans Commandes slash.²¹⁶ - Extension de la structure de spinnerTipsOverride (v2.1.247) : les astuces peuvent désormais être des objets {id, text, cooldownSessions, priority} en plus de simples chaînes, et l’objet accepte les clés tipsFile et label, ce qui permet aux organisations d’alterner leurs propres astuces avec celles intégrées (l’exemple ci-dessus illustre la structure étendue). La documentation des paramètres ne mentionne pas encore les nouvelles clés – le CHANGELOG est la seule source à les référencer.²¹⁶

Nouveaux paramètres (v2.1.248–251) :

• desktopSessionCleanupPeriodDays (v2.1.248) : limite la durée pendant laquelle les sessions enregistrées par l’application de bureau restent exemptées du nettoyage des transcriptions. Le correctif associé compte davantage que le paramètre lui-même : les sessions Claude Desktop et Cowork disparaissaient auparavant après cleanupPeriodDays (30 jours par défaut) ; le nettoyage les conserve désormais tant qu’elles se trouvent dans l’application, sauf si une politique de l’organisation gère leur conservation.²⁰⁶
• Restrictions de env au niveau du projet (v2.1.251) : un bloc env dans le fichier .claude/settings.json d’un projet ne peut plus définir CLAUDE_CONFIG_DIR, CLAUDE_CODE_TMPDIR ni TMPDIR/TMP/TEMP – définissez-les plutôt dans votre shell ou dans les paramètres utilisateur ou gérés, afin qu’un dépôt cloné ne puisse pas rediriger les fichiers de configuration et temporaires écrits par Claude Code.²⁰⁶

Nouveaux paramètres (v2.1.257-259) :

• timeFormat / timeZone (v2.1.257) : contrôlent la façon dont Claude Code affiche les heures – l’heure d’achèvement en fin de tour et les horodatages des transcriptions. timeFormat accepte un format sur 12 heures, sur 24 heures, sur 24 heures en UTC ou un motif strftime explicite ; timeZone indique le fuseau horaire. La documentation des paramètres ne les mentionne pas encore – le CHANGELOG fait foi.²¹¹
• permissions.blockReadsOutsideWorkingDirectories (v2.1.257) : refuse catégoriquement la lecture de fichiers situés en dehors des répertoires de travail de la session. Sans ce paramètre, le mode automatique demande désormais une seule confirmation avant la première lecture de ce type pendant la session (consultez Mode automatique).²¹¹
• managedMcpServers / managedSourcesBehavior : clés réservées à la portée gérée, présentées dans Déploiement en entreprise – elles concernent les organisations qui fournissent des serveurs MCP à chaque utilisateur (v2.1.259), ainsi que la fusion facultative entre les sources gérées (affinée dans la v2.1.257).²¹¹²¹⁵

Recherche de paramètres : les options les plus recherchées

Si vous êtes arrivé ici à la recherche d’un paramètre précis, voici l’index abrégé. Chaque entrée indique la version dans laquelle il est apparu et, lorsqu’il dépend d’une portée, laquelle :

ANTHROPIC_API_KEY=sk-ant-...                    # Direct API authentication
ANTHROPIC_AUTH_TOKEN=token                      # Custom authorization header
ANTHROPIC_CUSTOM_HEADERS="X-Key: val"           # Additional request headers; credential/org/routing/API-behavior headers set from managed or project settings require approval (v2.1.251)[^238]

Configuration du modèle :

ANTHROPIC_MODEL=claude-opus-4-7                 # Override default model (Apr 16, 2026)
ANTHROPIC_DEFAULT_MODEL=claude-opus-5           # Model new sessions START on; a /model pick overrides + persists (v2.1.236)
ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-5      # What the `opus` alias resolves to (Opus 5 since v2.1.219)
ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-4-6
ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-4-5-20251001
CLAUDE_CODE_SUBAGENT_MODEL=sonnet               # Default model for subagents; an agent's model: field and per-spawn picks win (v2.1.251 demoted it from override to default)[^238]
CLAUDE_CODE_SUBAGENT_MODEL_FORCE=1              # Force every subagent onto CLAUDE_CODE_SUBAGENT_MODEL (or the main model), ignoring agent-definition and per-spawn overrides -- the pre-v2.1.251 behavior, opt-in (v2.1.257)[^243]
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
CLAUDE_CODE_RESTRICTED=1                        # Restricted mode: no command/code tools or WebFetch unless named in --tools; only managed settings load (v2.1.248+)[^238]
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+)
CLAUDE_CODE_PROMPT_CACHE_TTL=1h                 # Main-conversation cache TTL, 5m or 1h; beats the promptCacheTtl setting (v2.1.242+)[^234]
CLAUDE_CODE_SUBAGENT_PROMPT_CACHE_TTL=5m        # TTL for subagents, workflows, forks, compaction, titles; beats subagentPromptCacheTtl (v2.1.242+)[^234]
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_WEBFETCH_CACHE_TTL_MS=900000        # WebFetch per-URL session cache TTL (default 15 min; v2.1.233+)[^226]
CLAUDE_CODE_PROJECT_DIR_NAME=myproj             # Short name for the per-project transcript directory, for hosts that give each session its own config dir (v2.1.234+)[^227]
CLAUDE_CODE_GOAL_CHECKIN_MINUTES=30             # How long background tasks may keep a /goal waiting before Claude checks in on them; 0 disables (v2.1.234+)[^227]
CLAUDE_CODE_MAX_SUBAGENTS_PER_SESSION=200       # Per-session subagent-spawn cap (default 200 in v2.1.212–223; the default cap was REMOVED in v2.1.224 — set this to reimpose one)[^206][^218]
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_WORKFLOW_PREFIX_STAGGER_MS=0        # Disable the v2.1.229 workflow fan-out stagger (same-prefix sibling agents launch staggered so they read the cached prompt prefix instead of re-paying it)[^224]
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]
CLAUDE_CODE_TOOL_MEMORY_LIMIT=4096              # Opt-in Linux memory cgroup (MB) for Bash tool commands — a runaway build can't stall the session (v2.1.233+)[^226]
CLAUDE_CODE_ENABLE_TODO_TOOLS=1                 # Restore TodoWrite/TaskCreate-family tools on Opus 4.8+/Sonnet 5+/Fable 5+, where they are off by default since v2.1.233[^226]
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; not settable from project-settings env (v2.1.251)[^238]
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; not settable from project-settings env, nor are TMPDIR/TMP/TEMP (v2.1.251)[^50][^238]
CLAUDE_CODE_DISABLE_1M_CONTEXT=1               # Hold ALL native-1M models to 200K via auto-compaction (v2.1.223 widened scope)[^103][^217]
CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT=1  # Let unrecognized model IDs exceed the assumed context window (v2.1.223)[^217]
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 d’étendue de requête LLM dans v2.1.121+ : stop_reason, gen_ai.response.finish_reasons et user_system_prompt sont désormais émis dans les étendues 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 dans v2.1.122+ : les attributs numériques des événements de journalisation api_request et api_error sont désormais émis sous forme de nombres (auparavant sous forme de chaînes), ce qui corrige les collecteurs OTel en aval appliquant un typage strict au schéma. Le nouvel événement de journalisation claude_code.at_mention se déclenche lorsque Claude Code résout une mention @.¹⁵⁴

Événement de journalisation claude_code.assistant_response dans v2.1.193+ : Claude Code peut émettre le texte intégral de la réponse du modèle sous forme d’événement de journalisation OTel, sous le contrôle de OTEL_LOG_ASSISTANT_RESPONSES. Ce mécanisme comporte 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 le contenu 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 dans v2.1.214 : les événements de journalisation OTel comportent désormais les attributs message.uuid, client_request_id et tool_source pour la corrélation au niveau des messages et la traçabilité de l’origine des outils ; la charge utile subagentStatusLine inclut l’effort de raisonnement du subagent, ce qui permet aux lignes d’état personnalisées d’afficher ensemble le modèle et l’effort ; enfin, la nouvelle variable d’environnement CLAUDE_CODE_OTEL_CONTENT_MAX_LENGTH permet de configurer la limite de troncature de 60 Ko applicable 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 de 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 majeure sur le coût comme sur la qualité. Claude Code permet de changer facilement de modèle à plusieurs niveaux.

Modèles disponibles

Deux changements incompatibles lorsque vous faites migrer un harness d’Opus 4.8 vers Opus 5 :¹⁹⁷

1. La réflexion est activée par défaut. Avec Opus 4.8, une requête dépourvue de champ thinking s’exécutait sans réflexion ; avec Opus 5, la même requête utilise la réflexion adaptative. max_tokens demeure une limite stricte pour l’ensemble de la sortie — réflexion et texte de la réponse — : vérifiez donc de nouveau la marge disponible pour toute charge de travail qui s’exécutait auparavant sans réflexion. Transmettez thinking: {type: "disabled"} pour rétablir l’ancien comportement, sous réserve du point suivant.
2. Lorsque la réflexion est désactivée, l’effort est limité à high. Associer thinking: {type: "disabled"} à un effort xhigh ou max renvoie une erreur 400. La vérification s’effectue pour chaque requête — passer l’effort à xhigh alors que la réflexion est désactivée 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 utilise high par défaut (comme avec l’API Claude) et toute l’échelle est disponible — low, medium, high, xhigh, max. Les recommandations de migration de Anthropic préconisent de tester l’effort max lorsque les capacités priment sur la consommation de tokens. Le mode rapide couvre Opus 5 au tarif de 10 $/50 $ par MTok (voir Mode rapide).¹⁹⁷¹⁹⁸

Claude Fable 5.1 (1er septembre 2026) : le nouveau sommet du niveau Fable et, depuis la v2.1.257, le modèle vers lequel pointe l’alias fable (sauf si ANTHROPIC_DEFAULT_FABLE_MODEL en épingle un autre) ; best signifie désormais « le dernier modèle Fable auquel vous avez accès ». La version minimale nécessite une explication : la documentation de configuration des modèles indique que l’alias a changé dans la v2.1.255 et la page du modèle précise que Fable 5.1 « nécessite Claude Code v2.1.255 ou version ultérieure », mais les versions 2.1.253 à 2.1.256 n’ont jamais été publiées sur npm – la v2.1.257 (1er septembre) est la première version installable qui l’intègre. ID du modèle : claude-fable-5-1 (Bedrock : anthropic.claude-fable-5-1). Même niveau et même tarif par token que Fable 5 – 10 $/MTok en entrée, 50 $/MTok en sortie, contexte de 1 M, sortie maximale de 128 K, réflexion adaptative toujours active, avec effort réglé par défaut sur high – mais avec un changement tarifaire important pour les longues sessions agentiques : les lectures du cache coûtent 0,25 $/MTok, soit 0,025 fois le prix d’entrée (2,5 %), contre 10 % habituellement ; seuls Fable 5.1 et Mythos 5.1 bénéficient de ce tarif, tandis que les écritures dans le cache conservent le tarif standard (12,50 $ pour 5 minutes, 20 $ pour 1 heure). Limite fiable des connaissances : juin 2026 (les données d’entraînement s’arrêtent également à juin 2026) – la plus récente de tous les modèles Claude actuels. Retrait au plus tôt le 1er septembre 2027. Trois changements incompatibles par rapport à Fable 5 : l’utilisation forcée d’outils renvoie une erreur, les modèles antérieurs ne peuvent pas lire ses blocs de réflexion et la modification de tours antérieurs invalide les blocs de réflexion. Cinq ajouts : effort par message (bêta), messages système limités au tour (bêta), mises à jour de progression entre les appels d’outils (display: "updates", bêta), lectures du cache moins coûteuses et provenance du contenu. Claude Mythos 5.1 est le même modèle, avec les mêmes caractéristiques, accessible uniquement sur invitation via Project Glasswing. Avec ce lancement, Fable 5 rejoint le tableau des modèles Legacy de la documentation, aux côtés d’Opus 4.8/4.7/4.6/4.5 et de Sonnet 4.6/4.5. Les notes de version signalent une réserve concernant la passerelle : dans les sessions de passerelle des applications Claude, fable et best continuent pour l’instant de pointer vers Fable 5 – une passerelle qui n’est pas encore configurée pour la version 5.1 la refuse – ; sélectionnez donc explicitement Fable 5.1 dans /model dans ce contexte. Les modèles par défaut des offres restent inchangés : Opus 5 avec les offres premium, Sonnet 5 avec Pro et Team Standard.^211212213

Claude Fable 5 (9 juin 2026 ; modèle Legacy depuis le 1er septembre 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 préserver sa cohérence sur des millions de tokens de contexte. Fable 5 est le modèle de pointe de classe « Mythos » sécurisé pour une utilisation générale : il intègre des classificateurs de sécurité qui basculent vers Opus 4.8 pour les requêtes portant sur 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 qui, depuis la v2.1.257, pointe vers Fable 5.1 – pour sélectionner Fable 5 aujourd’hui, utilisez /model claude-fable-5) — et son déploiement dans les offres par abonnement s’est poursuivi jusqu’au 22 juin 2026 (désormais terminé). ID du 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, dont le contexte de 1 M nécessite [1m]) ; sortie maximale de 128 K. Le tarif est de 10 $/MTok en entrée et de 50 $/MTok en sortie — environ deux fois celui d’Opus 4.8 — : réservez-le donc aux raisonnements réellement difficiles, et non aux modifications courantes. Il reprend l’interface de requête d’Opus 4.8 (réflexion adaptative uniquement ; suppression de temperature/top_p/top_k et de budget_tokens), avec une particularité supplémentaire : une valeur explicite thinking: {type: "disabled"} renvoie une erreur 400 ; pour l’exécuter sans réflexion, omettez entièrement le paramètre thinking.²³²

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. La réflexion ne peut pas être désactivée avec Fable 5 — le bouton de réflexion de la session, le paramètre alwaysThinkingEnabled et MAX_THINKING_TOKENS=0 restent tous sans effet ; il raisonne toujours de façon adaptative. Une surface de configuration complète pour 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 le basculement automatique fondé sur le contenu s’applique aux passerelles d’entreprise. /model opus sélectionne désormais Opus 5 (effort high par défaut, /effort xhigh pour les tâches les plus difficiles), et le modèle fourni par défaut dépend de votre offre – Opus 5 avec les offres premium, Sonnet 5 avec Pro/Team Standard ; choisissez délibérément le niveau Fable avec /model fable lorsque vous recherchez les capacités maximales – ce qui, depuis la v2.1.257, correspond à Fable 5.1.^232197207213 Opus 4.7 (16 avril 2026) : Le modèle phare de la génération précédente, toujours pleinement disponible. Fenêtre de contexte de 1 million de tokens au tarif standard — sans supplément pour les contextes longs. Sortie maximale de 128K, adaptive thinking uniquement (extended thinking supprimé) et nouveau niveau d’effort xhigh, recommandé comme point de départ pour les tâches de codage et les charges de travail agentiques.¹⁴⁵ Date limite des connaissances fiables : janvier 2026. Date limite des données d’entraînement : janvier 2026. ID du modèle : claude-opus-4-7. Tarification identique à celle d’Opus 4.6, à 5 $/25 $ par MTok, avec une écriture dans le cache de 5 min à 6,25 $, une écriture dans le cache de 1 h à 10 $ et une lecture du cache à 0,50 $ par MTok.¹⁴⁴ Opus 4.7 résout 3 fois plus de tâches de production sur SWE-Bench qu’Opus 4.6, obtient 70 % sur CursorBench (contre 58 % pour la version 4.6) et améliore de 13 % le taux de résolution sur le benchmark de codage interne de 93 tâches de Anthropic.¹⁴⁴ Il utilise un nouveau tokenizer — prévoyez environ 1 à 1,35 fois plus de tokens 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 au format 1:1.¹⁴⁵

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

Modèle par défaut selon l’offre (Claude Code) :²⁰⁷

Modifications incompatibles de Messages API dans Opus 4.7 (visibles par l’appelant) :¹⁴⁵

• Le paramètre budget_tokens d’extended thinking est supprimé. Utilisez plutôt thinking: {type: "adaptive"}. Adaptive thinking est désactivé par défaut ; les requêtes dépourvues de 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 rétablir un raisonnement visible (indispensable si votre produit diffuse le thinking aux utilisateurs).

Les budgets de tâche (en-tête bêta task-budgets-2026-03-13) permettent d’indiquer au modèle une cible de tokens couvrant une boucle agentique complète 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 1 million et une sortie maximale de 128K. Envisagez de migrer vers Opus 4.7 pour bénéficier de meilleures performances de codage agentique. Opus 4.6 a été lancé initialement le 5 février 2026.⁷⁹¹⁴⁴ Depuis la version v2.1.117 (22 avril 2026), les abonnés Pro et Max utilisent par défaut le niveau d’effort high avec Opus 4.6 et Sonnet 4.6 (contre medium auparavant) ; Opus 4.7 reste réglé sur xhigh. Ce changement a rétabli le niveau d’intelligence après la réduction de l’effort intervenue du 4 mars au 7 avril, documentée dans l’analyse post-mortem du 23 avril.¹⁵²¹⁵³

Sonnet 5 (30 juin 2026) : Le modèle actuel de la gamme Sonnet, présenté comme « la meilleure combinaison de vitesse et d’intelligence ». Anthropic affirme que ses performances sont proches de celles d’Opus 4.8, mais à moindre coût, et qu’il améliore nettement Sonnet 4.6 en matière de raisonnement agentique, d’utilisation d’outils, de codage et de travail intellectuel — tout en affichant globalement moins de comportements indésirables et des capacités de cybersécurité bien plus faibles que les modèles Opus (le compromis de sécurité qui a permis son lancement sans restriction liée au contrôle des exportations). ID du modèle : claude-sonnet-5 (snapshot épinglé sans date). Fenêtre de contexte de 1 million de tokens, sortie maximale de 128K (jusqu’à 300K sur Batches API avec l’en-tête bêta output-300k-2026-03-24), adaptive thinking uniquement. Date limite des connaissances fiables : janvier 2026. Tarification : 2 $/10 $ par MTok en entrée/sortie, désormais le tarif catalogue standard. Lors du lancement, Anthropic avait annoncé le tarif de 2 $/10 $ comme prix de lancement valable jusqu’au 31 août 2026, avant de le conserver : la page de tarification indique que la hausse à 3 $/15 $ prévue pour le 1er septembre « n’aura pas lieu », et la version v2.1.243 a mis à jour le sélecteur /model ainsi que la skill claude-api incluse afin d’afficher 2 $/10 $ comme tarif catalogue plutôt que comme promotion temporaire.²²² Ce tarif est inférieur de 60 % aux 5 $/25 $ d’Opus 5. Dans Claude Code, le paramètre effort utilise par défaut la valeur high avec Sonnet 5 (définissez-le explicitement pour la modifier). Sélectionnez ce modèle avec /model sonnet (ou /model claude-sonnet-5).¹⁸⁰ La version v2.1.197 (30 juin 2026) a fait de Sonnet 5 le modèle par défaut dans Claude Code pour les nouvelles sessions à cette date ; aujourd’hui, il reste le modèle par défaut de l’offre standard (Pro, Team Standard), tandis que les offres premium et Anthropic API utilisent Opus 5 par défaut – consultez le tableau des offres ci-dessus.¹⁸¹²⁰⁷

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 tout en consommant moins de tokens. Prend en charge extended thinking, adaptive thinking et une fenêtre de contexte de 1 million de tokens (bêta). Sortie maximale de 64K (limite supérieure de 128K dans la version v2.1.77).¹¹⁹ Date limite des connaissances : août 2025 (fiables), janvier 2026 (données d’entraînement). ID du modèle : claude-sonnet-4-6.

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

Pourquoi ces écarts de prix comptent : Une session de codage classique consomme entre 50K et 200K tokens en entrée, et entre 10K et 50K tokens en sortie. Avec Haiku, elle coûte entre 0,10 $ et 0,45 $. Avec Opus, la même session coûte entre 0,50 $ et 2,25 $, soit 5 fois plus. Réservez Opus aux problèmes véritablement difficiles.¹

Quand utiliser chaque modèle

Haiku : utilisez-le pour les subagents chargés de l’exploration, des recherches simples de fichiers ou des questions rapides. Il est environ 5 fois moins cher qu’Opus et répond plus vite. Il convient parfaitement aux tâches en arrière-plan qui ne nécessitent pas de raisonnement approfondi.

Sonnet : le modèle polyvalent pour le développement quotidien lorsque le coût compte – et le modèle par défaut de l’offre standard, Pro et Team Standard (contexte natif de 1 million, 2 $/10 $ par MTok au tarif catalogue standard ; la hausse prévue pour le 1er septembre a été annulée).^181222207 Il prend en charge la plupart des tâches de codage : implémentation de fonctionnalités, correction de bugs, écriture de tests et revue de code. Historique : la version v2.1.197 (30 juin 2026) a longtemps été présentée – y compris ici – comme ayant fait de Sonnet 5 le modèle par défaut partout. Toutefois, selon la documentation de configuration des modèles par offre, le modèle par défaut des offres premium/API est passé à Opus 4.8 avec la version v2.1.154, puis à Opus 5 avec la version v2.1.219 ; « partout » désignait donc en réalité l’offre standard. Sonnet 4.6 a occupé le rôle de Sonnet jusqu’en juin 2026.^93147207 Utilisez Sonnet lorsque vous avez besoin de tokens moins chers, d’une latence plus faible ou d’une meilleure rentabilité pour les subagents. Opus : le niveau de raisonnement approfondi — depuis la v2.1.219, l’alias opus sélectionne Claude Opus 5 (5 $/25 $ par MTok, contexte de 1M, effort réglé par défaut sur high).¹⁹⁷ Le paragraphe ci-dessous décrit Opus 4.7 lors de son lancement le 16 avril 2026, conservé à titre historique.¹⁴⁴¹⁴⁷ Réservez ce raisonnement plus coûteux aux situations où il est vraiment utile : décisions architecturales, débogage complexe, compréhension de systèmes complexes, analyse de sécurité et travail agentique de longue haleine. Opus 4.7 résout 3× plus de tâches de production sur SWE-Bench qu’Opus 4.6, obtient 70 % sur CursorBench (contre 58 %) et améliore de 13 % le taux de résolution sur un benchmark interne de programmation comprenant 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 accessible aux 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 contrôles administrateur.¹⁴⁶ Contexte de 1M au tarif standard — aucun supplément pour les contextes longs. 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, lance moins de subagents par défaut et adopte un ton plus direct, avec moins de formulations cherchant à valider l’utilisateur. Si vos prompts contiennent des mécanismes destinés à imposer des messages de progression intermédiaires ou une double vérification, essayez de les supprimer.¹⁴⁵

Opusplan : un mode hybride qui utilise Opus pour la planification (où la qualité du raisonnement compte le plus) et Sonnet pour l’exécution (où la rapidité prime). Excellent pour les refactorisations complexes lorsque vous souhaitez bénéficier du meilleur plan sans avoir besoin d’un raisonnement de niveau 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-5"
}

Personnaliser le sélecteur lui-même (modelPicker, v2.1.242+) : un fichier de paramètres utilisateur ou géré peut répertorier les modèles proposés par /model, dans l’ordre de votre choix et avec vos propres libellés, au lieu de laisser la sélection intégrée comme seul menu. Chaque ligne indique un model (toute forme acceptée par --model, y compris les identifiants Vertex et Bedrock), avec un label et une description facultatifs ; définissez replaceBuiltInOptions sur true pour n’afficher que ces lignes, ainsi que Par défaut et le modèle actuel de la session. Les paramètres du projet et les paramètres locaux sont ignorés pour cette clé, et une liste d’autorisation availableModels continue de filtrer les lignes. Claude Code supprime toute ligne qu’il ne peut pas prendre en charge, grise les lignes que vous ne pouvez pas encore sélectionner en indiquant la raison et revient à la sélection intégrée si aucune ligne ne subsiste.²²¹²¹⁹

{
  "modelPicker": {
    "options": [
      { "model": "us.anthropic.claude-opus-4-8", "label": "Opus (production)" },
      {
        "model": "us.anthropic.claude-sonnet-4-6",
        "label": "Sonnet (production)",
        "description": "Day-to-day work"
      }
    ]
  }
}

Spécifiquement pour les subagents :

export CLAUDE_CODE_SUBAGENT_MODEL=haiku

Depuis la v2.1.251, CLAUDE_CODE_SUBAGENT_MODEL définit le modèle par défaut des subagents au lieu de tout remplacer : le champ model: d’une définition d’agent et un modèle explicitement indiqué lors d’un lancement individuel ont priorité.²⁰⁶ Depuis la v2.1.257, CLAUDE_CODE_SUBAGENT_MODEL_FORCE permet de rétablir l’ancien comportement de manière facultative : il applique CLAUDE_CODE_SUBAGENT_MODEL (ou le modèle de la conversation principale si cette variable n’est pas définie) à chaque subagent, en ignorant les modèles choisis lors des lancements individuels et les champs model: des définitions d’agents.²¹¹

Chaîne de modèles de repli (v2.1.166+) : le paramètre fallbackModel permet de configurer jusqu’à trois modèles de repli, essayés dans l’ordre lorsque le modèle principal est surchargé ou indisponible. L’option --fallback-model (qui servait auparavant uniquement à changer de modèle en cours de session) s’applique désormais aussi 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 ne permettant pas de nouvelle tentative, Claude Code réessaie désormais aussi une fois le tour avec le modèle de repli avant de signaler l’échec. Ainsi, un problème temporaire du modèle principal entraîne une dégradation progressive plutôt que la perte du tour.²³⁴

Depuis la v2.1.178, la compaction respecte également la chaîne de repli — si le modèle principal est surchargé ou indisponible au cours de la compaction, cette étape utilise la chaîne fallbackModel/--fallback-model configurée au lieu de faire échouer le tour. Lors d’une longue exécution autonome, cela élimine le risque qu’une compaction autrement récupérable interrompe la session en raison d’une erreur temporaire du modèle.¹⁷³

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 les contextes longs.¹⁴⁸ 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 habituels sur l’intégralité 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’abonnement Pro, le contexte de 1M est accessible via l’option d’utilisation supplémentaire. Les utilisateurs de API et ceux qui paient à l’usage bénéficient d’un accès complet au contexte de 1M aux tarifs standards par token.¹⁴⁷

Pour désactiver les variantes avec contexte de 1M dans le sélecteur de modèles, définissez CLAUDE_CODE_DISABLE_1M_CONTEXT=1. Depuis la v2.1.223, la portée de cette variable a changé : elle limite désormais à 200K, au moyen de la compaction automatique, tous les modèles dotés nativement d’une fenêtre de 1M — et non plus seulement une liste fixe de variantes connues — et un avertissement s’affiche au démarrage si la compaction automatique ne limite pas réellement la session à 200K. Si vous utilisez ce réglage pour garantir la prévisibilité des coûts d’une famille de modèles, il s’applique désormais aux nouveaux modèles de 1M dès leur sortie au lieu de cesser silencieusement de fonctionner. La même version permet à la compaction automatique de maintenir les sessions utilisant des identifiants de modèles non reconnus dans les limites de la fenêtre de contexte supposée, plutôt que de les laisser la dépasser ; CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT=1 rétablit l’ancien comportement pour les passerelles qui enregistrent des identifiants personnalisés associés à des fenêtres réelles plus grandes.²⁰⁰

Depuis la v2.1.247, la fenêtre de compaction automatique par défaut de Sonnet 5 correspond à son contexte complet de 1M : les sessions utilisant la fenêtre de 1M sont désormais compactées automatiquement autour de 967K tokens au lieu d’environ 934K.²¹⁶

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 des versions épinglées, avec des suggestions de mise à niveau lorsque de nouvelles versions sont disponibles.⁹⁸ La v2.1.219 corrige l’affichage de la ligne Opus fusionnée, qui apparaît désormais simplement comme « 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. Ainsi, elle indique ce qui vient réellement de sortir plutôt qu’une portion arbitraire de la liste.¹⁹⁶

Fast Mode (v2.1.36+)

Fast Mode produit 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 (depuis 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 avec Sonnet, Haiku ou Fable. Elle reste en version préliminaire de recherche uniquement sur Claude API (y compris Claude Managed Agents) — pas sur Amazon Bedrock, Google Cloud, Microsoft Foundry ni 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 avec Opus 5 / Opus 4.8) :¹⁹⁸

Le piège d’Opus 4.7 (v2.1.219). Les modèles non pris en charge ne se comportent pas tous de la même manière. Une requête adressée à claude-opus-4-7 avec speed: "fast" renvoie désormais une erreur — elle ne revient pas silencieusement à la vitesse standard. Opus 4.6 constitue l’exception qui rend cette distinction importante : il accepte speed: "fast", s’exécute néanmoins à la vitesse standard, est facturé aux tarifs standards et indique usage.speed: "standard". Si votre infrastructure épinglait la version 4.7 et comptait sur une dégradation silencieuse des requêtes Fast Mode, celles-ci échouent désormais directement ; migrez l’épinglage vers Opus 5 ou 4.8.¹⁹⁸ Quand utiliser le mode rapide : - Pour itérer rapidement sur de petites modifications lorsque la latence constitue le facteur limitant - Pour générer des tests, du code standard ou répétitif lorsque la vitesse compte davantage que le coût - Pour traiter séquentiellement une liste de tâches similaires

Quand NE PAS utiliser le mode rapide : - Pour les tâches agentiques de longue durée (le coût reste doublé pendant toute l’exécution) - Pour le travail des subagents en arrière-plan (personne n’attend le résultat) - Pour les sessions où le budget est une priorité

Le mode rapide 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 additionnel pour les contextes longs — qui se cumule avec les multiplicateurs liés à la mise en cache des prompts et à la résidence des données.⁹⁶¹⁹⁸

Notes opérationnelles. Le mode rapide possède sa propre limite de débit, distincte des limites standard d’Opus ; si vous la dépassez, un code 429 accompagné de retry-after est renvoyé (les en-têtes de réponse anthropic-fast-*-tokens-* indiquent la capacité restante). Passer du mode rapide au mode standard, ou inversement, 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 entraîne donc un défaut de cache. Le mode rapide n’est pas disponible avec la Batch API ni avec un engagement Priority Tier.¹⁹⁸

Conseil d’expert : le mode rapide n’est pas compatible avec opusplan (opusplan combine déjà Opus et Sonnet ; le mode rapide n’agit que sur la partie 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 de l’usage 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 votre mode rapide. La v2.1.219 a par ailleurs corrigé un problème où les clients Remote Control conservaient un état obsolète du mode rapide 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 vitesse et intelligence. Utilisez /effort pendant une session :

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

Enregistré par modèle (v2.1.251+) : /effort enregistre désormais votre niveau d’effort par défaut pour chaque modèle. Chacun conserve ainsi son propre réglage lorsque vous changez de modèle — votre habitude d’utiliser xhigh avec Opus ne vous suit plus lorsque vous passez à Haiku (CHANGELOG : « Modification de /effort afin d’enregistrer votre niveau d’effort par défaut pour chaque modèle, de sorte que chacun conserve son propre réglage lorsque vous changez de modèle »). L’exception limitant max à la session en cours reste valable.²⁰⁶ La v2.1.257 affine les deux réglages : /effort accepte s pour un choix limité à la session, conformément à la convention de /model, et le flag --effort est désormais limité à la session — il lève le maintien du niveau d’effort par défaut d’un nouveau modèle uniquement pour cette session, sans modification permanente (selon la référence CLI, il « remplace » la valeur par défaut « pour cette session et n’est pas conservé »).²¹¹²¹⁴

Auto Mode avec Max (v2.1.111+)

Depuis le 14 août 2026, Auto Mode est le mode d’autorisation par défaut des offres Pro, Max et Team (annonce publiée le 7 août) — consultez Modes d’autorisation pour connaître les chiffres de l’étude mentionnés dans l’annonce, les méthodes de désactivation et les offres ou passerelles où son activation reste facultative.²⁰³ Il a d’abord été conçu comme une alternative plus sûre à --dangerously-skip-permissions, proposée initialement aux abonnés Max utilisant Opus 4.7 via la Anthropic API.¹⁴⁶ Un modèle de classification distinct — Claude Sonnet 5 depuis la v2.1.210 — 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+) : le flag --enable-auto-mode a été supprimé ; pour démarrer une session dans Auto Mode, utilisez désormais --permission-mode auto. L’offre Pro est restée exclue d’Auto Mode pendant la majeure partie de son existence — le déploiement par défaut du 14 août met fin à cette restriction. Bedrock/Vertex/Foundry (v2.1.158+) : Auto Mode pouvait être activé sur Opus 4.7 et Opus 4.8 avec ces passerelles au moyen de 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 souhaitant le désactiver peuvent utiliser le paramètre géré disableAutoMode. Cette même version fait d’Claude Opus 4.8 le modèle par défaut sur Bedrock, Vertex AI et Claude Platform sur 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.¹⁸⁵ Depuis la v2.1.247, les demandes d’autorisation de Bash comportent une suggestion renvoyant vers Auto Mode, avec une option accessible en une touche : « Oui, et passer à Auto Mode ».²¹⁶

Ce qu’Auto Mode n’est pas : une frontière de sécurité. La plupart des mécanismes décrits ci-après renforcent un classificateur, or un classificateur n’est pas une sandbox. Le 26 août 2026, Johann Rehberger, chercheur spécialisé dans les injections de prompts, a publié une chaîne d’attaque fonctionnelle contre Claude Code Opus 5 en mode automatique. Sur de petits échantillons, il rapporte un taux de réussite de 60 à 80 % — 3 exécutions sur 5 pour la chaîne principale, qui lance un processus enfant python3 isolé, ainsi que 3 sur 5 et 4 sur 5 pour deux configurations d’une variante dont la charge utile lance une instance sans interface graphique de claude -p. Il précise lui-même qu’il s’agit de petits échantillons, et non d’une mesure universelle du taux de réussite de l’attaque.²¹⁰ Cette chaîne mérite d’être comprise, car chaque étape prise individuellement paraît raisonnable : un serveur répond à WebFetch avec le code HTTP 415, ce qui pousse l’agent à se rabattre sur curl ; l’archive téléchargée est extraite dans un dossier temporaire contenant un manifeste, sept enregistrements de données encodés en Base85/zlib, un binaire natif et un fichier struct.py ; Claude refuse d’exécuter le binaire non fiable, puis écrit son propre décodeur Python et l’exécute depuis ce dossier ; le décodeur importe base64, base64 importe struct, et Python charge en priorité le fichier struct.py de l’attaquant. Aucune instruction de cette séquence n’est manifestement malveillante — l’injection doit seulement faire du chemin compromis la solution la plus raisonnable pour terminer la tâche. Rehberger rapporte également que, lors de quelques exécutions, Claude a tenté d’arrêter le processus malveillant après avoir détecté la compromission, mais que le mode automatique a refusé la commande de nettoyage.²¹⁰ Il met cette découverte en regard d’un chiffre utilisé par Anthropic dans sa communication : une évaluation commandée à un tiers a fait état d’un taux de réussite des attaques par injection de prompts de 0,00 % pour Opus 5 en mode automatique, sur 72 scénarios exécutés dix fois chacun. Sa chaîne ne faisait pas partie de cet ensemble, ce qui explique comment un résultat de référence de 0,00 % et une chaîne fonctionnelle d’exécution de code peuvent être vrais simultanément ; selon lui, ces deux messages restent néanmoins incompatibles.²¹⁰ À noter également concernant la classification : dans sa mise à jour du 30 août, Simon Willison approuve la remarque d’un lecteur selon laquelle il ne s’agit pas d’une injection de prompts classique — le modèle ne lit ni ne suit les instructions de l’attaquant — mais d’une attaque par confusion de l’environnement.²¹⁰ Anthropic a clôturé le rapport avec le statut « Informatif » — le comportement fonctionne comme prévu — et la position rapportée par Rehberger est celle autour de laquelle il convient de concevoir les protections : le mode automatique est un classificateur fondé sur le meilleur effort, et non une garantie de sécurité ; les chaînes d’injection délibérées assemblées à partir d’étapes individuellement bénignes ne relèvent pas de ce qu’un classificateur est censé détecter ; et la véritable limite de confinement repose sur l’isolation au niveau du système d’exploitation et le contrôle du trafic réseau sortant.²¹⁰ Cela ne contredit pas les mesures de sécurisation ci-dessous — c’est le cadre approprié pour les comprendre. Le mode automatique réduit le nombre de demandes auxquelles vous devez répondre et bloque une liste documentée d’opérations destructrices ; il ne sécurise pas une session exposée à des entrées non fiables. Si une session doit traiter du contenu susceptible d’avoir été influencé par un attaquant — pages récupérées, archives téléchargées, texte de tickets, serveurs MCP tiers — les contrôles qui limitent réellement les dégâts sont ceux qui se trouvent en dehors du modèle : un conteneur ou une machine virtuelle, un trafic réseau sortant restreint, la surveillance des actions réellement effectuées par l’agent et un dossier personnel qui ne contient ni les clés SSH ni les identifiants cloud que vous ne voudriez pas perdre. Une approbation en mode automatique ne prouve pas qu’une action était sûre.

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 fonctionnaient selon un choix exclusif : définir votre propre liste revenait à perdre les règles de sécurité intégrées. Le marqueur $defaults résout ce problème : il est remplacé à l’endroit exact où vous le placez par 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
    ]
  }
}

Modifiez les règles du classificateur depuis /permissions (v2.1.246). Exécutez /permissions et ouvrez l’onglet Mode automatique, qui n’apparaît que lorsque ce mode est disponible pour la session. Il répertorie les entrées allow, soft_deny, hard_deny et environment de chaque portée consultée par le classificateur, et indique si les règles intégrées sont actives pour chaque section ; les entrées provenant des paramètres administrés ou de --settings sont en lecture seule, et chaque modification est enregistrée dans ~/.claude/settings.json. L’ajout de la première règle à une section insère également "$defaults" afin de conserver les règles intégrées. Vous pouvez activer ou désactiver celles-ci séparément pour chaque section — une section doit contenir au moins une de vos propres règles avant que ses règles intégrées puissent être désactivées — tandis que environment s’ouvre sous la forme d’un document unique dans votre éditeur.²²⁰²¹⁸

Option « Ne plus demander » (v2.1.118+). L’invite d’activation du mode automatique propose désormais l’option « Ne plus demander », afin que les utilisateurs fréquents puissent masquer l’explication sans avoir à automatiser un indicateur.¹⁵²

Garde-fous contre les commandes destructrices (v2.1.183). Le mode automatique 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’infrastructure (terraform destroy, pulumi destroy, cdk destroy), sauf si vous avez nommé la pile concernée. Cela réduit le rayon d’impact du classificateur précisément pour les opérations qui peuvent supprimer silencieusement du travail ou détruire des environnements — l’agent peut toujours les exécuter, mais uniquement sur votre instruction explicite, jamais de sa propre initiative.¹⁷⁴

Classez chaque commande shell (v2.1.193). Par défaut, le classificateur du mode automatique examine uniquement les commandes shell correspondant à des motifs d’exécution de code arbitraire ; les commandes courantes ne lui sont pas soumises. Le nouveau paramètre autoMode.classifyAllShell transmet 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 que chaque appel shell soit contrôlé. Cette même version affiche également les motifs de refus du mode automatique dans la transcription, la notification de refus et la liste des refus récents de /permissions, afin qu’une commande bloquée indique désormais pourquoi elle l’a été.¹⁷⁹

Trois règles de sécurisation supplémentaires (v2.1.205). Le mode automatique empêche désormais toute altération des fichiers de transcription de la 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 évite les accidents du type rm -rf $DIR lorsque $DIR est inconnu ; et les notifications de tâches en arrière-plan précisent désormais explicitement qu’aucune intervention humaine n’a eu lieu, afin qu’une fausse ligne « utilisateur approuvé » insérée dans une transcription ne puisse pas être transformée en approbation exploitable.¹⁸³ La troisième règle constitue une défense contre l’injection de prompt qu’il faut bien retenir : 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 automatique. Encapsuler une commande destructrice dans une substitution ne permet donc plus de contourner le dispositif de sécurité.¹⁸⁶

Réinitialisez l’état du mode automatique : claude auto-mode reset (v2.1.212). Une nouvelle sous-commande réinitialise l’état de votre mode automatique depuis le terminal ; transmettez --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, même niveau de contrôle (v2.1.218). Trois vérifications qui interrompaient auparavant le mode automatique avec une boîte de dialogue d’autorisation — les commandes rm dangereuses, l’utilisation de & en arrière-plan et les chemins Windows suspects — ne le font plus ; le classificateur du mode automatique tranche désormais lui-même, de sorte que le contrôle de sécurité demeure sans vous solliciter à chaque détection. Cette version applique également ce fonctionnement au mode plan avec le mode automatique : les commandes Bash dont l’analyseur statique ne peut pas démontrer 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.¹⁹⁵

Règle contre l’évasion du confinement (v2.1.257). La liste des actions que le classificateur ne doit jamais approuver automatiquement s’enrichit d’une règle « Évasion du confinement » : la récupération d’identifiants depuis les services de métadonnées cloud, le contournement des restrictions sur le trafic réseau sortant et l’accès entre locataires ne sont plus approuvés automatiquement, sauf si l’environnement les signale comme attendus. Interprétez cette évolution dans le cadre posé par l’avertissement ci-dessus : il s’agit d’un nouveau renforcement du classificateur — une catégorie de refus documentée supplémentaire — et non d’une modification de la nature du mode automatique.²¹¹

Demande unique pour les lectures en dehors des dossiers de travail (v2.1.257). Le mode automatique demande désormais une confirmation avant la première lecture de fichier effectuée par la session en dehors des dossiers de travail. Le paramètre associé permissions.blockReadsOutsideWorkingDirectories transforme cette demande en refus : ces lectures sont alors systématiquement bloquées.²¹¹

Nouvelles commandes dans les 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 des notifications push sur mobile à sa discrétion grâce à un nouvel outil de notification push. 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, cette même variable permet d’activer ou de désactiver la fonctionnalité pendant son déploiement.¹⁴⁶

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

Réduction des demandes de permission : 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 de permission.¹⁴⁶ Associé à /less-permission-prompts, ce changement devrait réduire considérablement les interruptions dans les workflows quotidiens.

Traçage distribué (v2.1.110+)

Les sessions SDK et headless lisent désormais TRACEPARENT et TRACESTATE depuis l’environnement, ce qui permet de relier 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 le lancement de CLI : 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 la version intégrée de JavaScript. Les commandes d’installation et de mise à jour restent identiques, et les équipes n’ont pas besoin de modifier leurs scripts de déploiement.

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

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

Délai d’expiration des subagents bloqués (v2.1.113+)¹⁵⁰

Les subagents qui se bloquent au milieu d’un 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 couvrir plus largement les processus bloqués lors du streaming des 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 des permissions pouvait planter lorsqu’un membre d’une équipe d’agents demandait l’autorisation d’utiliser un outil. Effectuez la mise à niveau si vous utilisez Agent Teams.

Marquage du contenu : filigranes textuels et métadonnées de fichiers C2PA (août 2026)

Anthropic a annoncé un marquage lisible par machine pour le contenu généré par Claude, motivé par l’article 50 du règlement européen sur l’intelligence artificielle (applicable à compter du 2 août 2026 aux systèmes d’IA nouvellement lancés). Le système comporte deux composants : un filigrane statistique invisible dans le texte généré et des métadonnées de provenance signées — conformes au standard ouvert C2PA — dans les fichiers générés tels que .svg, .png et .jpg.²²³²⁰⁴ Un détail est estompé par les gros titres : les deux composants suivent le même calendrier de modèles. D’après la page d’assistance, « les modèles Claude lancés à compter du 2 août 2026 prendront en charge le marquage lisible par machine dès leur lancement » — les modèles lancés avant cette date, soit toute la gamme actuelle (Fable 5, Opus 5, Sonnet 5, Haiku 4.5), relèvent de la période transitoire prévue par la législation européenne, tandis que Anthropic « travaille également à ajouter la prise en charge du marquage à ces modèles ».²⁰⁴ Rien de ce que vous générez aujourd’hui avec Claude Code ne comporte de marquage, qu’il s’agisse de texte ou de fichiers ; les sorties des futurs modèles en comporteront sur toutes les interfaces — Claude Platform (API), claude.ai, Claude Code, Claude Cowork, Claude Tag et les passerelles cloud — puisque le marquage intervient au niveau du modèle. Une conséquence mérite d’être précisée, car un fil de discussion viral l’a présentée à l’envers : tout changement de style ou de comportement que vous percevez dans un modèle actuel ne peut pas provenir du filigrane — celui-ci n’est actif dans aucun modèle actuel.

Fonctionnement : il s’agit d’une variante de SynthID-Text de Google DeepMind. Le filigrane modifie « la source du caractère aléatoire utilisée pour choisir parmi les mots » lorsque Claude sélectionne des options sémantiquement équivalentes — aucun caractère n’est ajouté, aucun post-traitement n’est appliqué et, selon les tests internes de Anthropic, le filigrane n’a « aucun impact sur le contenu, le niveau de créativité ou la lisibilité ».²²³

Ce qui intéressera les utilisateurs de Claude Code : le code comporte un filigrane peu dense. Le code fonctionnel laisse peu de place aux choix arbitraires ; le marquage se concentre donc là où une certaine liberté existe — commentaires, noms — avec ce que Anthropic qualifie d’« effet négligeable sur le code effectivement produit ».²²³ Sa persistance est probabiliste et varie selon le composant : pour le texte, une modification légère « ne supprimera probablement pas complètement le filigrane », tandis qu’une réécriture intégrale le fera, et une traduction produite par Claude comportera son propre nouveau marquage ; pour les métadonnées de fichiers, la conversion de format, le réenregistrement et les captures d’écran peuvent supprimer la signature C2PA.²⁰⁴ Une API de détection est prévue ; un résultat positif prouvera qu’« Claude a probablement participé à la création du contenu à un moment donné » et ne permettra explicitement pas de distinguer « Claude a rédigé ceci » de « Claude a profondément remanié ceci » — et, selon la page d’assistance, l’absence de marquage ne prouve rien non plus. Aucune option de désactivation n’est mentionnée, quel que soit le niveau d’abonnement du client.²²³²⁰⁴

Combien coûte Claude Code ?

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

Consultation des coûts

> /cost

Sortie :

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

Les utilisateurs disposant d’un abonnement voient dans /cost une ventilation par modèle et par résultat trouvé dans le cache, indiquant précisément quels modèles ont consommé des tokens et quelle part a été fournie depuis le cache (v2.1.92+).¹³⁷

Tarifs contractuels au lieu du prix catalogue (modelPricing, géré, v2.1.243+) : les organisations disposant de tarifs négociés par modèle ou d’un coefficient de remise peuvent les déployer au moyen du paramètre géré modelPricing ; /cost, la ligne d’état et les données de coût de la télémétrie utilisent alors ces tarifs plutôt que le prix catalogue, de sorte que les chiffres affichés aux développeurs correspondent aux montants payés par l’organisation.²²¹

Ligne de cache de prompt par session (v2.1.251+) : /cost ajoute une ligne consacrée au cache de prompt de la session — taux de succès, échecs, tokens remis en cache et état chaud ou froid du cache — ainsi qu’un objet prompt_cache correspondant pour les scripts de ligne d’état. Cet objet apparaît après la première réponse de API de la conversation principale, ne tient pas compte des requêtes des subagents et est calculé à partir du nombre de tokens de cache dans les réponses de API ; il fonctionne donc avec tous les fournisseurs. /usage affiche les mêmes statistiques sur sa ligne Prompt cache (main).²⁰⁶²⁰⁹

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 standard de API.¹⁴

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 sur cinq heures de Claude Code pour les formules Pro, Max, Team et Enterprise par siège, supprimé la réduction appliquée aux heures de pointe pour 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 sert de garantie de capacité : « plus de 300 mégawatts de nouvelle capacité (plus de 220 000 GPU) dans le mois ».¹⁵⁷

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

Pour les utilisateurs facturés via API, voici les tarifs 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 un contexte de 1M aux tarifs standard par MTok — sans supplément pour les contextes longs.¹⁴⁸ Il s’agit d’une harmonisation récente ; les anciennes recommandations selon lesquelles Opus 4.6 ou Sonnet 4.6 étaient facturés 2× en entrée et 1,5× en sortie au-delà de 200K tokens d’entrée ne sont plus d’actualité. Les anciens modèles Opus 4.5 et antérieurs conservent leur structure tarifaire d’origine.

Tarification liée à la résidence des données : le choix d’une inférence exclusivement aux États-Unis au moyen de inference_geo applique un coefficient de 1,1× à l’ensemble de la tarification des tokens, y compris les lectures et écritures dans le 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), tandis que les lectures ne coûtent que 0,1×, soit une économie de 90 % — et, uniquement sur Claude Fable 5.1 et Mythos 5.1, elles descendent à 0,025× (0,25 $/MTok sur Fable 5.1), soit une économie de 97,5 %.²¹² Pour les systèmes RAG et les assistants de programmation réutilisant le même contexte, la mise en cache peut réduire les coûts de 88 à 95 %.

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

Politique relative aux comptes multiples⁵²

Pouvez-vous avoir plusieurs comptes Claude ? Oui, pour des cas d’usage légitimes. Anthropic autorise explicitement plusieurs comptes lorsqu’ils répondent à des objectifs 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 séparés ; 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 l’offre gratuite

Exemple concret : en janvier 2026, les 22 comptes Max de l’utilisateur intensif Jeffrey Emanuel (@doodlestein) ont été signalés automatiquement 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 des projets professionnels et personnels répartis sur plusieurs comptes, le service est précisément conçu pour cela, mais n’essayez pas de contourner le système.

En cas de doute : contactez l’assistance de Anthropic pour obtenir une confirmation écrite concernant 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 d’exploration et Sonnet pour l’implémentation permet généralement de réduire 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 d’outils supplémentaires

Outre 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 représente à lui seul un surcoût d’environ 24 500 tokens d’entrée.

Stratégies de réduction des coûts

1. Utilisez Haiku pour les subagents : la plupart des explorations 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 arrête complètement la session une fois le plafond de dépenses atteint. Depuis la v2.1.217, ce plafond s’applique également aux subagents en arrière-plan : une fois atteint, la création de nouveaux agents est refusée et les agents en arrière-plan déjà actifs sont arrêtés (auparavant, ils échappaient à cette limite budgétaire)¹⁹⁴
5. Utilisez le plan mode pour l’exploration : aucune exécution = aucune opération coûteuse déclenchée accidentellement
6. Compactez de manière proactive : contexte plus réduit = moins de tokens
7. Limitez la sortie : export CLAUDE_CODE_MAX_OUTPUT_TOKENS=2000
8. Utilisez Batch API pour les tâches non urgentes : remise de 50 % sur les tokens d’entrée et de sortie
9. Analysez les dépenses Claude API d’un projet : /claude-api cost-optimize (v2.1.247+) analyse les dépenses Claude API d’un projet existant et examine les leviers de réduction des coûts (mise en cache, maîtrise des tokens, batch, effort, choix du modèle), une modification mesurée à la fois — pour les applications que vous développez avec API, et non pour la session Claude Code elle-même²¹⁶

Suivi de l’utilisation

• Console Claude : platform.claude.com (rôle Admin ou Billing requis)
• Limites de workspace : définissez des limites de dépenses pour chaque workspace
• 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 et aux indicateurs de productivité de Claude Code 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 IA

Remarque : les données apparaissent dans l’heure qui suit 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 les 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 5 (high effort default; /effort xhigh for harder)
                  │         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 : le modèle par défaut dépend de votre abonnement : Opus 5 avec les offres premium et le Anthropic API, Sonnet 5 avec Pro et Team Standard ; /model opus fait passer une session Sonnet à Opus 5.^181197207 Utilisez Haiku pour les subagents. Passez à Opus lorsque la réponse de Sonnet vous semble 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 ne l’augmentez que 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 raisonnement face aux 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 choisir ?

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 choisir ?

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 bascule PAS vers un modèle moins cher et, à 10 $/50 $ par million de tokens, il n’est pas moins cher non plus.¹⁹⁶¹⁹⁸

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 flux de travail. 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 du 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 fournit une intelligence du code comparable à celle d’un IDE : - Accéder à la définition : accéder à l’emplacement où un symbole est défini - Rechercher les références : répertorier toutes les utilisations d’un symbole dans la base de code - Documentation au survol : obtenir les informations de type et la documentation de n’importe quel symbole - Fonctionne 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 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 les rares cas de saisies extrêmement abusives ou de tentatives persistantes de jailbreak, Claude peut mettre fin immédiatement à la session au moyen de 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 flux de travail — elle ne se déclenche jamais lors des sessions de développement normales.¹⁹⁰¹⁹³

Modes d’autorisation

Le mode default porte le libellé « 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é, de sorte 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 le libellé ne donne plus l’impression qu’il s’agit du « mode que vous obtenez par défaut », alors qu’il s’agit en réalité du mode d’approbation manuelle. Dans la 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, et vous pouvez réactiver un délai d’inactivité via /config.

Le mode auto est le mode prêt à l’emploi par défaut sur les offres Pro, Max et Team depuis le 14 août 2026 — annoncé le 7 août et confirmé comme actif dans la documentation officielle sur les modes d’autorisation à la date du basculement. Sa formulation actuelle apporte deux précisions importantes sur sa portée : ce réglage par défaut s’applique aux nouvelles sessions, et « un réglage par défaut que vous avez vous-même défini reste en place, sauf si vous acceptez l’invite de changement unique, tandis qu’un réglage par défaut géré par votre organisation reste inchangé ». Les nouvelles sessions associées à ces offres démarrent en mode auto, lequel « soumet chaque appel d’outil à un classificateur conçu pour bloquer les actions irréversibles, destructrices ou dirigées hors de votre environnement ». Voici l’argument avancé par Anthropic en faveur de ce changement : dans une étude menée auprès de 1 053 testeurs, le mode auto a détecté 89 % des commandes dangereuses, contre 13,6 % pour la vérification humaine — et les utilisateurs approuvent de toute façon 97 % des demandes d’autorisation, ce qui affaiblit en pratique la vérification manuelle. Le surcoût en tokens du classificateur n’est plus facturé sur les offres Pro/Max/Team (depuis cette annonce). Un seul Shift+Tab permet de revenir au mode précédent (ou utilisez le menu déroulant des modes dans l’application de bureau) ; définissez un autre mode par défaut avec defaultMode dans les paramètres ; les administrateurs d’organisation peuvent entièrement désactiver le mode auto au moyen du paramètre géré disableAutoMode. Enterprise, le API de Claude, Claude Platform sur AWS, Bedrock, Agent Platform de Google Cloud et Foundry restent pour l’instant sur adhésion volontaire — Anthropic prévoit de leur appliquer ce réglage par défaut « dans le mois à venir ».²⁰³ Pour savoir ce que le mode auto ne garantit pas — ainsi que le contournement démontré par des chercheurs qui a poussé Anthropic à le préciser —, consultez Mode auto sur Max.

Les fichiers de configuration permettant l’exécution de code nécessitent désormais une 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, la 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 sont donc soumis à une validation délibérée, même dans un mode destiné aux projets de confiance qui laisse normalement passer les modifications. Il s’agit du même modèle de menace que pour les protections existantes contre l’écriture dans .claude/, .git/ et .vscode/, étendu à la catégorie plus large des fichiers où « modifier revient à exécuter ».²³⁶

Mode auto (v2.1.85+) : une alternative plus sûre à --dangerously-skip-permissions. Un modèle de classification distinct — Claude Sonnet 5 depuis la v2.1.210 (initialement 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 ou de refus sont évaluées en premier - Tout le reste est soumis au classificateur pour évaluation - En cas de blocage, Claude tente automatiquement une autre approche

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

Disjoncteur : 3 blocages consécutifs ou 20 blocages au total au cours d’une session entraînent le retour aux demandes de confirmation manuelles.¹²⁵

# Enable at startup
claude --permission-mode auto

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

Le mode auto ne nécessite plus d’activation préalable (v2.1.152), fonctionne sur Bedrock/Vertex/Foundry sans indicateur d’environnement (v2.1.207) et constitue le mode prêt à l’emploi par défaut sur les offres Pro/Max/Team depuis le 14 août 2026.^238185203

Mode YOLO (v2.0.68+) : pour un fonctionnement entièrement autonome sans aucun classificateur de sécurité, utilisez l’indicateur --dangerously-skip-permissions. Cet indicateur accepte tout : modifications de fichiers, commandes bash et tous les appels d’outils. Le terme « dangerous » est volontaire. Le mode auto est l’alternative recommandée dans 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"
  }
}

Restriction de portée de defaultMode (v2.1.257) : le fichier .claude/settings.json ou .claude/settings.local.json d’un projet ne peut plus définir defaultMode: "bypassPermissions" – cette valeur y est ignorée, comme "auto" l’était déjà. La documentation énonce désormais explicitement la règle : les valeurs auto et bypassPermissions de permissions.defaultMode « ne prennent pas effet depuis les paramètres du projet ou les paramètres locaux » – définissez-les dans les paramètres utilisateur ou gérés, ou pour chaque session avec --permission-mode. Un dépôt cloné ne peut donc pas fournir un fichier de paramètres qui lance les sessions sans contrôle des autorisations. (L’exemple ci-dessus utilise acceptEdits, que toutes les portées peuvent définir ; ce guide n’avait jamais documenté non plus la restriction préexistante concernant auto – les deux sont désormais consignées.)²¹¹²¹⁴

Syntaxe des règles d’autorisation

Des règles précises contrôlent des opérations particulières. 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.

Limite importante : les motifs Bash ne reconnaissent que les préfixes, pas les expressions régulières. Un motif tel que Bash(curl http:*) ne correspondra pas à curl -X GET http://..., car les options précèdent l’URL. Pour obtenir un blocage fiable, refusez entièrement la commande : Bash(curl:*).

Placez le * après la sous-commande. Claude Code recherche tel quel tout ce qui précède le premier * ; ce sont donc ces mots qui limitent la règle : Bash(git log *) n’autorise que les commandes git log, tandis que dans Bash(git * main), le * remplace la sous-commande et toutes les options qui la précèdent. Cela inclut -c, qui permet à git d’exécuter un programme que vous indiquez ; Bash(git * main) approuve donc également git -c core.fsmonitor=<script> diff main. Depuis la v2.1.246, Claude Code affiche au démarrage un avertissement lorsqu’une règle d’autorisation contient un caractère générique avant la sous-commande, qu’elle provienne d’un fichier de paramètres, de paramètres gérés ou d’une valeur --allowedTools/--settings ; corrigez-la en indiquant la valeur exacte voulue, par exemple Bash(git checkout main) au lieu de Bash(git * main).²²⁰²¹⁸

Les règles de refus portant sur les fichiers couvrent désormais les redirections et les valeurs d’options (v2.1.257-259). Les règles de refus Read(...) et Edit(...) appliquées aux commandes Bash couvrent désormais les redirections d’entrée (< file) et les commandes de lecture telles que tac et egrep (v2.1.257) – il s’agit de la version plus ciblée promise après l’annulation, dans la v2.1.233, des contrôles de redirection d’entrée introduits par la v2.1.232 ; cette promesse est maintenant tenue. La v2.1.259 étend cette même couverture aux chemins de fichiers dissimulés dans les valeurs d’options et les opérandes : --ignore-revs-file=.env, -f.env, les arguments @file, les opérandes de git diff et git grep, ainsi que les commandes composées cd DIR && cat FILE sont tous vérifiés par rapport aux règles de refus Read(). De même, l’exécution de grep -r ou cp -r sur un répertoire contenant un fichier refusé nécessite désormais une confirmation.²¹¹

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 telle que Edit(src/**) approuvait automatiquement les écritures dans n’importe quel répertoire nommé src, où qu’il se trouve dans l’arborescence — vendor/src/, packages/foo/src/, tous étaient concernés. Désormais, elle correspond 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 à profondeur quelconque — ce changement limite ce qui est approuvé automatiquement, jamais ce qui est bloqué. Après une mise à niveau, une règle qui cesse silencieusement de correspondre se manifeste par de nouvelles demandes d’autorisation, et non par une erreur ; vérifiez donc toutes les règles d’autorisation écrites sous la 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 Critères de correspondance).¹⁹⁰

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 écrites avec 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 toutes les anciennes règles afin de supprimer l’avertissement et d’expliciter leur intention.¹⁸⁷

L’option « Always allow » enregistre les règles à la racine du dépôt (v2.1.211). Les règles d’autorisation créées au moyen 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 donc 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 d’outils MCP :

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

Utilisez la syntaxe avec caractère générique mcp__server__* pour autoriser ou refuser tous les outils d’un serveur MCP particulier.³² Cette syntaxe permet d’activer rapidement tous les outils de serveurs de confiance ou de bloquer entièrement ceux 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 cet emplacement refuse tous les outils, ce qui vous permet de tout bloquer avant de réautoriser un ensemble restreint. À l’inverse, les règles d’autorisation rejettent les globs qui ne concernent pas MCP — vous ne pouvez pas tout autoriser globalement de la même façon, ce qui préserve 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 reconnaître les paramètres d’entrée d’un outil, avec * comme caractère générique pour 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 simplement d’une consigne dans le prompt demandant de l’éviter. Le contrôle des autorisations ne porte ainsi plus seulement sur « quel outil », mais aussi sur « la manière dont il est appelé », au moyen d’une règle déterministe plutôt que d’une demande formulée dans un prompt. Ce mécanisme complète le paramètre géré enforceAvailableModels : la liste d’autorisation définit les niveaux de modèle disponibles pour la session, tandis que les règles Tool(model:...) limitent la manière 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é particulier est lancé (au moyen d’un workflow, de --agents ou d’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 faille permettant à un agent nommé de contourner une règle destiné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

Vous pouvez également le configurer 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 exécutée dans la sandbox.¹⁷⁶

Depuis la v2.1.221, les fichiers d’identifiants disposent d’un troisième mode en plus de l’autorisation et du refus : mode: "mask" (Linux et WSL). Une commande exécutée dans la sandbox qui lit le fichier reçoit une copie contenant des valeurs sentinelles — soit pour l’intégralité du fichier, soit uniquement pour les segments capturés par une expression régulière extract —, puis le proxy de la sandbox remplace les valeurs sentinelles par les valeurs réelles à la sortie. La commande fonctionne (elle peut s’authentifier via le proxy) sans que le secret ne soit jamais présent dans son environnement, ce qui est précisément la propriété recherchée lorsqu’une commande issue d’une injection de prompt tente de dénicher des tokens. Sur macOS, où le mécanisme de substitution du proxy n’est pas disponible, mask revient à deny ; une configuration conçue pour une CI Linux se dégrade donc de manière sûre au lieu d’exposer silencieusement le fichier.¹⁹⁹

La v2.1.224 étend le masquage au-delà du contenu statique des fichiers. extract et onExtractNoMatch prennent en charge les valeurs d’environnement structurées ; decode: "jwt" avec maskClaims masque certains claims au sein d’un JWT plutôt que l’intégralité du token, afin qu’une commande puisse toujours lire les métadonnées de routage du token sans accéder aux claims sensibles, qui restent remplacés par des sentinelles ; enfin, awsPairs/sigv4 signe de nouveau les requêtes AWS SigV4 au niveau du proxy, ce qui rend le masquage utilisable avec les CLIs AWS — une clé masquée échouerait autrement à la vérification de la signature. Toutes ces fonctionnalités nécessitent network.tlsTerminate et ne sont prises en compte que depuis les portées utilisateur, gérée ou --settings ; un dépôt ne peut donc pas fournir une configuration de masquage qui redirige silencieusement vos identifiants.²⁰¹

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 sorties réseau — une option utile lorsque la prison du système de fichiers perturbe un outil de build, mais que vous souhaitez toujours imposer la liste des domaines autorisés au trafic sortant.¹⁹²

Depuis la v2.1.219, le paramètre sandbox.network.strictAllowlist refuse purement et simplement 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 absent de allowedDomains, une demande d’autorisation apparaît ; avec strictAllowlist, la connexion est simplement refusée. Ce paramètre convient aux exécutions sans surveillance — CI, agents en arrière-plan, boucles nocturnes —, où une demande à laquelle personne ne répond entraîne un blocage et où « m’interroger sur une sortie réseau inattendue » n’est de toute façon pas la bonne politique. Il complète le trio de contrôle réseau : allowedDomains indique ce qui est autorisé, deniedDomains (ci-dessous) ajoute des exceptions à une autorisation étendue, tandis que strictAllowlist détermine si tout le reste doit déclencher une demande ou échouer.¹⁹⁶ La v2.1.229 durcit la syntaxe même des listes de domaines : les littéraux IPv6 doivent être placés entre crochets ([::1]:443), les écritures ambiguës sont traitées selon une logique de refus par défaut et /doctor les signale.²²⁸ La v2.1.236 ajoute deux autres mesures de durcissement : sur macOS, les règles génériques de refus de lecture (par exemple **/.env) ont désormais priorité au sein des zones de lecture autorisées, couvrent le contenu des répertoires correspondants et ne peuvent pas être contournées en renommant le fichier refusé ; par ailleurs, lorsque le mode auto est actif, les règles d’autorisation Monitor sont mises de côté — les commandes Monitor sont soumises au même examen par le classificateur que les commandes Bash. Le classificateur du mode auto fonctionne désormais avec les mêmes réglages par défaut que sur le API de Claude — y compris la classification par score de gravité — sur Bedrock, Vertex AI et Foundry, ainsi que lorsque la télémétrie est désactivée.²¹⁷

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 est défini sur 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. Les tests internes de Anthropic ont constaté que la sandbox réduit de 84 % les demandes d’autorisation.³⁸ La sandbox utilise des primitives du système d’exploitation (seatbelt de 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 au moyen de sandbox.excludedCommands ou dangerouslyDisableSandbox pouvaient auparavant contourner la règle d’autorisation Bash de type ask 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, afin d’empêcher une injection de prompt de modifier les définitions des skills.⁸⁸ La v2.1.77 ajoute un paramètre de système de fichiers allowRead pour la sandbox, qui permet d’autoriser de nouveau la lecture dans les zones denyRead — utile lorsque vous souhaitez bloquer la majeure partie d’une arborescence de répertoires 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 imbriquée de .claude/ (v2.1.178) : les skills placés dans des répertoires .claude/skills imbriqués se chargent désormais automatiquement lorsque vous travaillez sur des fichiers situés sous le répertoire correspondant, 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>, afin que les deux demeurent disponibles. Le reste de la surface du projet suit la même logique : lorsque le nom d’un agent, d’un workflow ou d’un 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, tandis que l’enregistrement d’un workflow à la portée du projet cible le répertoire .claude/workflows/ existant le plus proche. Dans un monorepo ou un dépôt de dépôts, vous obtenez ainsi des outils propres à chaque package qui s’activent en fonction du contexte, plutôt qu’une unique surface globale et uniforme.¹⁷³

Chemins bubblewrap et socat personnalisés (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 binaires bubblewrap et socat. Cette possibilité est utile lorsque les distributions installent ces outils en dehors de $PATH ou lorsque l’organisation fournit ses propres builds renforcés.¹⁶⁰

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

• sandbox.network.deniedDomains bloque des hôtes précis, même lorsqu’un caractère générique plus large dans allowedDomains les autoriserait autrement. Utilisez la 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 toute votre politique d’autorisation. Associez-la à sandbox.network.strictAllowlist (v2.1.219, ci-dessus) lorsque vous souhaitez que tout ce qui ne figure pas dans la liste d’autorisation soit refusé silencieusement plutôt que de déclencher une demande.
• Règles de refus pour les commandes enveloppes. Les règles de refus Bash reconnaissent désormais les commandes enveloppées dans env, sudo, watch, ionice, setsid et d’autres wrappers d’exécution similaires. Les règles telles que Bash(rm:*) interceptent maintenant env rm -rf, sudo rm -rf et les variantes de contournement apparentées.
• Les règles d’autorisation Bash(find:*) n’approuvent plus automatiquement find -exec ou find -delete. Ces indicateurs 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 pointant vers /private/ ; la forme précédente des règles ne couvrait donc pas les cibles canoniques.

Durcissement des autorisations par refus en cas d’incertitude dans la v2.1.214 :¹⁹⁰

Plusieurs failles dans les contrôles d’autorisation ont été corrigées dans une même version, toujours selon une logique de refus en cas d’incertitude — lorsque l’analyseur ne peut pas se prononcer avec certitude, il demande une confirmation :

• Contournement de Windows PowerShell 5.1 corrigé. Les commandes exécutées dans des sessions PowerShell 5.1 pouvaient auparavant échapper au contrôle des autorisations.
• Refus par défaut pour les redirections de descripteurs de fichiers Bash. Les formes de redirection que bash analyse différemment de l’analyseur d’autorisations déclenchent désormais une demande de confirmation au lieu d’être exécutées.
• Les commandes de plus de 10 000 caractères demandent toujours une confirmation. 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 au sein des 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 consulter la documentation.
• Ordre des demandes dans les sessions distantes. Les demandes d’autorisation des sessions distantes ne peuvent plus poursuivre leur exécution avant la boîte de dialogue de confirmation locale.
• Les indicateurs 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 — ces indicateurs dirigent pourtant la commande vers un daemon totalement différent.
• file perd son laissez-passer en lecture seule lorsqu’un emplacement d’écriture lui est indiqué. 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 indispensables pour faire respecter les normes de l’équipe et automatiser les tâches répétitives. Consultez Cadres de décision pour voir 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 l’oublier, privilégier la rapidité ou décider que la modification est « trop petite ». Les hooks garantissent l’exécution : chaque opération Edit ou Write déclenche votre outil de formatage, à chaque fois, 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 inclut un champ source indiquant comment la session a commencé : "startup", "resume", "clear" ou "compact". Depuis la v2.1.214, une session initialement créée comme fork indique source: "fork" au lieu de "resume" — l’équivalent, côté hook, de la modification de /fork vers l’arrière-plan introduite par la v2.1.212. Si un hook SessionStart se ramifie selon source (par exemple, en réinjectant le contexte uniquement pour "resume"), mettez à jour sa liste de correspondances afin d’y inclure également "fork".¹⁹⁰ Depuis la v2.1.251, lorsque source vaut "resume" ou "fork" et que la transcription contient au moins une réponse antérieure de Claude, les hooks SessionStart reçoivent également quatre champs relatifs au coût de reprise : seconds_since_last_response, context_tokens (ce que la première requête renvoie comme prompt), prompt_cache_likely_expired (true lorsque la dernière réponse est plus ancienne que la durée de vie du cache de la session ou qu’une compaction ultérieure a remplacé la conversation mise en cache) et estimated_cache_write_usd ; un hook peut ainsi indiquer le coût de la reprise d’une conversation obsolète avant la première requête.²⁰⁶²⁰⁸

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": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/validate-bash.sh"
          }
        ]
      }
    ],
    "UserPromptSubmit": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/inject-context.sh"
          }
        ]
      }
    ]
  }
}