Guide Claude Code CLI : installation, configuration, commandes, 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 via un système en couches de permissions, de hooks, d’intégrations MCP et de subagents. Maîtrisez cinq systèmes clés (configuration, permissions, hooks, MCP et subagents) et vous débloquez une productivité démultipliée. Choisissez le niveau de modèle adapté à chaque tâche — Opus pour le raisonnement complexe, Sonnet pour le travail général, Haiku pour l’exploration rapide — ou standardisez sur Opus si la qualité est votre seule variable. Utilisez les hooks (pas les prompts) pour tout ce qui doit toujours s’exécuter. Depuis la v2.1.174–176 (12 juin 2026), la liste d’autorisation availableModels peut désormais contraindre le modèle Default via le nouveau paramètre géré enforceAvailableModels (les paramètres utilisateur/projet ne peuvent pas élargir une liste géré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 VSCode /usage, ainsi qu’un correctif permettant aux conditions hook if de correspondre aux 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 avec un suffixe [1m] est automatiquement normalisé/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 sub-agents peuvent créer récursivement leurs propres sub-agents, jusqu’à 5 niveaux de profondeur, Bedrock lit sa région depuis ~/.aws quand AWS_REGION n’est pas défini (/status indique la source), /plugin ajoute une barre de recherche 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 au-dessus d’Opus — est sélectionnable dans Claude Code via /model fable après claude update (il prend en charge toute l’échelle d’effort de low à max, mais le thinking ne peut pas être désactivé) ; Opus 4.8 reste le modèle agentique par défaut. Depuis la v2.1.169 (8 juin 2026), --safe-mode (et CLAUDE_CODE_SAFE_MODE) lance une session propre avec toutes les personnalisations désactivées pour le dépannage, /cd déplace une session vers un nouveau répertoire de travail sans casser le cache de prompt, et disableBundledSkills masque au modèle les skills et slash commands intégrées. Depuis la v2.1.166 (6 juin 2026), un paramètre fallbackModel enchaîne jusqu’à trois modèles de secours quand le modèle principal est surchargé, le glob "*" fonctionne dans les règles deny MCP, et MAX_THINKING_TOKENS=0 / --thinking disabled désactivent complètement le thinking sur les modèles think-by-default. Depuis la v2.1.154 (28 mai 2026), Opus 4.8 est le nouveau modèle par défaut avec un effort high par défaut et un niveau /effort xhigh, les dynamic workflows 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 lean system prompt est désormais le comportement par défaut pour tous les modèles sauf Haiku/Sonnet/Opus 4.7 et antérieurs, /simplify est revenu à une revue de nettoyage uniquement (séparée 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 d’outils en streaming est toujours activée, et les serveurs stdio MCP reçoivent CLAUDE_CODE_SESSION_ID plus CLAUDECODE=1 dans l’environnement. La v2.1.153 a ajouté skipLfs aux marketplaces de plugins, fait en sorte que /model soit enregistré comme valeur par défaut (appuyez sur s pour session-only), et placé COLUMNS/LINES dans l’environnement de ligne d’état. La v2.1.152 a introduit /code-review --fix (applique les constats à l’arbre de travail), disallowed-tools dans le frontmatter des skills, /reload-skills, le nouvel événement hook MessageDisplay, les sorties reloadSkills/sessionTitle du hook SessionStart, le paramètre géré pluginSuggestionMarketplaces, le basculement --fallback-model en cours de session, et supprimé l’opt-in auto-mode.^{162 163 164 165 166 167 168 169 170 179 171}

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

La différence entre une utilisation occasionnelle et une utilisation efficace de Claude Code tient à cinq systèmes clés. Maîtrisez-les et Claude Code devient un multiplicateur de force :

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 : gère les tâches complexes en plusieurs étapes

Points clés à retenir

• 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.
• Poussez le travail vers la Delegation Layer : les subagents évitent le gonflement du contexte en isolant l’exploration dans des fenêtres de contexte propres, puis en ne renvoyant que des synthèses.
• Les hooks garantissent l’exécution ; les prompts non : utilisez les hooks pour le linting, le formatage et les contrôles de sécurité qui doivent s’exécuter à chaque fois, quel que soit le comportement du modèle.
• Le découpage par niveau de modèle réduit les coûts sans sacrifier la qualité : orientez l’exploration des subagents vers des modèles moins chers et réservez Opus au véritable raisonnement architectural — ou standardisez sur Opus si la qualité est votre seule variable.
• MCP connecte Claude à votre toolchain : bases de données, GitHub, Sentry et plus de 3 000 intégrations étendent 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 de 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 voulu trouver à mes débuts. Chaque fonctionnalité inclut la syntaxe réelle, de vrais exemples de configuration et les cas limites qui piègent même les utilisateurs expérimentés.

Choisissez votre parcours

Comment utiliser ce guide

C’est une référence de plus de 5 000 lignes — vous n’avez pas besoin de la lire de bout en bout. Commencez là où correspond votre niveau d’expérience :

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

Analyses approfondies liées

Ces articles de blog explorent en profondeur des aspects spécifiques de Claude Code :

Démarrage rapide en 60 secondes

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

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

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

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

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

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

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

Fonctionnement de Claude Code : le modèle mental

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

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

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

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

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

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

Table des matières

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

Comment installer Claude Code ?

Configuration système requise

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

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

apk add libgcc libstdc++ ripgrep
export USE_BUILTIN_RIPGREP=0

Matrice de prise en charge des plateformes

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

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

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

Méthodes d’installation

Installation native (recommandée)

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

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

# Homebrew alternative
brew install --cask claude-code

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

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

Pour une installation d’une version spécifique :

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

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

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

Installation NPM (dépréciée)

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

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

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

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

Migration depuis une installation existante

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

claude install

Options d’authentification

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

Console Claude (facturation API)

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

Abonnement Claude Pro ou Max

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

Plateformes d’entreprise

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

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

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

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

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

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

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

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

Vérification

claude doctor

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

Gestion de l’authentification (v2.1.41+)

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

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

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

claude auth logout && claude auth login

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

Mises à jour

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

Désactiver les mises à jour automatiques :

export DISABLE_AUTOUPDATER=1

Ou dans settings.json :

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

Mise à jour manuelle :

claude update

Désinstallation

Installation native (macOS/Linux/WSL) :

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

Installation native (Windows PowerShell) :

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

Configuration propre (supprime tous les paramètres) :

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

Démarrage rapide : votre première session

1. Installer et lancer :

claude                           # Launch in current directory

2. Naviguer vers un projet :

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

3. Demander à Claude de faire quelque chose :

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

4. Utiliser les raccourcis clés 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. Reprendre plus tard :

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

Astuce d’expert : créez un fichier CLAUDE.md à la racine de votre projet avec les commandes de build, les conventions de code et les notes d’architecture. Claude le lit à chaque session — c’est l’action à plus fort effet de levier que vous puissiez entreprendre pour la qualité.

Modes d’interaction principaux

REPL interactif

Lancez Claude Code sans arguments pour entrer dans la boucle interactive read-eval-print :

cd your-project
claude

Le REPL conserve le contexte de conversation entre les tours. Saisissez vos requêtes directement, recevez des réponses et continuez jusqu’à ce que vous quittiez avec /exit ou Ctrl+D.

Commencez par une invite initiale pour cadrer la session :

claude "explain the authentication flow in this project"

Astuce d’expert : le REPL conserve son état lors des événements de compactage. Lorsque le contexte devient trop volumineux, Claude résume automatiquement les conversations plus anciennes tout en préservant les décisions clés et les extraits de code. Vous pouvez déclencher cela manuellement avec /compact ou ajouter des instructions personnalisées sur ce qu’il faut préserver.

Mode non interactif

Le mode print (-p) exécute une seule requête puis se termine :

# 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 une sortie structurée adaptée au parsing dans des scripts :

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

La sortie JSON inclut tout ce dont vous avez besoin 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 le traitement en temps réel d’une sortie en streaming :

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

Options de format de sortie :

Codes de sortie :

Contrôler le comportement agentique en mode -p :

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

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

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

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

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

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

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

Gestion des sessions

Les sessions conservent l’historique des conversations pour permettre leur reprise. La persistance des sessions est essentielle pour un travail complexe réparti sur plusieurs sessions :

# Continue most recent session
claude -c

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

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

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

Sessions liées aux PR (v2.1.27+, étendu en v2.1.119+) : démarrez une session liée à une pull ou merge request spécifique. Depuis la v2.1.119, --from-pr accepte les URL de MR GitLab, de PR Bitbucket et de PR GitHub Enterprise en plus 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 auto-liées aux PR lorsque vous les créez via gh pr create durant une session. Cela facilite la reprise du travail sur une PR spécifique plus tard. Le badge PR du pied de page peut pointer vers une URL de revue de code personnalisée via le paramètre prUrlTemplate (v2.1.119+) — pratique lorsque votre équipe relie les PR à un outil de revue séparé.¹⁵²

/resume accepte les URL de PR (v2.1.122+). Coller une URL de PR dans le champ de recherche /resume retrouve désormais la session qui a initialement créé cette PR — fonctionne sur github.com, GitHub Enterprise, gitlab.com (et GitLab auto-hébergé) et bitbucket.org.¹⁵⁴

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

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

# Name current session
> /rename auth-refactor

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

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

Note : --session-id requiert un UUID valide (par exemple, 550e8400-e29b-41d4-a716-446655440000). Pour un nommage de session lisible par un humain, utilisez plutôt /rename et --resume.

Claude Code stocke les sessions sous forme de transcripts JSONL. L’exécution d’agent assigne des valeurs agentId uniques avec des transcripts stockés sous agent-{agentId}.jsonl. La reprise préserve le contexte complet des conversations précédentes.

Mode Plan

Le mode plan restreint Claude à de l’exploration en lecture seule — pas d’édition de fichiers, pas d’exécution bash, pas d’actions destructrices. Claude conçoit une approche d’implémentation, l’écrit dans un fichier de plan et attend votre approbation avant d’exécuter quoi que ce soit.

Entrer en 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

Comment cela fonctionne :

1. Claude entre en mode plan (automatiquement pour les tâches complexes, ou via Shift+Tab)
2. Explore la base de code en utilisant des outils en lecture seule : Read, Glob, Grep, WebSearch, WebFetch
3. Écrit un plan dans .claude/plans/{session-slug}.md
4. Sort du mode plan avec ExitPlanMode, présentant le plan pour votre revue
5. Vous approuvez, demandez des modifications ou rejetez

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

Après l’approbation du plan (v2.1.32+) : Claude propose trois options : - « Yes, clear context and auto-accept edits » (Shift+Tab) — démarre à neuf avec un contexte complet pour le plan - « Yes, and manually approve edits » — préserve le contexte, vous approuvez chaque modification - « Yes, auto-accept edits » — préserve le contexte, Claude exécute sans approbation par modification

Le nettoyage automatique du contexte à l’approbation est le workflow recommandé. Il offre au plan une fenêtre de contexte fraîche, ce qui améliore considérablement le respect du plan — Claude reste sur la bonne voie plus longtemps sans interférence d’anciennes conversations.

Quand utiliser le mode plan : - Implémentations de nouvelles fonctionnalités impliquant des décisions architecturales - Refactorings multi-fichiers où vous voulez d’abord revoir l’approche - Bases de code méconnues où l’exploration doit précéder la modification - Toute tâche où plusieurs approches valides existent et où vous voulez donner votre avis

Astuce d’expert : plus vous passez de temps en mode plan, plus Claude a de chances de réussir l’implémentation. Le mode plan est essentiellement de l’exploration sans coût — pas d’appels d’outils risqués, pas de modifications gaspillées. Utilisez-le sans retenue.

Analyse approfondie du système de configuration

Claude Code utilise un système de configuration en couches. Comprendre la hiérarchie est essentiel, car les niveaux supérieurs remplacent les niveaux inférieurs, et les paramètres d’entreprise ne peuvent pas être contournés.

Hiérarchie de configuration

Conseil d’expert : utilisez .claude/settings.local.json pour vos préférences personnelles dans les projets partagés (ajoutez-le à .gitignore). Utilisez .claude/settings.json pour la configuration commune à l’équipe, suivie dans le contrôle de version.

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

Une configuration complète illustrant toutes les options principales :

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

skillOverrides est utile lorsqu’une équipe dispose d’une grande bibliothèque de skills, mais souhaite limiter plus strictement leur exposition à l’exécution. Utilisez off pour masquer une skill à la fois au modèle et au sélecteur slash, user-invocable-only pour la garder appelable par nom tout en la retirant de la sélection par le modèle, et name-only pour ne laisser visible que le nom de la skill, sans sa description complète.¹⁵⁶

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

• availableModels / enforceAvailableModels (managed, v2.1.175+) : l’allowlist availableModels limite les modèles qu’une session peut sélectionner. Avec enforceAvailableModels: true, l’allowlist contraint aussi le modèle Default : un Default qui se résoudrait vers un modèle non autorisé bascule vers le premier modèle autorisé, et les paramètres utilisateur/projet ne peuvent plus élargir une liste availableModels managed. Un correctif associé (v2.1.176) ferme la faille où le choix d’un alias pouvait rediriger vers un modèle bloqué via ANTHROPIC_DEFAULT_*_MODEL, et /fast refuse désormais de basculer vers un modèle hors allowlist.¹⁷²
• language (affinement v2.1.176) : en plus de définir la langue des réponses, les titres de session sont désormais générés par défaut dans la langue de votre conversation ; définissez language pour imposer une langue précise aux titres.¹⁷²
• footerLinksRegexes (v2.1.176) : badges de liens correspondant à des regex dans la ligne de pied de page, configurables via les paramètres utilisateur ou managed.¹⁷²
• wheelScrollAccelerationEnabled (v2.1.174) : définissez sur false pour désactiver l’accélération du défilement à la molette en mode plein écran.¹⁷²

Référence des variables d’environnement

Authentification et API :

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

Configuration des modèles :

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

Configuration des fournisseurs cloud :

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

Contrôle du comportement :

DISABLE_AUTOUPDATER=1                           # Prevent automatic background updates
DISABLE_UPDATES=1                               # Block ALL update paths including manual `claude update` (v2.1.118+, stricter than DISABLE_AUTOUPDATER)[^160]
CLAUDE_CODE_PACKAGE_MANAGER_AUTO_UPDATE=1       # Homebrew/WinGet installs run package-manager upgrade in background, then prompt restart (v2.1.129+)[^164]
DISABLE_TELEMETRY=1                             # Opt out of usage telemetry
DISABLE_ERROR_REPORTING=1                       # Disable Sentry
DISABLE_BUG_COMMAND=1                           # Disable /bug command
DISABLE_COST_WARNINGS=1                         # Hide cost warnings
DISABLE_PROMPT_CACHING=1                        # Disable prompt caching globally
DISABLE_PROMPT_CACHING_SONNET=1                 # Disable for Sonnet only
DISABLE_PROMPT_CACHING_OPUS=1                   # Disable for Opus only
DISABLE_NON_ESSENTIAL_MODEL_CALLS=1             # Skip non-critical API calls
ENABLE_PROMPT_CACHING_1H=1                      # Opt into 1-hour prompt cache TTL (v2.1.108+, API/Bedrock/Vertex/Foundry)
ENABLE_PROMPT_CACHING_1H_BEDROCK=1              # Deprecated alias for the above; v2.1.108+ still honors it on Bedrock but logs a deprecation notice
FORCE_PROMPT_CACHING_5M=1                       # Force 5-minute cache TTL (v2.1.108+)
ENABLE_TOOL_SEARCH=true                         # Re-enable tool search on Vertex AI (disabled by default v2.1.119+ to avoid unsupported beta header). Valid values: true, false, auto, auto:N[^160]
CLAUDE_CODE_HIDE_CWD=1                          # Hide the working directory in the startup logo (v2.1.119+)[^160]
CLAUDE_CODE_FORK_SUBAGENT=1                     # Enable forked subagents on external builds (v2.1.117+)[^160]
CLAUDE_CODE_FORCE_SYNC_OUTPUT=1                 # Force synchronized terminal output when auto-detection misses it, such as Emacs eat (v2.1.129+)[^164]
CLAUDE_CODE_SESSION_ID=...                      # Read-only: present in the Bash tool subprocess; matches the session_id passed to hooks (v2.1.132+)[^168]
CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN=1          # Skip the fullscreen alternate-screen renderer; keep the conversation in the terminal's native scrollback (v2.1.132+)[^168]
CLAUDE_EFFORT=...                               # Read-only: current effort level inside hooks and Bash tool subprocess (v2.1.133+)[^169]

Configuration des tools :

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

UI et terminal :

CLAUDE_CODE_DISABLE_TERMINAL_TITLE=1            # Don't update terminal title
CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL=1             # Skip IDE extension install
CLAUDE_CODE_SHELL=/bin/zsh                      # Override shell detection
USE_BUILTIN_RIPGREP=1                           # Use included ripgrep (default)
CLAUDE_CONFIG_DIR=~/.myconfig                   # Custom config directory
IS_DEMO=1                                       # Hide sensitive UI elements[^37]
CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1          # Disable background tasks and Ctrl+B[^46]
CLAUDE_CODE_TMPDIR=/path/to/tmp                 # Override temp directory[^50]
CLAUDE_CODE_DISABLE_1M_CONTEXT=1               # Disable 1M context window (use standard 200K)[^103]
CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS=120000       # Plugin marketplace git timeout (default 120s, was 30s)[^105]
CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS=1        # Remove built-in commit/PR instructions[^117]
CLAUDE_CODE_DISABLE_CRON=1                    # Stop scheduled cron jobs mid-session[^121]
CLAUDE_CODE_SESSIONEND_HOOKS_TIMEOUT_MS=30000 # SessionEnd hooks timeout (default varies)[^123]
CLAUDE_CODE_USE_POWERSHELL_TOOL=1             # Enable Windows PowerShell tool on Linux/macOS (requires pwsh on PATH; v2.1.111+)[^153]
CLAUDE_CODE_ENABLE_AWAY_SUMMARY=1             # Force Session Recap when telemetry disabled (v2.1.108+)[^153]
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 + 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)
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 de spans LLM-request v2.1.121+ : stop_reason, gen_ai.response.finish_reasons et user_system_prompt sont désormais émis sur les spans LLM-request. user_system_prompt est protégé par OTEL_LOG_USER_PROMPTS=1, car il peut contenir des PII.¹⁵⁴

Changements au niveau des événements v2.1.122+ : les attributs numériques des événements de log api_request et api_error sont désormais émis comme des nombres (auparavant des chaînes), ce qui corrige les collecteurs OTel en aval qui typaient strictement le schéma. Le nouvel événement de log claude_code.at_mention se déclenche lorsque Claude Code résout une mention @.¹⁵⁴

API / Contrôle des modèles :¹⁸⁰

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 / auth :¹⁸⁰

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)

Variables de skill (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=[email protected]        # 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 un impact important sur le coût comme sur la qualité. Claude Code offre un changement de modèle flexible à plusieurs niveaux.

Modèles disponibles

Claude Fable 5 (9 juin 2026) : un nouveau niveau de modèle au-dessus d’Opus — le modèle le plus puissant et le plus intelligent de Anthropic, à l’état de l’art sur presque tous les benchmarks où il a été testé, et conçu pour rester cohérent sur des millions de tokens de contexte. Fable 5 est le modèle frontière de classe « Mythos » rendu sûr pour un usage général : il est livré avec des classificateurs de sécurité qui basculent vers Opus 4.8 sur les requêtes cyber, biochimie et distillation de modèle (Claude Mythos 5 est le même modèle sans ces protections pour les chercheurs autorisés). Il est devenu sélectionnable dans Claude Code avec v2.1.170 (9 juin 2026) — exécutez claude update, puis /model fable (l’alias court ; /model claude-fable-5 et l’alias best le sélectionnent aussi) — et son déploiement vers les offres par abonnement s’étend jusqu’au 22 juin 2026. ID du modèle : claude-fable-5. Fable 5 inclut une fenêtre de contexte 1M par défaut, le suffixe [1m] est donc inutile — et depuis v2.1.173 (11 juin 2026), un nom de modèle claude-fable-5[1m] est automatiquement normalisé/réduit à claude-fable-5 (le suffixe n’a jamais eu de sens que pour Opus/Sonnet, qui réservent le 1M derrière [1m]) ; sortie maximale de 128K. Le prix est de $10/MTok en entrée et $50/MTok en sortie — environ 2× Opus 4.8 — réservez-le donc aux raisonnements vraiment difficiles, pas aux modifications routinières. Il partage la surface de requête d’Opus 4.8 (pensée adaptative uniquement ; temperature/top_p/top_k et budget_tokens supprimés), avec une nouveauté : un thinking: {type: "disabled"} explicite renvoie une 400, donc omettez entièrement le paramètre thinking pour exécuter sans pensée.¹⁷³

Dans Claude Code en particulier : Fable 5 prend en charge toute l’échelle d’effort (low/medium/high/xhigh/max, high par défaut), comme Opus 4.8. La pensée ne peut pas être désactivée sur Fable 5 — le toggle de pensée de session, le paramètre alwaysThinkingEnabled et MAX_THINKING_TOKENS=0 n’ont aucun effet ; il raisonne toujours de façon adaptative. Une surface de configuration complète de la famille fable reflète les réglages Opus : ANTHROPIC_DEFAULT_FABLE_MODEL fixe le modèle vers lequel l’alias fable se résout (utile sur Bedrock/Vertex/Foundry), DISABLE_PROMPT_CACHING_FABLE exclut Fable du prompt caching, et le fallback automatique basé sur le contenu s’applique sur les passerelles enterprise. Opus 4.8 reste la valeur agentique par défaut de Claude Code (effort high par défaut, /effort xhigh pour les tâches les plus difficiles) ; choisissez Fable 5 délibérément via /model fable lorsque vous voulez le plafond absolu.¹⁷³

Opus 4.7 (16 avril 2026) : le modèle phare de génération précédente, toujours pleinement disponible. Fenêtre de contexte de 1M tokens au tarif standard — aucun supplément long contexte. Sortie maximale de 128K, pensée adaptative uniquement (extended thinking supprimé), et un nouveau niveau d’effort xhigh recommandé comme point de départ pour le codage et les workloads agentiques.¹⁴⁵ Date limite fiable des connaissances : janvier 2026. Date limite des données d’entraînement : janvier 2026. ID du modèle : claude-opus-4-7. Le prix correspond à Opus 4.6 à $5/$25 par MTok, avec écriture de cache 5 min à $6.25, écriture de cache 1 h à $10 et lecture de cache à $0.50 par MTok.¹⁴⁴ 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 % pour 4.6) et améliore de 13 % la résolution sur le benchmark interne de codage à 93 tâches de Anthropic.¹⁴⁴ Il utilise un nouveau tokenizer — attendez-vous à des nombres de tokens d’environ 1× à 1,35× pour le même texte ; augmentez la marge de max_tokens et les déclencheurs de compaction.¹⁴⁵ La vision prend en charge les images jusqu’à 2 576 px / 3,75 MP avec coordonnées pixel 1:1.¹⁴⁵

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

Opus 4.7 devance la baseline GPT-5-Codex largement citée de 12,7 points sur SWE-bench Verified, et GPT-5.4 (57,7 %) de 6,6 points sur SWE-bench Pro. Sur Terminal-Bench 2.0, GPT-5.3-Codex reste légèrement devant GPT-5.4 (77,3 % contre 75,1 %) et les deux devancent Opus 4.7 (69,4 %). Le leadership des benchmarks évolue vite ; consultez les pages des fournisseurs avant de vous engager sur un choix pluri-trimestriel.

Modèle par défaut par offre (Claude Code) :¹⁴⁷

Opus 4.7 nécessite Claude Code v2.1.111 ou ultérieure ; exécutez claude update pour mettre à niveau.¹⁴⁷ Bedrock, Vertex et Foundry exposent Opus 4.7 via des noms complets de modèle explicites ou des pins ANTHROPIC_DEFAULT_OPUS_MODEL, pas via l’alias opus par défaut.¹⁴⁷

Breaking changes Messages API dans Opus 4.7 (visibles par l’appelant) :¹⁴⁵

• Extended thinking budget_tokens est supprimé. Utilisez plutôt thinking: {type: "adaptive"}. La pensée adaptative est désactivée par défaut ; les requêtes sans champ thinking s’exécutent sans pensée.
• Définir temperature, top_p ou top_k sur une valeur non par défaut renvoie HTTP 400. Omettez ces paramètres et orientez le modèle par le prompt.
• Le contenu de pensée est omis des réponses par défaut. Définissez thinking.display: "summarized" pour restaurer le raisonnement visible (obligatoire si votre produit diffuse la pensée aux utilisateurs).

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

Opus 4.6 (legacy) : toujours disponible à claude-opus-4-6 avec contexte 1M et sortie maximale de 128K. Envisagez de migrer vers Opus 4.7 pour un meilleur codage agentique. Opus 4.6 a été publié initialement le 5 février 2026.⁷⁹¹⁴⁴ Depuis v2.1.117 (22 avril 2026), les abonnés Pro et Max utilisent par défaut l’effort high sur Opus 4.6 et Sonnet 4.6 (auparavant medium) ; Opus 4.7 reste à xhigh. Ce changement a restauré l’intelligence après la baisse d’effort du 4 mars → 7 avril documentée dans le postmortem du 23 avril.¹⁵²¹⁵³

Sonnet 4.6 (17 février 2026) : modèle équilibré ; a remplacé Sonnet 4.5 comme valeur par défaut sur claude.ai et Claude Cowork.⁹³ Même prix que Sonnet 4.5 ($3/$15 par MTok). Performances de recherche agentique améliorées tout en consommant moins de tokens. Prend en charge extended thinking, pensée adaptative et une fenêtre de contexte de 1M tokens (bêta). Sortie maximale de 64K (borne supérieure de 128K dans v2.1.77).¹¹⁹ Date limite des connaissances : août 2025 (fiable), janvier 2026 (données d’entraînement). ID du modèle : claude-sonnet-4-6.

Claude Mythos Preview (7 avril 2026) : modèle frontière en research preview pour le travail de cybersécurité défensive, proposé dans le cadre de Project Glasswing.¹³⁹ Sur invitation uniquement ; pas disponible au grand public. Anthropic présente Opus 4.7 comme délibérément moins capable que Mythos sur les dimensions cyber — un compromis de sécurité — et a ouvert un Cyber Verification Program à https://claude.com/form/cyber-use-case pour les chercheurs en sécurité légitimes ayant besoin d’un accès élevé.¹⁴⁶

Pourquoi ces différences de prix comptent : une session de codage typique consomme 50K à 200K tokens d’entrée et 10K à 50K tokens de sortie. Avec Haiku, cela représente $0.10 à $0.45 par session. Avec Opus, la même session coûte $0.50 à $2.25, soit 5x plus. Réservez Opus aux problèmes réellement difficiles.¹

Quand utiliser chaque modèle

Haiku : utilisez-le pour les subagents qui font de l’exploration, des recherches simples dans les fichiers ou répondent à des questions rapides. Il coûte environ 5x moins cher qu’Opus et répond plus vite. Parfait pour les tâches d’arrière-plan qui ne demandent pas de raisonnement profond.

Sonnet : le modèle de référence pour le développement quotidien lorsque le coût compte. Il gère la plupart des tâches de codage : implémenter des fonctionnalités, corriger des bugs, écrire des tests, faire de la code review. Sonnet 4.6 offre une recherche agentique améliorée et une meilleure efficacité en tokens par rapport à Sonnet 4.5, avec prise en charge de la pensée adaptative et une fenêtre de contexte 1M au tarif standard.⁹³ Depuis Opus 4.7 (16 avril 2026), Claude Code ne passe par défaut à Opus que sur les offres Max et Team Premium ; les comptes Pro, Team Standard, Enterprise et API gardent Sonnet 4.6 comme valeur par défaut jusqu’au passage d’Enterprise et API à Opus 4.7 le 23 avril 2026.¹⁴⁷ Utilisez Sonnet lorsque vous avez besoin de tokens moins chers, d’une latence plus faible ou d’une économie favorable pour les subagents.

Opus : le niveau phare depuis le 16 avril 2026, et le modèle par défaut sur les offres Max et Team Premium.¹⁴⁴¹⁴⁷ Réservez ce raisonnement plus coûteux aux cas où il apporte vraiment de la valeur : décisions d’architecture, debugging délicat, compréhension de systèmes complexes, analyse de sécurité, travail agentique à long horizon. 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 % la résolution sur un benchmark interne de codage à 93 tâches.¹⁴⁴ Claude Code utilise par défaut l’effort xhigh sur Opus 4.7, réglable via /effort (v2.1.111+).¹⁴⁶¹⁴⁷ Auto Mode est disponible pour les abonnés Max sur Opus 4.7 via le Anthropic API sans nécessiter --enable-auto-mode ; les autres offres/fournisseurs ont une disponibilité propre à l’offre et contrôlée par les administrateurs.¹⁴⁶ Contexte 1M au tarif standard — aucun supplément long contexte. Changements de comportement à connaître : Opus 4.7 suit les instructions plus littéralement, calibre la longueur des réponses sur la complexité de la tâche, lance moins de subagents par défaut et adopte un ton plus direct, avec moins de formulations centrées sur la validation. Si vos prompts contiennent un échafaudage pour forcer des messages de progression intermédiaires ou un comportement de double vérification, essayez de le retirer.¹⁴⁵

Opusplan : mode hybride qui utilise Opus pour la planification (là où la qualité du raisonnement compte le plus) et Sonnet pour l’exécution (là où la vitesse compte). Excellent pour les refactorings complexes où vous voulez le meilleur plan sans avoir besoin d’un raisonnement de niveau Opus pour chaque modification individuelle.

Changer de modèle

Pendant une session :

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

Au démarrage :

claude --model opus

Via l’environnement :

export ANTHROPIC_MODEL=opus

Dans settings.json :

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

Spécifiquement pour les subagents :

export CLAUDE_CODE_SUBAGENT_MODEL=haiku

Chaîne de fallback model (v2.1.166+) : le paramètre fallbackModel configure jusqu’à trois modèles de fallback, essayés dans l’ordre, lorsque le modèle principal est surchargé ou indisponible. Le flag --fallback-model (auparavant uniquement un changement en cours de session) s’applique désormais aussi aux sessions interactives dès le démarrage.¹⁷⁵

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

Lorsque le API renvoie une erreur inattendue non réessayable, Claude Code réessaie désormais aussi le tour une fois sur le modèle de fallback avant d’afficher l’échec, de sorte qu’un problème transitoire du modèle principal se dégrade proprement au lieu de perdre le tour.¹⁷⁵

Contexte étendu

Pour les grands codebases 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 sein 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 — aucun supplément long contexte.¹⁴⁸ 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 de prompt caching et de batch processing s’appliquent aux tarifs standard sur toute la fenêtre de contexte.

Sur les abonnements Max, Team et Enterprise, Opus avec contexte 1M est inclus automatiquement — aucun suffixe [1m] nécessaire (activé par défaut depuis v2.1.75, 13 mars 2026).¹¹⁷¹⁴⁷ Sur Pro, le contexte 1M est accessible via extra usage. Les utilisateurs API et pay-as-you-go disposent d’un accès complet au 1M aux tarifs standard par token.¹⁴⁷

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

Vérifier le modèle actuel

> /status

La commande affiche le modèle actuel, les informations du compte, les paramètres appliqués et d’autres états de session.

Libellés du sélecteur de modèle (v2.1.51+) : le sélecteur /model affiche désormais des libellés lisibles par un humain (par exemple, « Sonnet 4.6 ») au lieu des ID de modèles bruts pour les versions épinglées, avec des indices de mise à niveau lorsque des versions plus récentes sont disponibles.⁹⁸

Fast Mode (v2.1.36+)

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

> /fast            # Toggle fast mode on/off

Tarifs (fast mode Opus 4.6) :

Fast mode est en research preview, uniquement sur Opus 4.6, et fournit une sortie environ 2,5× plus rapide à 6× le tarif de base.¹⁴⁹ Activer /fast fait automatiquement passer la session à Opus 4.6 si vous étiez sur un autre modèle ; désactiver /fast vous laisse sur Opus 4.6 jusqu’à ce que vous changiez via /model. Fast mode n’est pas disponible sur Opus 4.7, Sonnet, Haiku, ni via Bedrock/Vertex/Foundry. Il nécessite l’activation d’extra usage et, pour Team/Enterprise, une activation par l’administrateur.

Quand utiliser fast mode : - Itérer rapidement sur de petites modifications lorsque la latence est le goulot d’étranglement - Générer des tests, du boilerplate ou du code répétitif lorsque la vitesse compte plus que le coût - Parcourir séquentiellement une liste de tâches similaires

Quand NE PAS utiliser fast mode : - Tâches agentiques de longue durée (le coût monte vite à 6x les tarifs) - Travail de subagent en arrière-plan (personne n’attend la sortie) - Sessions sensibles au budget

Fast mode Opus 4.6 inclut la fenêtre de contexte complète de 1M (v2.1.50+). Le prix du fast mode est fixe sur tout le contexte 1M — aucun supplément long contexte supplémentaire.⁹⁶¹⁴⁹

Conseil expert : Fast mode ne s’associe pas à opusplan (opusplan mélange déjà Opus et Sonnet ; fast mode n’affecte qu’Opus 4.6). Utilisez fast mode directement lorsque la latence compte plus que le coût, et désactivez-le pour le travail autonome ou par lots. /fast nécessite extra usage ; les administrateurs Team/Enterprise peuvent devoir l’activer d’abord (correctif v2.1.37).⁸⁶¹⁴⁹

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

Opus 4.7 introduit un nouveau cadran d’effort qui ajuste le compromis vitesse/intelligence. Utilisez /effort pendant une session :

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

Claude Code utilise désormais par défaut l’effort xhigh pour Opus 4.7. xhigh est propre à Opus 4.7 — les autres modèles retombent sur high. Claude Managed Agents gère l’effort automatiquement ; le paramètre d’effort est un concept Messages API.¹⁴⁵¹⁴⁶

Auto Mode sur Max (v2.1.111+)

Auto Mode — un remplacement plus sûr de --dangerously-skip-permissions — est disponible pour les abonnés Max sur Opus 4.7 via le Anthropic API sans --enable-auto-mode.¹⁴⁶ Un classificateur Sonnet 4.6 examine chaque action avant exécution, en vérifiant la correspondance avec l’intention et la sécurité. Note (v2.1.111+) : le flag --enable-auto-mode a été supprimé ; démarrez une session en Auto Mode avec --permission-mode auto à la place. Auto Mode n’est pas disponible sur Pro ; selon les docs des modes de permission de Anthropic, il est direct sur le Anthropic API par défaut. Bedrock/Vertex/Foundry (v2.1.158+) : Auto Mode est désormais opt-in sur Opus 4.7 et Opus 4.8 sur ces passerelles avec CLAUDE_CODE_ENABLE_AUTO_MODE=1.¹⁷⁸

Règles personnalisées sans perdre les valeurs par défaut (v2.1.118+). Les versions précédentes rendaient autoMode.allow, autoMode.soft_deny et autoMode.environment exclusifs : définissez votre propre liste et vous perdez les règles de sécurité intégrées. Le sentinel $defaults résout cela — il se développe inline en liste intégrée exactement à l’endroit où vous le placez, ce qui vous permet de superposer des règles personnalisées autour d’elles :¹⁵²

// .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
    ]
  }
}

Opt-in « Don’t ask again » (v2.1.118+). Le prompt d’opt-in d’Auto Mode propose désormais une option « Don’t ask again », afin que les utilisateurs fréquents puissent masquer l’explication sans scripter de flag.¹⁵²

Nouvelles commandes dans v2.1.105–v2.1.114¹⁴⁶¹⁵⁰

Session Recap (v2.1.108+)

Une nouvelle fonctionnalité au niveau de la session qui affiche le contexte lorsque vous revenez à une session en pause. Activée par défaut et désactivable via /config ou CLAUDE_CODE_ENABLE_AWAY_SUMMARY=0. Le modèle peut aussi invoquer des slash commands intégrées (/init, /review, /security-review) via l’outil Skill — cela étend le motif subagent/skill.¹⁴⁶

Notifications push (v2.1.110+)

Lorsque Remote Control est configuré avec « Push when Claude decides » activé, Claude peut désormais envoyer des notifications push mobiles à sa discrétion via un nouvel outil de notification push. Fonctionne avec la surface mobile/web Remote Control existante.¹⁴⁶ /context, /exit et /reload-plugins fonctionnent désormais aussi depuis les clients Remote Control.

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

Claude Code déploie un outil Windows PowerShell natif. Sur Linux/macOS, activez-le avec CLAUDE_CODE_USE_POWERSHELL_TOOL=1 (nécessite pwsh sur le PATH). Sur Windows, la même variable contrôle l’opt-in/opt-out pendant le déploiement.¹⁴⁶

Approbation automatique en permission-mode (v2.1.119+). Les commandes de l’outil PowerShell peuvent désormais recevoir une approbation automatique en permission mode, de la même manière que les commandes Bash. Les règles d’autorisation comme PowerShell(Get-*:*) et la syntaxe de motifs existante contournent désormais le prompt pour les opérations read-only, avec une ergonomie opérateur alignée sur celle dont les équipes disposent déjà sur Linux/macOS.¹⁵²

Réduction des permissions : Bash read-only (v2.1.111+)

Les motifs Bash read-only avec arguments glob (par exemple ls *.ts, cat src/*.md) et les commandes commençant par cd <project-dir> && ne déclenchent plus de prompt de permission.¹⁴⁶ Combiné à /less-permission-prompts, cela devrait réduire fortement les interruptions dans les workflows quotidiens.

Distributed Tracing (v2.1.110+)

Les sessions SDK et headless lisent désormais TRACEPARENT et TRACESTATE depuis l’environnement, reliant les exécutions Claude Code aux traces distribuées. Associez cela à OTEL_LOG_RAW_API_BODIES=1 (v2.1.111+) pour émettre les corps complets de requête/réponse API sous forme d’événements de log OpenTelemetry pour le debugging.¹⁴⁶

Distribution binaire native (v2.1.113+)¹⁵⁰

v2.1.113 change la manière dont le CLI se lance : claude démarre désormais un binaire Claude Code natif via une dépendance optionnelle propre à chaque plateforme, au lieu d’exécuter le JavaScript empaqueté. Les commandes d’installation et de mise à jour restent identiques, et les équipes n’ont pas besoin de changer leurs scripts de déploiement.

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

L’éditeur de prompt gagne une navigation façon readline dans la saisie multiligne, ainsi que le défilement du viewport en plein écran :

Ils sont activés par défaut. Aucune configuration de raccourcis clavier requise.

Timeout de blocage des subagents (v2.1.113+)¹⁵⁰

Les subagents qui se bloquent en plein flux échouent désormais avec une erreur claire après 10 minutes au lieu de rester suspendus silencieusement. Associez cela à CLAUDE_STREAM_IDLE_TIMEOUT_MS (v2.1.84+) pour une couverture plus large des processus bloqués sur les API en streaming.

Correctif de stabilité v2.1.114¹⁵⁰

v2.1.114 (18 avril 2026) apporte un seul correctif : la boîte de dialogue de permission pouvait planter lorsqu’un coéquipier agent-teams demandait une permission d’outil. Mettez à niveau si vous utilisez Agent Teams.

Combien coûte Claude Code ?

Comprendre et maîtriser les coûts est essentiel pour une utilisation durable de Claude Code. Consultez aussi Sélection du modèle pour les capacités des modèles et Cadres de décision pour choisir le bon modèle selon la tâche.

Consulter les 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 avec abonnement voient une ventilation par modèle et par cache-hit dans /cost, indiquant exactement quels modèles ont consommé des tokens et quelle proportion a été servie depuis le cache (v2.1.92+).¹³⁷

Plans d’abonnement

Limites de débit (août 2025) : Anthropic a introduit 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 de débit aux tarifs API standard.¹⁴

Doublement des limites de débit (6 mai 2026) : Lors de l’événement Code with Claude SF, Anthropic a doublé les limites de débit Claude Code sur cinq heures pour les plans Pro, Max, Team et Enterprise basés sur les sièges, supprimé la réduction en heures de pointe sur les comptes Pro et Max, et augmenté « considérablement » les limites de débit API pour les modèles Claude Opus. Le filet de sécurité de capacité est l’accord SpaceX Colossus 1 : « plus de 300 mégawatts de nouvelle capacité (plus de 220 000 NVIDIA GPUs) dans le mois ».¹⁵⁷

Tarification API par token (avril 2026)¹¹⁴⁴

Pour les utilisateurs facturés via API, tarification par million de tokens :

Tarification du contexte 1M (avril 2026) : Opus 4.7, Opus 4.6, Sonnet 4.6 et Mythos Preview incluent tous le 1M aux tarifs par MTok standard — sans surcoût pour contexte long.¹⁴⁸ Il s’agit d’une consolidation récente ; les anciennes recommandations selon lesquelles Opus 4.6 ou Sonnet 4.6 facturaient 2× l’entrée / 1,5× la 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 de la résidence des données : Spécifier une inférence aux États-Unis uniquement via inference_geo ajoute un multiplicateur de 1,1× sur tous les tarifs de tokens, y compris les lectures et écritures de cache (modèles Opus 4.6+).¹⁴⁸

Le prompt caching réduit considérablement les coûts d’entrée répétés : les écritures de cache coûtent 1,25× le tarif de base (cache 5 min) ou 2× (cache 1 h), mais les lectures de cache ne coûtent que 0,1×, soit une économie de 90 %. Pour les systèmes RAG et les assistants de code avec contexte répété, le caching peut réduire les coûts de 88 à 95 %.

Batch API offre 50 % de réduction avec un délai de 24 heures pour les tâches non urgentes comme les suites de tests nocturnes.

Politique des comptes multiples⁵²

Pouvez-vous avoir plusieurs comptes Claude ? Oui, pour des cas d’usage légitimes. Anthropic autorise explicitement plusieurs comptes lorsqu’ils servent 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 depuis la même IP/le même réseau sont explicitement pris en charge - Les comptes sont totalement séparés ; aucun transfert de chat ou de projet entre eux

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

Note du monde réel : En janvier 2026, l’utilisateur expérimenté Jeffrey Emanuel (@doodlestein) a vu 22 comptes Max automatiquement signalés et temporairement bannis. Thariq (@trq212), employé d’Anthropic, a résolu la situation en 4 heures après avoir confirmé un usage légitime. Si vous utilisez intensivement Claude Code pour des projets professionnels et personnels via plusieurs comptes, c’est exactement l’usage prévu, mais n’essayez pas de jouer avec le système.

En cas de doute : Contactez le Support Anthropic pour confirmer votre configuration spécifique par écrit.

Facteurs de coût

Exemples de coûts réels

Astuce d’économie : Utiliser Haiku pour les sous-agents d’exploration et Sonnet pour l’implémentation réduit généralement les coûts de 40 à 50 % par rapport à l’utilisation de Sonnet pour tout.

Gestion des coûts en équipe

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

Frais d’outils cachés

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

Ces frais s’accumulent dans les boucles d’agent. Un cycle de débogage de 100 itérations avec Bash coûte ~24 500 tokens d’entrée supplémentaires uniquement en surcharge.

Stratégies d’économie

1. Utiliser Haiku pour les sous-agents : la plupart des explorations n’ont pas besoin de Sonnet
2. Activer le prompt caching : par défaut, mais vérifiez qu’il n’est pas désactivé
3. Définir un nombre maximal de tours : claude --max-turns 5 empêche les conversations qui s’emballent
4. Utiliser le mode plan pour explorer : pas d’exécution = pas d’opérations coûteuses accidentelles
5. Compacter de manière proactive : contexte plus petit = moins de tokens
6. Limiter la sortie : export CLAUDE_CODE_MAX_OUTPUT_TOKENS=2000
7. Batch API pour le travail non urgent : 50 % de réduction sur les tokens d’entrée et de sortie

Suivi de l’utilisation

• Console Claude : platform.claude.com (nécessite le rôle Admin ou Billing)
• Limites par espace de travail : définissez des plafonds de dépenses par espace de travail
• Bedrock/Vertex : utilisez la surveillance native des coûts cloud
• LiteLLM : pour un suivi détaillé par utilisateur avec des fournisseurs tiers

Utilisation de tokens en arrière-plan

Certaines opérations consomment des tokens en arrière-plan : - La synthèse de conversation pour /resume - Les commandes /cost et /status - L’auto-compactage

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

Claude Code Analytics API (Team/Enterprise)⁴⁶

Accédez programmatiquement aux analyses d’utilisation et aux indicateurs de productivité Claude Code de votre organisation via l’Admin API.

Endpoint : GET /v1/organizations/usage_report/claude_code

Prérequis : - Clé Admin API (sk-ant-admin...) - Plan 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/rejet pour Edit, Write, etc.) - Suivi et répartition des coûts entre équipes - Justification du ROI pour les outils de codage IA

Note : Les données apparaissent dans l’heure suivant la fin de l’activité. Seules les données antérieures à 1 heure sont incluses dans les réponses pour assurer la cohérence.

Cadres de décision

Savoir que des fonctionnalités existent ne suffit pas. Vous devez savoir quand utiliser chacune d’elles. Ces arbres de décision transforment la connaissance en action.

Quel modèle dois-je utiliser ?

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

Règle générale : Opus 4.7 est le modèle par défaut pour Max et Team Premium. Sur Pro/Team Standard/Enterprise/API, Sonnet 4.6 est le modèle par défaut (Enterprise + Anthropic API basculent vers Opus 4.7 le 23 avril 2026).¹⁴⁷ Passez à 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 le raisonnement étendu ?

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

Basculez avec Alt+T pendant la session. Des budgets de raisonnement plus élevés coûtent plus cher ; commencez par le minimum et n’augmentez que si les réponses semblent précipitées.

Raisonnement adaptatif d’Opus 4.6 : Opus 4.6 ajuste automatiquement la profondeur de raisonnement selon la complexité du problème. Pour la plupart des tâches, le contrôle explicite du budget de raisonnement n’est pas nécessaire — Opus monte en puissance pour les problèmes difficiles et reste rapide pour les simples. Le basculement manuel du raisonnement est surtout utile avec Sonnet lorsque vous voulez forcer une analyse plus approfondie.

Quelle surface d’exécution ?

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

Équipes d’agents, Subagents ou Sessions parallèles

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

Quel type de hook ?

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

Quand utiliser /fast ?

Is response speed more important than depth right now?
│
├── YES → Use /fast
│         Same Opus 4.6 model, faster output
│         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 le mode rapide pour la session en cours. Il utilise le même modèle (Opus 4.6) avec une vitesse de sortie optimisée — il ne bascule PAS vers un modèle moins cher.

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 s’exécuter. Le comprendre est essentiel à la fois pour la sécurité et l’efficacité du workflow. Consultez aussi Déploiement Enterprise pour les paramètres gérés qui imposent les autorisations à l’échelle de toute l’organisation.

Niveaux d’autorisations

Outils en lecture seule (approuvés automatiquement) : - Read - Lire le contenu des fichiers - Glob - Trouver des fichiers par motif - Grep - Rechercher dans le contenu des fichiers - WebSearch - Rechercher sur le web - LSP - Intelligence de code (aller à la définition, trouver les références, documentation au survol)¹⁸

Capacités de l’outil LSP (v2.0.74+) : l’outil LSP fournit une intelligence de code comparable à celle d’un IDE : - Aller à la définition : accéder à l’endroit où un symbole est défini - Trouver les références : lister toutes les utilisations d’un symbole dans toute la codebase - 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 avec prise en charge LSP - Nécessite que le serveur de langage soit disponible (généralement installé avec votre toolchain)

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’une URL - NotebookEdit - Modifier des notebooks Jupyter

La première fois qu’un outil de modification s’exécute, Claude Code demande une approbation. Les approbations persistent pendant la session, sauf configuration explicite contraire.

Modes d’autorisation

Les fichiers de configuration permettant l’exécution de code déclenchent désormais une demande de confirmation même sous acceptEdits (v2.1.160). acceptEdits approuve automatiquement les modifications ordinaires, mais depuis la v2.1.160, il s’arrête et demande confirmation avant d’écrire dans des fichiers pouvant accorder une 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 similaires). La raison est qu’une modification de l’un de ces fichiers transforme le prochain shell, install ou commit en vecteur d’exécution : ils reçoivent donc une barrière explicite, même dans un mode de projet de confiance qui laisse autrement passer les modifications. C’est le même modèle de menace que les protections d’écriture existantes pour .claude/, .git/ et .vscode/, étendu à la catégorie plus large des fichiers « modification-devenant-exécution ».¹⁷⁷

Auto Mode (v2.1.85+) : un remplacement plus sûr de --dangerously-skip-permissions. Un modèle classificateur distinct (Sonnet 4.6) vérifie chaque action avant exécution, en contrôlant 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 dossier de travail sont approuvées automatiquement - Les règles personnalisées d’autorisation/refus sont résolues en premier - Tout le reste est transmis au classificateur pour évaluation - En cas de blocage, Claude essaie automatiquement une autre approche

Bloqué automatiquement par défaut : curl | bash, force-push vers main, déploiements/migrations de production, suppressions cloud massives, modifications IAM/d’autorisations, envoi externe de données sensibles.¹²⁵

Coupe-circuit : 3 blocages consécutifs ou 20 au total dans une session font revenir aux demandes de confirmation manuelles.¹²⁵

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

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

Disponibilité : utilisateurs du plan Team d’abord, puis Enterprise et API. Nécessite Sonnet 4.6 ou Opus 4.6.¹²⁴

Mode YOLO (v2.0.68+) : pour une opération entièrement autonome sans aucun classificateur de sécurité, utilisez le flag --dangerously-skip-permissions. Le flag dit oui à tout : modifications de fichiers, commandes bash, tous les appels d’outils. Le mot « dangerous » est intentionnel. Auto Mode est l’alternative recommandée pour la plupart des cas d’usage.⁵⁴

claude --dangerously-skip-permissions

Définir le mode via CLI :

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

Basculer pendant la session :

Shift+Tab  # Cycles through modes

Dans settings.json :

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

Syntaxe des règles d’autorisation

Des règles précises contrôlent les opérations spécifiques. Les règles 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 fournit une correspondance par préfixe : Bash(npm run test:*) autorise npm run test, npm run test:unit et npm run test:integration.

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

Motifs d’opérations sur les fichiers :

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

Syntaxe des chemins : - Chemins relatifs : Edit(src/**) - relatifs au dossier de travail - Absolu depuis le fichier de paramètres : Edit(/build/**) - relatif à l’emplacement du fichier de paramètres - Véritable absolu : Edit(//tmp/**) - commence par // - Dossier personnel : Read(~/.zshrc)

Motifs d’outils MCP :

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

Utilisez la syntaxe wildcard mcp__server__* pour autoriser ou refuser tous les outils d’un serveur MCP spécifique.³² La syntaxe wildcard est utile pour activer rapidement tous les outils de serveurs de confiance ou bloquer des serveurs entiers issus de sources non fiables.

Depuis la v2.1.166, les règles de refus acceptent aussi un glob à l’emplacement du nom d’outil : un simple "*" dans l’emplacement du nom d’outil refuse tous les outils, ce qui vous permet de tout bloquer puis de réautoriser un ensemble restreint. Les règles d’autorisation, en revanche, rejettent les globs non-MCP : vous ne pouvez pas autoriser largement tout de la même manière, ce qui maintient une posture restrictive par défaut.¹⁷⁵

Motifs WebFetch :

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

Dossiers supplémentaires

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

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

Les dossiers supplémentaires sont essentiels pour les monorepos ou lorsque Claude doit référencer du code dans des dossiers voisins.

Mode sandbox

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

> /sandbox

Ou 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"]
    }
  }
}

En sandbox : - Accès au système de fichiers limité au dossier du projet - Accès réseau contrôlé - Certaines commandes exclues des restrictions du sandbox - Commandes Bash autorisées automatiquement si autoAllowBashIfSandboxed vaut true

Conseil d’expert : le mode sandbox est excellent pour exécuter Claude sur des codebases non fiables. Activez-le lorsque vous explorez des projets inconnus ou lorsque vous voulez une couche de protection supplémentaire. Les tests internes de Anthropic ont montré que le sandboxing réduit les demandes d’autorisation de 84 %.³⁸ Le sandbox utilise des primitives au niveau de l’OS (macOS seatbelt, Linux bubblewrap) pour isoler le système de fichiers et le réseau ; ainsi, même une injection de prompt réussie reste entièrement contenue. Anthropic a publié en open source le runtime sandbox pour les équipes qui construisent leurs propres agents.⁸²

Notes de sécurité (v2.1.34+) : les commandes exclues du sandboxing via sandbox.excludedCommands ou dangerouslyDisableSandbox pouvaient auparavant contourner la règle d’autorisation Bash lorsque autoAllowBashIfSandboxed était activé ; cela a été corrigé en v2.1.34.⁸⁷ Depuis la v2.1.38, les écritures dans .claude/skills sont bloquées en mode sandbox, empêchant l’injection de prompt de modifier les définitions de skills.⁸⁸ v2.1.77 ajoute un paramètre de système de fichiers sandbox allowRead pour réautoriser l’accès en lecture à l’intérieur de régions denyRead, utile lorsque vous voulez bloquer la majeure partie d’une arborescence de dossiers tout en plaçant certains sous-dossiers en liste blanche.¹¹⁹

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

Chemins bubblewrap et socat personnalisés (v2.1.133+) : les paramètres gérés sandbox.bwrapPath et sandbox.socatPath permettent aux admins d’orienter les déploiements Linux/WSL vers des emplacements non standard des binaires bubblewrap et socat. Utile lorsque les distributions installent ces outils en dehors de $PATH ou lorsque l’organisation fournit des builds renforcés.¹⁶⁰

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

• sandbox.network.deniedDomains bloque des hôtes spécifiques même lorsqu’un wildcard allowedDomains plus large les autoriserait autrement. Utilisez la blocklist pour couper l’accès à des pastebins, des dépôts de fichiers ou des hôtes connus comme malveillants sans réécrire toute votre politique d’autorisation.
• Règles de refus pour commandes wrapper. Les règles de refus Bash correspondent désormais aux commandes enveloppées dans env, sudo, watch, ionice, setsid et des wrappers d’exécution similaires. Des règles comme Bash(rm:*) interceptent maintenant env rm -rf, sudo rm -rf et les motifs de contournement voisins.
• Les règles d’autorisation Bash(find:*) n’approuvent plus automatiquement find -exec ni find -delete. Ces flags exécutent des commandes et suppriment des fichiers ; Claude Code les fait donc passer par le chemin d’autorisation normal.
• Protection contre les suppressions sur macOS. Les règles d’autorisation Bash(rm:*) traitent désormais /private/etc, /private/var, /private/tmp et /private/home comme des cibles de suppression dangereuses. /var, /etc et /tmp sont des symlinks vers /private/, si bien que la forme précédente de la règle manquait les cibles canoniques.

Comment fonctionnent les hooks ?

Les hooks exécutent des commandes shell déterministes à des points précis du workflow de Claude Code. Contrairement au fait de demander à Claude d’effectuer des actions, les hooks garantissent l’exécution, quel que soit le comportement du modèle. Ils sont essentiels pour appliquer les standards d’équipe et automatiser les tâches répétitives. Consultez Cadres de décision pour l’arbre de décision « Quel type de hook ? » couvrant les hooks de commande, de prompt et d’agent.

Pourquoi utiliser des hooks plutôt que des prompts : dire à Claude « exécute toujours Prettier après avoir modifié des fichiers » fonctionne parfois. Mais Claude peut oublier, privilégier la vitesse ou décider que le changement est « trop petit ». Les hooks garantissent l’exécution : chaque Edit ou Write déclenche votre formateur, à chaque fois, sans exception. Pour la conformité, la sécurité et les standards d’équipe, le déterministe l’emporte sur le probabiliste.⁴

Événements disponibles

Configuration des hooks

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

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

Matchers

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

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

Protocole d’entrée/sortie des hooks

Les hooks reçoivent du JSON sur stdin :

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

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

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

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

Retour souple sans blocage (v2.1.163+) : les hooks Stop et SubagentStop peuvent renvoyer hookSpecificOutput.additionalContext dans leur sortie JSON pour transmettre un retour à Claude et poursuivre le tour, sans que la réponse soit étiquetée comme une erreur de hook. Auparavant, le seul vrai levier d’un hook Stop était le blocage exit-2 (qui est lu comme une erreur et compte dans le plafond de blocages consécutifs) ; additionalContext ajoute un canal de pilotage pour des consignes du type « voici ce que vous avez manqué, continuez », sans entrer en conflit avec la boucle.¹⁷⁶

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

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

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

Contrôle de décision PreToolUse (format recommandé) : les hooks PreToolUse utilisent hookSpecificOutput pour un contrôle plus riche : trois issues (allow/deny/ask), plus la possibilité de modifier l’entrée de l’outil et d’injecter du contexte :⁸⁹

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

Remarque : les champs de premier niveau decision et reason sont dépréciés pour PreToolUse. Utilisez plutôt hookSpecificOutput.permissionDecision et hookSpecificOutput.permissionDecisionReason. Les autres événements (PostToolUse, Stop, etc.) utilisent toujours decision au premier niveau.⁸⁹

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

Hooks async (janvier 2026)

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

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

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

Quand NE PAS utiliser les hooks async : - Formatage (doit se terminer avant la prochaine modification) - Validation (doit bloquer en cas d’échec) - Tout hook qui doit modifier l’entrée/la sortie d’un outil

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

Au-delà des hooks de commande shell (type: "command"), Claude Code prend en charge deux types de hooks alimentés par LLM qui évaluent les conditions avec un raisonnement IA plutôt que des scripts.⁸⁹

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

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

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

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

Les hooks HTTP utilisent le même format de décision que les hooks de commande (renvoyer du JSON avec decision et reason). Ils passent par le proxy réseau du sandbox lorsque le sandboxing est activé. Non pris en charge pour les événements SessionStart/Setup.

Les hooks d’agent (type: "agent") lancent un subagent avec accès aux outils (Read, Grep, Glob) pour une vérification multi-tour. Utilisez-les lorsque la vérification exige d’inspecter de vrais fichiers ou des sorties de test :

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

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

Hooks d’outil MCP (v2.1.118+)

Les hooks peuvent désormais invoquer directement un outil MCP via type: "mcp_tool", ce qui évite d’envelopper un sous-processus Bash appelant le serveur.¹⁵²

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

Cela fonctionne bien avec les serveurs MCP que les utilisateurs ont déjà configurés : tout outil accessible depuis /mcp peut être appelé par un hook.

duration_ms dans les hooks PostToolUse (v2.1.119+)

Les entrées des hooks PostToolUse et PostToolUseFailure incluent désormais duration_ms, le temps d’exécution de l’outil hors prompts d’autorisation et hooks PreToolUse.¹⁵² Utile pour détecter les outils lents, les journaux d’audit et les métriques de latence par outil :

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

updatedToolOutput pour tous les outils (v2.1.121+)

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

Variables d’environnement des hooks

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

Persister les variables d’environnement depuis SessionStart :

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

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

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

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

Exemples pratiques de hooks

Formater automatiquement les fichiers TypeScript après modification :

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

Journaliser toutes les commandes bash :

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

Bloquer l’accès aux fichiers sensibles :

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

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

Exécuter les tests après les changements de code :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c '[[ \"$FILE_PATH\" == *.test.ts ]] || npm run test:affected'"
          }
        ]
      }
    ]
  }
}

Système de notification personnalisé :

{
  "hooks": {
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "notify-send 'Claude Code' 'Waiting for your input'"
          }
        ]
      }
    ]
  }
}

Injecter du contexte dynamique dans les prompts :

#!/bin/bash
# .claude/hooks/inject-context.sh
# Add current git branch and recent commits to every prompt

branch=$(git branch --show-current 2>/dev/null)
commits=$(git log --oneline -3 2>/dev/null | tr '\n' ' ')

if [ -n "$branch" ]; then
  echo "[Context: Branch '$branch', Recent: $commits]"
fi
exit 0

Débogage des hooks

Activez le mode debug pour résoudre les problèmes liés aux hooks :

claude --debug

Le mode debug journalise : - Temps d’exécution des hooks - Données d’entrée/sortie - Messages d’erreur et stack traces - Résultats de décision (allow/reject/ask)

Affichage de la source du hook (v2.1.75+) : lorsqu’un hook exige une confirmation utilisateur, le prompt d’autorisation affiche désormais la source du hook (settings, plugin ou skill), ce qui facilite l’identification du composant demandant l’accès.¹¹⁷

Hooks limités à un composant (v2.1.0+)

Les hooks peuvent être définis directement dans les Skills, subagents et commandes slash à l’aide du frontmatter. Ces hooks sont limités au cycle de vie du composant et ne s’exécutent que lorsque ce composant est actif.³⁴

Skill avec hooks intégrés :

---
name: secure-deployment
description: Deployment skill with security validation
hooks:
  PreToolUse:
    - matcher: Bash
      command: ".claude/hooks/validate-deploy.sh"
  PostToolUse:
    - matcher: Bash
      command: ".claude/hooks/log-deploy.sh"
  Stop:
    - command: ".claude/hooks/cleanup.sh"
      once: true  # Run only once per session
---

Événements pris en charge : PreToolUse, PostToolUse, Stop

L’option once (Skills et commandes slash uniquement) garantit que le hook ne s’exécute qu’une seule fois par session, ce qui est utile pour les tâches de nettoyage ou de finalisation.

Stratégie pour les sessions longues

Pour les sessions Claude Code nocturnes ou sans surveillance, configurez des hooks afin de garder Claude sur la bonne voie sans intervention manuelle. L’idée clé : utilisez les hooks de linting et de test comme garde-fous qui forcent Claude à corriger les problèmes avant de continuer.⁵⁷

Le modèle « Ne vous arrêtez pas tant que les tests ne passent pas » :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          {
            "type": "command",
            "command": "npm run lint && npm run typecheck",
            "timeout": 60000
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "npm test || echo 'Tests failing - Claude should fix before stopping'"
          }
        ]
      }
    ]
  }
}

Stratégie pour les sessions nocturnes :

1. Vérification préalable : utilisez un hook Setup pour vérifier que l’environnement est prêt
2. Validation continue : les hooks PostToolUse exécutent les tests après chaque changement
3. Verrouillage de l’achèvement : les hooks Stop vérifient tous les critères d’acceptation avant que Claude déclare « terminé »
4. Notification : les hooks Stop peuvent vous notifier via Slack/Pushover lorsque Claude termine ou reste bloqué

Combinez avec --dangerously-skip-permissions dans un conteneur sandboxé pour des exécutions nocturnes entièrement autonomes. Claude continuera d’itérer jusqu’à ce que les tests passent ou qu’il épuise ses options.

Qu’est-ce que MCP (Model Context Protocol) ?

MCP étend Claude Code avec un accès à des outils externes, des bases de données, des APIs et des services via un protocole standardisé. L’écosystème a explosé : MCP compte désormais 100 millions de téléchargements mensuels et plus de 3 000 serveurs indexés sur MCP.so (janvier 2026), consolidant sa position en tant que standard du secteur pour connecter l’IA aux outils et aux données.³⁴⁷ Comprendre MCP est essentiel pour intégrer Claude dans votre chaîne d’outils existante.

Pourquoi MCP est important pour les développeurs : Sans MCP, Claude Code ne peut que lire des fichiers et exécuter des commandes bash. Avec MCP, Claude peut interroger votre base de données de production, créer des tickets Jira, examiner des PR GitHub, vérifier les erreurs Sentry et interagir avec n’importe quel API utilisé par votre équipe, le tout à partir de requêtes en langage naturel. Le protocole standardise la manière dont les outils d’IA se connectent aux services externes, évitant ainsi le verrouillage par fournisseur. Consultez Decision Frameworks pour des conseils sur le choix entre MCP et d’autres mécanismes d’extension.

Prise en charge des serveurs MCP distants (juin 2025)

Claude Code prend désormais en charge les serveurs MCP distants avec une authentification OAuth native.²¹ Connectez-vous à des outils et des sources de données sans gérer de serveurs locaux. Authentifiez-vous une seule fois et Claude Code gère automatiquement le rafraîchissement des jetons.

# Connect to remote MCP server with OAuth
claude mcp add --transport http linear https://mcp.linear.app/sse
# Browser opens for OAuth flow, tokens stored securely

SDK mcp_authenticate redirectUri (v2.1.121+) : Le mcp_authenticate de l’Agent SDK accepte un paramètre redirectUri pour finaliser OAuth sur des schémas d’URI personnalisés — requis pour les applications de bureau et les flux de connecteurs claude.ai qui ne peuvent pas utiliser la redirection en boucle locale par défaut.¹⁵⁴

Connecteurs MCP claude.ai (v2.1.46+)

Claude Code peut désormais utiliser les connecteurs MCP configurés dans votre compte claude.ai. Cela comble le fossé entre le web et CLI : les serveurs MCP que vous avez configurés via l’interface claude.ai sont automatiquement disponibles dans Claude Code sans avoir à les reconfigurer localement.⁹⁵

Désactivation : Définissez ENABLE_CLAUDEAI_MCP_SERVERS=false dans votre environnement ou dans le bloc env de settings.json pour empêcher le chargement des serveurs MCP claude.ai.¹⁰⁴

Recherche d’outils MCP (v2.1.7+)

À mesure que les serveurs MCP ont gagné en capacités (certains exposant plus de 50 outils), les descriptions d’outils ont commencé à consommer un contexte excessif. La Recherche d’outils MCP résout ce problème en chargeant dynamiquement les descriptions d’outils uniquement lorsque cela est nécessaire, une forme de chargement paresseux pour les outils d’IA.⁴⁷

Impact sur les performances : Les benchmarks internes montrent des améliorations spectaculaires en matière de précision : - Opus 4 : 49 % → 74 % sur les évaluations MCP - Opus 4.5 : 79,5 % → 88,1 % sur les évaluations MCP - Réduction de la surcharge de jetons : 85 %

Comment cela fonctionne : Lorsque les descriptions d’outils MCP dépassent 10 % de la fenêtre de contexte (seuil par défaut), Claude Code diffère le chargement des descriptions complètes jusqu’à ce qu’elles soient réellement nécessaires. Claude voit les noms des outils mais récupère les descriptions à la demande.

Configuration :

{
  "mcpToolSearchAutoEnable": "auto:15"  // Enable when tools exceed 15% of context
}

Valeurs : - true - Toujours activer la recherche d’outils - false - Toujours désactiver (charger toutes les descriptions d’outils dès le départ) - auto:N - Activer lorsque les outils dépassent N % du contexte (0-100)

Conseil d’expert : Avec la Recherche d’outils activée, vous pouvez vous connecter à beaucoup plus de serveurs MCP sans vous soucier des limites de contexte. La réduction de 95 % du contexte signifie que les serveurs qui se disputaient auparavant le contexte coexistent désormais paisiblement.

Surcharge de chargement permanent MCP (v2.1.121+)

La Recherche d’outils diffère le chargement des descriptions complètes jusqu’à ce qu’un outil soit nécessaire (seuil : mcpToolSearchAutoEnable, par défaut auto:10). Pour les serveurs de confiance dont vous prévoyez d’utiliser les outils à chaque tour, désactivez cette option par serveur avec alwaysLoad: true — chaque outil de ce serveur est chargé dans le prompt au démarrage de la session, sans aller-retour ToolSearch :¹⁵⁴

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/",
      "alwaysLoad": true
    }
  }
}

Nouvelle tentative automatique au démarrage MCP (v2.1.121+) : Un serveur qui rencontre une erreur lors du démarrage est désormais réessayé jusqu’à 3 fois avant d’être marqué comme déconnecté — utile pour les serveurs stdio qui font la course avec un processus parent lent ou les serveurs HTTP derrière un backend à démarrage à froid.¹⁵⁴

Élicitation MCP (v2.1.76+)

Les serveurs MCP peuvent désormais demander une saisie structurée à l’utilisateur en cours de tâche via des dialogues interactifs.¹¹⁸ Lorsqu’un serveur MCP a besoin d’informations supplémentaires (par exemple, sélectionner une branche, saisir un nom de projet, confirmer une action), il envoie une demande d’élicitation que Claude Code rend sous forme de champs de formulaire ou d’URL de navigateur.

Intégration des hooks : Deux nouveaux événements de hook — Elicitation (avant l’apparition du dialogue) et ElicitationResult (après la réponse de l’utilisateur) — vous permettent d’intercepter, de valider ou de remplacer les réponses d’élicitation de manière programmatique. Cela permet des flux de travail d’entreprise où les invites du serveur MCP sont pré-remplies ou contraintes par une politique.

Surcharge de la taille des résultats MCP (v2.1.91+)

Les résultats des outils MCP sont tronqués par défaut. Les serveurs peuvent remplacer ce comportement par résultat en utilisant l’annotation _meta["anthropic/maxResultSizeChars"], autorisant jusqu’à 500 000 caractères.¹³⁶ Ceci est utile pour renvoyer des charges utiles volumineuses telles que des schémas de bases de données, des réponses API ou des contenus de fichiers sans troncature.

Assistant interactif de configuration MCP

Exécutez claude mcp add sans arguments pour lancer une interface étape par étape pour ajouter des serveurs MCP. L’assistant vous guide à travers la sélection du type de transport, l’authentification et la configuration.⁸

Types de transport

HTTP (recommandé pour les serveurs distants) :

claude mcp add --transport http github https://api.githubcopilot.com/mcp/

# With authentication
claude mcp add --transport http api https://api.example.com/mcp \
  --header "Authorization: Bearer $API_TOKEN"

SSE (déprécié mais fonctionnel) :

claude mcp add --transport sse asana https://mcp.asana.com/sse \
  --header "X-API-Key: your-key"

Stdio (serveurs locaux) :

# PostgreSQL
claude mcp add --transport stdio postgres \
  --env "DATABASE_URL=postgresql://user:pass@localhost/db" \
  -- npx -y @anthropic-ai/mcp-server-postgres

# Custom server
claude mcp add --transport stdio custom -- python /path/to/server.py --port 8000

Windows nécessite un wrapper cmd pour stdio :

claude mcp add --transport stdio my-server -- cmd /c npx -y @some/package

Gestion des portées

Les serveurs MCP existent à trois portées avec une précédence claire (local prime sur projet, qui prime sur utilisateur) :

Spécifiez la portée lors de l’installation :

claude mcp add --scope project --transport http github https://...
claude mcp add --scope user --transport stdio personal-tool -- ./my-tool

Format du fichier de configuration

Le fichier .mcp.json définit les serveurs au niveau du projet :

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "database": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-server-postgres"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    },
    "sentry": {
      "type": "http",
      "url": "https://mcp.sentry.dev/mcp",
      "headers": {
        "Authorization": "Bearer ${SENTRY_API_KEY}"
      }
    },
    "internal-api": {
      "type": "http",
      "url": "${API_BASE_URL:-https://api.example.com}/mcp",
      "headers": {
        "X-API-Key": "${INTERNAL_API_KEY}"
      }
    }
  }
}