Claude Code CLI : le guide complet

TL;DR : Claude Code est un CLI agentique qui lit votre codebase, exécute des commandes et modifie des fichiers à travers un système multicouche de permissions, de hooks, d’intégrations MCP et de subagents. Maîtrisez cinq systèmes fondamentaux (configuration, permissions, hooks, MCP et subagents) et vous dé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 (et non les prompts) pour tout ce qui doit s’exécuter systématiquement.

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

La différence entre une utilisation occasionnelle et une utilisation efficace de Claude Code repose sur cinq systèmes fondamentaux. 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 : régit les opérations
3. Système de hooks : permet l’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

• 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.
• Déléguez le travail à la couche de délégation : les subagents évitent la surcharge de contexte en isolant l’exploration dans des fenêtres de contexte propres, ne renvoyant que des résumés.
• Les hooks garantissent l’exécution ; les prompts non : utilisez les hooks pour le linting, le formatage et les vérifications de sécurité qui doivent s’exécuter à chaque fois, indépendamment du comportement du modèle.
• L’échelonnement des modèles réduit les coûts sans sacrifier la qualité : orientez l’exploration des subagents vers des modèles moins coûteux et réservez Opus pour le véritable raisonnement architectural — ou standardisez sur Opus si la qualité est votre seule variable.
• MCP connecte Claude à votre chaîne d’outils : 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 à travers des codebases de production, des pipelines CI/CD et des déploiements en entreprise. Ce guide distille cette expérience en la référence complète que j’aurais aimé avoir quand j’ai commencé. Chaque fonctionnalité inclut la syntaxe réelle, des exemples de configuration concrets et les cas limites qui piègent même les utilisateurs expérimentés.

Comment utiliser ce guide

Ceci 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ù votre niveau d’expérience vous situe :

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 en fin de guide fournit un résumé synthétique de toutes les commandes principales.

Comment fonctionne Claude Code : le modèle mental

Avant de plonger dans les fonctionnalités, comprenez comment l’architecture de Claude Code façonne tout ce que vous faites avec. 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 principale (Core Layer) : 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). Lorsque 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 (Delegation Layer) : les subagents démarrent avec des contextes vierges, effectuent un travail ciblé et renvoient des résumés. Les résultats d’exploration n’alourdissent pas votre conversation principale ; seules les conclusions sont renvoyées. Orientez les subagents vers des niveaux de modèles moins coûteux pour l’exploration, ou utilisez votre modèle principal tout au long si la qualité compte plus que le coût.

Couche d’extension (Extension Layer) : 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 une expertise métier que Claude applique automatiquement. Les plugins empaquettent tout cela pour la distribution.

L’idée clé : la plupart des utilisateurs travaillent exclusivement dans la couche principale, observant le contexte gonfler et les coûts grimper. Les utilisateurs avancés délèguent l’exploration et le travail spécialisé à la couche de délégation, maintiennent la couche d’extension configurée pour leur flux de travail, et n’utilisent la couche principale 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. Système de configuration en profondeur
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 de réflexion étendue ?
13. Styles de sortie
14. Commandes slash
15. Comment fonctionnent les skills ?
16. Système de plugins
17. Comment fonctionne la mémoire ?
18. Images et entrées multimodales
19. Mode vocal
20. Comment fonctionne l’intégration Git ?
21. Comment utiliser Claude Code dans mon IDE ?
22. Patterns d’utilisation avancée
23. Agents distants et en arrière-plan [APERÇU RECHERCHE]
24. Claude dans Chrome
25. Claude Code dans Slack [APERÇU RECHERCHE]
26. Claude Code sur le Web [APERÇU 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 flux de travail
33. Guide de migration
34. Conseils par profil d’utilisateur
35. Carte de référence rapide
36. Journal des modifications
37. Références

Comment installer Claude Code ?

Configuration requise

Claude Code fonctionne sur macOS 10.15+, Ubuntu 20.04+/Debian 10+, et Windows 10+ via WSL ou Git Bash. 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 rester en 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

Méthodes d’installation

Installation native (recommandée)

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

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

# Homebrew alternative
brew install --cask claude-code

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

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

Pour installer une version 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 via NPM (dépréciée)

Remarque : 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 existants 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 méthodes d’authentification, chacune avec des compromis différents :

Claude Console (facturation API)

Connectez-vous directement à l’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 propose une facturation à l’usage avec un accès complet à l’API. Un espace de travail « Claude Code » dédié est créé automatiquement ; vous ne pouvez pas créer de clés API pour cet espace, mais vous pouvez suivre votre utilisation.

Abonnement Claude Pro ou Max

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

Plateformes entreprise

AWS Bedrock, Google Vertex AI et Microsoft Foundry offrent chacun un accès de niveau entreprise avec les relations de facturation cloud existantes :

# 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

Pour les déploiements 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

Cette commande affiche le type d’installation, la version, la configuration système et les éventuels problèmes détectés.

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 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 se téléchargent en arrière-plan et s’appliquent 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

Nettoyage de la configuration (supprime tous les paramètres) :

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

Démarrage rapide : votre première session

1. Installez et lancez :

claude                           # Launch in current directory

2. Accédez à un projet :

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

3. Demandez à Claude 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. Utilisez les raccourcis clavier pendant votre session :

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

5. Reprenez plus tard :

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

Conseil d’expert : Créez un fichier CLAUDE.md à la racine de votre projet contenant les commandes de build, les conventions de code et les notes d’architecture. Claude le lit à chaque session — c’est le levier le plus efficace pour améliorer 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 maintient le contexte de conversation entre les échanges. Saisissez vos requêtes directement, recevez les réponses et continuez jusqu’à ce que vous quittiez avec /exit ou Ctrl+D.

Démarrez avec un prompt initial pour orienter la session :

claude "explain the authentication flow in this project"

Astuce avancée : Le REPL conserve l’état entre les événements de compaction. Lorsque le contexte devient trop volumineux, Claude résume automatiquement les échanges plus anciens tout en préservant les décisions clés et les extraits de code. Vous pouvez déclencher cela manuellement avec /compact ou ajouter des instructions personnalisées pour définir ce qui doit être préservé.

Mode non interactif

Le mode print (-p) exécute une requête unique 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 à l’analyse 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 de la 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ôle du comportement agentique en mode -p :

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

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

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

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 les travaux complexes multi-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+) : Démarrez une session liée à une pull request spécifique :⁸¹

claude --from-pr 123                                    # By PR number
claude --from-pr https://github.com/org/repo/pull/123   # By URL

Les sessions se lient également automatiquement aux PR lorsque vous les créez via gh pr create pendant une session. Cela facilite la reprise du travail sur une PR spécifique ultérieurement.

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

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

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

Mode Plan

Le mode Plan restreint Claude à l’exploration en lecture seule — pas de modification de fichiers, pas d’exécution bash, aucune action destructive. 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

Fonctionnement :

1. Claude entre en mode Plan (automatiquement pour les tâches complexes, ou via Shift+Tab)
2. Explore le codebase à l’aide d’outils en lecture seule : Read, Glob, Grep, WebSearch, WebFetch
3. Rédige un plan dans .claude/plans/{session-slug}.md
4. Quitte le mode Plan avec ExitPlanMode, en présentant le plan pour votre examen
5. Vous approuvez, demandez des modifications ou rejetez

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

Après approbation du plan (v2.1.32+) : Claude propose trois options : - « Oui, réinitialiser le contexte et accepter automatiquement les modifications » (Shift+Tab) — repart à zéro avec le contexte complet pour le plan - « Oui, et approuver manuellement les modifications » — conserve le contexte, vous approuvez chaque changement - « Oui, accepter automatiquement les modifications » — conserve le contexte, Claude exécute sans approbation individuelle

La réinitialisation du contexte à l’approbation est le workflow recommandé. Elle offre au plan une fenêtre de contexte fraîche, ce qui améliore significativement le respect du plan — Claude reste sur la bonne voie plus longtemps sans que l’ancienne conversation n’interfère.

Quand utiliser le mode Plan : - Implémentation de nouvelles fonctionnalités impliquant des décisions architecturales - Refactorisations multi-fichiers où vous souhaitez examiner l’approche au préalable - Codebases non familiers où l’exploration doit précéder la modification - Toute tâche où plusieurs approches valides existent et vous souhaitez des suggestions

Astuce avancée : 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 gratuite — pas d’appels d’outils risqués, pas de modifications gaspillées. Utilisez-le généreusement.

Système de configuration en profondeur

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

Hiérarchie de configuration

Conseil d’expert : Utilisez .claude/settings.local.json pour vos préférences personnelles dans les projets partagés (ajoutez-le au .gitignore). Utilisez .claude/settings.json pour la configuration d’équipe qui est versionnée 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
  },
  "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
  }
}

Référence des variables d’environnement

Authentification et API :

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

Configuration du modèle :

ANTHROPIC_MODEL=claude-opus-4-6                 # Override default model
ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-4-6    # Opus 4.6 (Feb 2026)
ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-4-5-20250929
ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-4-5-20251001
CLAUDE_CODE_SUBAGENT_MODEL=sonnet               # Model for subagents
MAX_THINKING_TOKENS=10000                       # Enable extended thinking
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
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

Contrôle du comportement :

DISABLE_AUTOUPDATER=1                           # Prevent automatic updates
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

Configuration des outils :

BASH_DEFAULT_TIMEOUT_MS=30000                   # Bash command timeout (30s)
BASH_MAX_TIMEOUT_MS=600000                      # Maximum bash timeout (10min)
BASH_MAX_OUTPUT_LENGTH=50000                    # Bash output limit
CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=1     # Reset CWD after each bash
MCP_TIMEOUT=5000                                # MCP server startup timeout
MCP_TOOL_TIMEOUT=30000                          # MCP tool execution timeout
MAX_MCP_OUTPUT_TOKENS=25000                     # MCP output limit
SLASH_COMMAND_TOOL_CHAR_BUDGET=15000            # Slash command context limit

Réseau et proxy :

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

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

Variables de skills (v2.1.69+) :

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

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

CLAUDE_CODE_ACCOUNT_UUID=uuid                  # Provide account UUID synchronously for SDK callers
CLAUDE_CODE_USER_EMAIL=[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 ?

Le choix du bon modèle pour chaque tâche a un impact significatif sur le coût et la qualité. Claude Code offre une flexibilité de changement de modèle à plusieurs niveaux.

Modèles disponibles

Opus 4.6 (5 février 2026) : Le dernier modèle phare avec une fenêtre de contexte de 1M de tokens, une sortie maximale de 128K, le raisonnement adaptatif et les équipes d’agents.⁸⁶ Même tarification qu’Opus 4.5 (5 $/25 $ par MTok). Depuis la v2.1.75 (13 mars 2026), la fenêtre de contexte de 1M est activée par défaut pour les forfaits Max, Team et Enterprise — le suffixe [1m] n’est plus nécessaire pour ces niveaux.¹²⁴ Depuis la v2.1.77 (17 mars 2026), la limite par défaut de tokens en sortie pour Opus 4.6 passe à 64K tokens, avec un plafond de 128K tokens.¹²⁶ Le contexte long (>200K en entrée) en utilisation API uniquement coûte toujours 10 $/37,50 $ par MTok. Identifiant du modèle : claude-opus-4-6.¹

Sonnet 4.6 (17 février 2026) : Le nouveau modèle équilibré qui remplace Sonnet 4.5 comme modèle par défaut sur claude.ai et Claude Cowork.¹⁰⁰ Même tarification que Sonnet 4.5 (3 $/15 $ par MTok). Performances améliorées en recherche agentique tout en consommant moins de tokens. Prend en charge le raisonnement étendu, le raisonnement adaptatif et une fenêtre de contexte de 1M de tokens (bêta). Sortie maximale de 64K (plafond augmenté à 128K dans la v2.1.77).¹²⁶ Date limite de connaissances : août 2025 (fiable), janvier 2026 (données d’entraînement). Identifiant du modèle : claude-sonnet-4-6. Sonnet 4.5 est désormais un modèle obsolète.¹⁰⁰

Pourquoi ces différences de prix comptent : Une session de développement typique consomme entre 50K et 200K tokens en entrée et entre 10K et 50K tokens en 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 5 fois plus. Réservez Opus aux problèmes réellement complexes.¹

Quand utiliser chaque modèle

Haiku : À utiliser pour les subagents d’exploration, les recherches de fichiers simples et les questions rapides. Il est environ 5 fois moins cher qu’Opus et répond plus vite. Parfait pour les tâches en arrière-plan ne nécessitant pas de raisonnement approfondi.

Sonnet : Le modèle de référence pour le développement au quotidien. Il gère bien la plupart des tâches de programmation : implémenter des fonctionnalités, corriger des bugs, écrire des tests, faire de la revue de code. Utilisez-le comme modèle par défaut. Sonnet 4.6 (février 2026) offre une recherche agentique améliorée et une meilleure efficacité en tokens par rapport à Sonnet 4.5, avec prise en charge du raisonnement adaptatif et la fenêtre de contexte de 1M en bêta.¹⁰⁰

Opus : À réserver au raisonnement réellement complexe : décisions architecturales, débogage délicat, compréhension de systèmes complexes, analyse de sécurité. Opus 4.6 (février 2026) représente un progrès majeur : il planifie plus soigneusement, maintient les tâches agentiques plus longtemps, fonctionne plus fiablement dans les grandes bases de code et détecte mieux ses propres erreurs lors de la revue de code.⁸⁶ Il dispose d’une fenêtre de contexte de 1M de tokens en bêta et introduit le raisonnement adaptatif qui détermine automatiquement la profondeur d’analyse. Selon Anthropic, sur Terminal-Bench 2.0, Opus 4.6 obtient le meilleur score industriel en programmation agentique. Sur GDPval-AA (travail de connaissance à valeur économique), Anthropic rapporte qu’il surpasse GPT-5.2 d’environ 144 points Elo.⁸⁶ Remarque : Les utilisateurs avec un abonnement Pro ont accès à Opus dans le cadre de leur abonnement.²⁰

Opusplan : Un mode hybride qui utilise Opus pour la planification (là où la qualité du raisonnement compte le plus) et Sonnet pour l’exécution (là où la rapidité prime). Excellent pour le refactoring complexe lorsque vous souhaitez le meilleur plan sans avoir besoin du niveau de raisonnement d’Opus pour chaque modification individuelle.

Changer de modèle

En cours de session :

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

Au démarrage :

claude --model opus

Via une variable d’environnement :

export ANTHROPIC_MODEL=opus

Dans settings.json :

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

Pour les subagents spécifiquement :

export CLAUDE_CODE_SUBAGENT_MODEL=haiku

Contexte étendu

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

claude --model sonnet[1m]
claude --model opus[1m]           # Opus 4.6 avec contexte 1M

Ou en cours de session :

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

Depuis la v2.1.75 (13 mars 2026), Opus 4.6 utilise le contexte 1M par défaut pour les forfaits Max, Team et Enterprise — aucun suffixe [1m] nécessaire.¹²⁴ Le suffixe [1m] reste requis pour Sonnet et pour les utilisateurs API uniquement.

Opus 4.6 est le premier modèle de classe Opus avec une prise en charge native du contexte 1M. Il atteint 76 % de précision sur la variante 8 aiguilles à 1M du MRCR v2 (les concurrents obtiennent environ 18,5 %), ce qui en fait le modèle le plus performant pour la récupération en contexte long.⁸⁶

Le contexte étendu coûte plus cher par token (2x en entrée, 1,5x en sortie au-delà de 200K tokens en entrée). Pour Sonnet avec [1m], utilisez-le quand vous en avez réellement besoin, pas par défaut.

Vérifier le modèle actuel

> /status

Cette commande affiche le modèle en cours, les informations du compte, les paramètres appliqués et d’autres détails de la session.

Libellés du sélecteur de modèle (v2.1.51+) : Le sélecteur /model affiche désormais des libellés lisibles (par ex. « Sonnet 4.6 ») au lieu des identifiants bruts pour les versions épinglées, avec des suggestions de mise à jour lorsque des versions plus récentes sont disponibles.¹⁰⁵

Mode rapide (v2.1.36+)

Le mode rapide fournit une sortie considérablement plus rapide avec le même modèle ; il ne bascule pas vers un modèle moins cher. Activez-le en session avec /fast.⁹³

> /fast            # Activer/désactiver le mode rapide

Tarification (Opus 4.6 en mode rapide) :

La tarification du mode rapide s’applique sur l’ensemble de la fenêtre de contexte, y compris les requêtes dépassant 200K tokens en entrée — il n’y a pas de surcoût supplémentaire pour le contexte long en mode rapide.¹ La tarification du mode rapide se cumule avec la mise en cache des prompts et les multiplicateurs de résidence des données, mais PAS avec la tarification du contexte long. Le mode rapide n’est pas disponible avec l’API Batch.

Quand utiliser le mode rapide : - Itérations rapides sur de petites modifications où la latence est le goulot d’étranglement - Génération de tests, de code répétitif ou de boilerplate où la rapidité prime sur le coût - Traitement séquentiel d’une liste de tâches similaires

Quand NE PAS utiliser le mode rapide : - Tâches agentiques longues (le coût s’accumule vite à 6x le tarif) - Travail de subagents en arrière-plan (personne n’attend la sortie) - Sessions avec un budget limité

Le mode rapide d’Opus 4.6 inclut désormais la fenêtre de contexte complète de 1M (v2.1.50+). Auparavant, le mode rapide était limité au contexte standard ; vous bénéficiez maintenant de la même capacité de 1M de tokens à la vitesse du mode rapide.¹⁰³

Astuce d’expert : Le mode rapide se combine bien avec le mode hybride opusplan : utilisez le mode rapide pendant la phase d’exécution Sonnet pour des itérations rapides tout en conservant les tarifs standard pour la planification Opus. Notez que /fast nécessite que /extra-usage soit activé au préalable (correctif v2.1.37).⁹³

Combien coûte Claude Code ?

Comprendre et maîtriser les coûts est essentiel pour une utilisation durable de Claude Code. Consultez également 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

Résultat :

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

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 standard de l’API.²¹

Tarification par token de l’API (février 2026)¹⁸⁶

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

Tarification pour contexte long (>200K tokens en entrée) :

Le seuil de 200K est basé sur le total des tokens en entrée (y compris les lectures/écritures de cache). Lorsqu’il est dépassé, Anthropic facture tous les tokens au tarif contexte long.¹

Tarification par résidence des données : Spécifier une inférence limitée aux États-Unis via inference_geo ajoute un multiplicateur de 1,1× sur tous les tarifs de tokens (modèles Opus 4.6+ uniquement).¹

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

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

Politique des comptes multiples⁵⁹

Peut-on avoir plusieurs comptes Claude ? Oui, pour des cas d’utilisation légitimes. Anthropic autorise explicitement les comptes multiples 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 adresse IP/réseau sont explicitement pris en charge - Les comptes sont entièrement séparés ; aucun transfert de conversation 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 comptes pour éviter la détection - Utiliser plusieurs comptes pour contourner les limites de débit ou les crédits du niveau gratuit

Note pratique : En janvier 2026, l’utilisateur intensif Jeffrey Emanuel (@doodlestein) a vu ses 22 comptes Max automatiquement signalés et temporairement bannis. L’employé d’Anthropic Thariq (@trq212) a résolu le problème en 4 heures après avoir confirmé l’utilisation légitime. Si vous utilisez Claude Code de manière intensive pour des projets professionnels et personnels sur plusieurs comptes, c’est exactement ce pour quoi le service est conçu, mais n’essayez pas de contourner 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 pour réduire les coûts : Utiliser Haiku pour les subagents d’exploration et Sonnet pour l’implémentation réduit généralement les coûts de 40 à 50 % par rapport à l’utilisation exclusive de Sonnet.

Gestion des coûts en équipe

TPM/RPM recommandés par taille d’équipe :

Frais d’outils cachés

Au-delà de la tarification par token, certains outils entraînent des frais séparés :¹⁶

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

Stratégies de réduction des coûts

1. Utilisez Haiku pour les subagents : la plupart des explorations ne nécessitent pas Sonnet
2. Activez le prompt caching : activé par défaut, mais vérifiez qu’il n’est pas désactivé
3. Définissez un nombre maximum de tours : claude --max-turns 5 empêche les conversations incontrôlées
4. Utilisez le mode plan pour l’exploration : pas d’exécution = pas d’opérations coûteuses accidentelles
5. Compactez de manière proactive : moins de contexte = moins de tokens
6. Limitez la sortie : export CLAUDE_CODE_MAX_OUTPUT_TOKENS=2000
7. API Batch pour les travaux non urgents : 50 % de réduction sur les tokens d’entrée et de sortie

Surveillance de l’utilisation

• Console Claude : platform.claude.com (nécessite le rôle Admin ou Billing)
• Limites de l’espace de travail : définissez des limites 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

Consommation de tokens en arrière-plan

Certaines opérations consomment des tokens en arrière-plan : - Résumé de conversation pour /resume - Commandes /cost et /status - Auto-compaction

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

API Analytics de Claude Code (Team/Enterprise)⁵³

Accédez de manière programmatique aux analyses d’utilisation de Claude Code et aux métriques de productivité de votre organisation via l’API Admin.

Point d’accès : GET /v1/organizations/usage_report/claude_code

Prérequis : - Clé API Admin (sk-ant-admin...) - Plan Team ou Enterprise - Rôle Admin, Billing ou Developer

Métriques 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’utilisation : - Analyse de la productivité des développeurs (sessions, commits, PR) - Métriques 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

Remarque : Les données apparaissent dans l’heure suivant la fin de l’activité. Seules les données de plus d’une heure sont incluses dans les réponses pour des raisons de cohérence.

Cadres de décision

Connaître les fonctionnalités ne suffit pas. Vous devez savoir quand utiliser chacune d’entre elles. Ces arbres de décision transforment la connaissance en action.

Quel modèle utiliser ?

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

Règle générale : Commencez avec Sonnet. Passez à Haiku pour les subagents. N’escaladez vers Opus 4.6 que 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 vs Skill vs Subagent vs é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 vs Prompt ?

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

Quand utiliser la réflexion étendue ?

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

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

Réflexion adaptative d’Opus 4.6 : Opus 4.6 ajuste automatiquement la profondeur de réflexion en fonction de la complexité du problème. Pour la plupart des tâches, le contrôle explicite du budget de réflexion n’est pas nécessaire — Opus monte en puissance pour les problèmes difficiles et reste rapide pour les tâches simples. Le basculement manuel de la réflexion est surtout utile avec Sonnet lorsque vous souhaitez 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 vs subagents vs 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 de permissions ?

Le système de permissions de Claude Code offre un contrôle granulaire sur les opérations autorisées. Le comprendre est essentiel tant pour la sécurité que pour l’efficacité du flux de travail. Consultez également Déploiement en entreprise pour les paramètres gérés qui appliquent les permissions à l’échelle de l’organisation.

Niveaux de permissions

Outils en lecture seule (approuvés automatiquement) : - Read - Lire le contenu des fichiers - Glob - Rechercher des fichiers par motif - Grep - Rechercher dans le contenu des fichiers - WebSearch - Effectuer des recherches 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 à un IDE : - Aller à la définition : accéder directement à l’endroit où un symbole est défini - Trouver les références : lister toutes les utilisations d’un symbole dans l’ensemble du code - Documentation au survol : obtenir les informations de type et la documentation pour n’importe quel symbole - Fonctionne avec TypeScript, Python, Go, Rust et d’autres langages disposant d’un support LSP - Nécessite qu’un serveur de langage soit disponible (généralement installé avec votre chaîne d’outils)

Outils de modification (nécessitent une approbation) : - 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

Lors de la première exécution d’un outil de modification, Claude Code demande une approbation. Les approbations persistent pour la durée de la session, sauf configuration contraire explicite.

Modes de permissions

Mode YOLO (v2.0.68+) : Pour un fonctionnement entièrement autonome, utilisez le flag --dangerously-skip-permissions. Ce flag accepte tout : modifications de fichiers, commandes bash, tous les appels d’outils. Le mot « dangerous » est intentionnel. À utiliser dans des environnements isolés ou lorsque vous faites entièrement confiance au code source.⁶¹

claude --dangerously-skip-permissions

Définir le mode via CLI :

claude --permission-mode acceptEdits

Basculer pendant une session :

Shift+Tab  # Cycles through modes

Dans settings.json :

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

Syntaxe des règles de permissions

Des règles granulaires contrôlent des 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 ne correspondent qu’aux préfixes, pas aux expressions régulières. Un motif comme Bash(curl http:*) ne correspondra pas à curl -X GET http://... car les options précèdent l’URL. Pour un blocage fiable, refusez la commande entièrement : 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/**) - relatif au répertoire de travail - Absolus depuis le fichier de paramètres : Edit(/build/**) - relatif à l’emplacement du fichier de paramètres - Véritablement absolus : Edit(//tmp/**) - commence par // - Répertoire personnel : Read(~/.zshrc)

Motifs d’outils MCP :

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

Utilisez la syntaxe avec caractère générique mcp__server__* pour autoriser ou refuser tous les outils d’un serveur MCP spécifique.³⁹ Cette syntaxe est utile pour activer rapidement tous les outils de serveurs de confiance ou bloquer l’ensemble des outils de serveurs non fiables.

Motifs WebFetch :

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

Répertoires supplémentaires

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

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

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

Mode Sandbox

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

> /sandbox

Ou configurez dans les paramètres :

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["git", "docker"],
    "network": {
      "allowUnixSockets": ["~/.ssh/agent-socket"],
      "allowLocalBinding": true
    }
  }
}

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

Conseil d’expert : le mode sandbox est idéal pour exécuter Claude sur des bases de code non fiables. Activez-le lorsque vous explorez des projets inconnus ou souhaitez une couche de protection supplémentaire. Les tests internes d’Anthropic ont montré que le sandboxing réduit les demandes de permissions de 84 %.⁴⁵ Le sandbox utilise des primitives au niveau du système d’exploitation (seatbelt sur macOS, bubblewrap sur Linux) pour l’isolation du système de fichiers et du réseau, de sorte que même une injection de prompt réussie reste entièrement contenue. Anthropic a publié en open source le runtime du sandbox pour les équipes développant 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 de permission Bash lorsque autoAllowBashIfSandboxed était activé ; ce problème a été corrigé dans la v2.1.34.⁹⁴ Depuis la v2.1.38, les écritures dans .claude/skills sont bloquées en mode sandbox, empêchant l’injection de prompt de modifier les définitions de skills.⁹⁵ La v2.1.77 ajoute un paramètre allowRead pour le système de fichiers du sandbox, permettant de réautoriser l’accès en lecture au sein de régions denyRead — utile lorsque vous souhaitez bloquer la majorité d’une arborescence tout en autorisant des sous-répertoires spécifiques.¹²⁶

Comment fonctionnent les hooks ?

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

Pourquoi des hooks plutôt que des prompts : Dire à Claude « lance toujours Prettier après avoir édité des fichiers » fonctionne parfois. Mais Claude peut oublier, privilégier la rapidité, ou juger que la modification est « trop mineure ». 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 un fichier hooks.json dédié :

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

Matchers

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

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

Protocole d’entrée/sortie des hooks

Les hooks reçoivent du JSON sur stdin :

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

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

Hooks Stop/SubagentStop (v2.1.47+) : ils reçoivent un champ supplémentaire last_assistant_message contenant le texte de la réponse finale de Claude, permettant aux hooks d’inspecter la sortie sans analyser les fichiers de transcription :

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

Les codes de sortie contrôlent le comportement : - 0 : Succès : l’opération se poursuit. La sortie standard est affichée en mode verbeux (Ctrl+O). Pour UserPromptSubmit et SessionStart, la sortie standard est ajoutée au contexte. - 2 : Erreur bloquante : l’opération s’arrête. La sortie d’erreur devient le message d’erreur transmis à Claude. - 1, 3, etc. : Erreur non bloquante : l’opération continue. La sortie d’erreur est affichée 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 résultats possibles (allow/deny/ask) ainsi que la capacité 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 niveau supérieur decision et reason sont obsolètes pour PreToolUse. Utilisez plutôt hookSpecificOutput.permissionDecision et hookSpecificOutput.permissionDecisionReason. Les autres événements (PostToolUse, Stop, etc.) utilisent toujours le decision de niveau supérieur.⁹⁶

Hooks asynchrones (janvier 2026)

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

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

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

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

Hooks basés sur les prompts et hooks basés sur les 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 à l’aide du raisonnement IA plutôt que de scripts.⁹⁶

Les hooks de prompt (type: "prompt") envoient un prompt en un seul tour à 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 à une URL et reçoivent du JSON en retour. Utilisez-les pour les webhooks, les services de notification externes ou la validation basée sur API (v2.1.63+) :¹¹¹

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

Les hooks HTTP utilisent le même format de décision que les hooks de commande (retour JSON avec decision et reason). Ils sont routés via le proxy réseau du bac à sable 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-tours. Utilisez-les lorsque la vérification nécessite l’inspection de fichiers réels ou de résultats de tests :

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

Utilisez $ARGUMENTS comme espace réservé pour l’entrée JSON du hook. Les deux types prennent en charge les champs model (par défaut le 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.

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 nécessitent désormais une liste allowedEnvVars explicite. Cela empêche l’exfiltration arbitraire de variables d’environnement via les valeurs d’en-tête. Les hooks HTTP sont également routés via le proxy réseau du bac à sable lorsque le sandboxing est activé, appliquant la liste d’autorisation de 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 de l’espace de travail pour les hooks (v2.1.51+) : Les commandes de hook statusLine et fileSuggestion nécessitent désormais l’acceptation de la confiance de l’espace de travail avant de s’exécuter en mode interactif, fermant un vecteur de sécurité potentiel.¹⁰⁵

Exemples pratiques de hooks

Formatage automatique des fichiers TypeScript après édition :

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

Lancer les tests après des modifications 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 débogage pour résoudre les problèmes de hooks :

claude --debug

Le mode débogage journalise : - Les temps d’exécution des hooks - Les données d’entrée/sortie - Les messages d’erreur et les traces de pile - Les résultats de décision (allow/reject/ask)

Affichage de la source du hook (v2.1.75+) : Lorsqu’un hook nécessite la confirmation de l’utilisateur, l’invite de permission affiche désormais la source du hook (paramètres, plugin ou skill), facilitant l’identification du composant qui demande l’accès.¹²⁴

Hooks à portée de composant (v2.1.0+)

Les hooks peuvent être définis directement dans les Skills, les subagents et les slash commands via le 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 slash commands 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 longue durée

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

Le pattern « Ne pas s’arrêter 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é-vol : Utilisez un hook Setup pour vérifier que l’environnement est prêt
2. Validation continue : Les hooks PostToolUse lancent les tests après chaque modification
3. Porte d’achèvement : Les hooks Stop vérifient que tous les critères d’acceptation sont remplis avant que Claude ne déclare « terminé »
4. Notification : Les hooks Stop peuvent vous notifier via Slack/Pushover lorsque Claude termine ou se retrouve 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 ait épuisé 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 de standard industriel 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 PRs GitHub, vérifier les erreurs Sentry et interagir avec n’importe quelle API utilisée par votre équipe, le tout à partir de requêtes en langage naturel. Le protocole standardise la façon dont les outils d’IA se connectent aux services externes, évitant ainsi la dépendance à un fournisseur. Consultez Cadres de décision pour savoir quand utiliser MCP plutôt que d’autres mécanismes d’extension.

Support MCP distant (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. Il suffit de s’authentifier une fois et Claude Code gère automatiquement le renouvellement des tokens.

# 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

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 le 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ésactiver : 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 gagnaient en capacité (certains exposant plus de 50 outils), les descriptions d’outils commençaient à consommer un contexte excessif. La recherche d’outils MCP résout ce problème en chargeant dynamiquement les descriptions d’outils uniquement lorsque c’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 de la 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 tokens : 85 %

Fonctionnement : 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)

Astuce avancée : 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 sans problème.

É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, entrer un nom de projet, confirmer une action), il envoie une requête d’élicitation que Claude Code affiche sous forme de champs de formulaire ou d’URL de navigateur.

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

Assistant de configuration MCP interactif

Exécutez claude mcp add sans arguments pour lancer une interface étape par étape permettant d’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 (obsolète 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 niveaux de portée avec une priorité claire (local remplace projet, projet remplace 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}"
      }
    }
  }
}

Les variables d’environnement sont développées avec la syntaxe ${VAR} avec des valeurs par défaut optionnelles : ${VAR:-default}.

Commandes de gestion MCP

claude mcp list                      # View all configured servers
claude mcp get github                # Get specific server details
claude mcp remove github             # Remove a server
claude mcp reset-project-choices     # Reset project-scoped approvals
claude mcp add-from-claude-desktop   # Import from Claude Desktop
claude mcp add-json weather '{"type":"http","url":"..."}'  # Add from JSON

# Within Claude Code REPL
> /mcp                               # Interactive MCP management

Authentification OAuth

Pour les serveurs nécessitant OAuth :

> /mcp
# Follow browser-based OAuth flow
# Tokens stored securely and auto-refreshed
# Use "Clear authentication" to revoke access

Utilisation des ressources et prompts MCP

Référencer des ressources :

@github:issue://123
@postgres:schema://users
@docs:file://api/authentication

Prompts MCP comme commandes slash :

/mcp__github__list_prs
/mcp__github__pr_review 456
/mcp__jira__create_issue "Bug title" high

Limites de sortie

Claude Code limite la sortie MCP pour éviter le débordement de contexte : - Seuil d’avertissement : 10 000 tokens - Maximum par défaut : 25 000 tokens

Augmentez si nécessaire :

export MAX_MCP_OUTPUT_TOKENS=50000

Serveurs MCP populaires

Patterns MCP pratiques

Workflow GitHub :

> Review PR #456
> List all open issues assigned to me
> Create a bug issue for the authentication failure we found

Requêtes base de données :

> What's our total revenue this quarter?
> Show the schema for the users table
> Find customers with no purchases in 90 days

Surveillance des erreurs :

> What errors occurred in production today?
> Show the stack trace for error ABC123
> Which deployment introduced these errors?

Configuration MCP entreprise

Les administrateurs système peuvent appliquer des politiques MCP via managed-mcp.json :

{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverName": "sentry" },
    { "serverCommand": ["npx", "-y", "@approved/server"] }
  ],
  "deniedMcpServers": [
    { "serverName": "dangerous-server" }
  ]
}

Emplacement : - macOS : /Library/Application Support/ClaudeCode/managed-mcp.json - Linux : /etc/claude-code/managed-mcp.json - Windows : C:\ProgramData\ClaudeCode\managed-mcp.json

La liste de refus a une priorité absolue. Les commandes doivent correspondre exactement, y compris l’ordre des arguments.

MCP Apps (janvier 2026)

Anthropic a lancé MCP Apps, une extension du Model Context Protocol qui permet des interfaces d’outils interactives directement dans l’interface Claude.⁷⁸ MCP Apps permet aux utilisateurs de visualiser, modifier et interagir avec le contenu de services externes sans quitter Claude, notamment Asana, Box, Canva, Figma, Hex, monday.com et Slack. N’importe quel serveur MCP peut fournir une interface interactive qui s’affiche dans Claude. Bien que MCP Apps apparaisse actuellement dans l’interface web de claude.ai, les extensions de protocole MCP sous-jacentes sont pertinentes pour l’écosystème MCP de Claude Code à mesure que les serveurs adoptent les nouvelles capacités interactives.

Plateforme API : outil d’exécution de code v2 (janvier 2026)

Anthropic a lancé la v2 de l’outil d’exécution de code en bêta publique, remplaçant le bac à sable exclusivement Python par l’exécution de commandes Bash et la manipulation directe de fichiers.⁷⁹ Changements clés : - Exécuter des commandes Bash (pas seulement Python) dans des conteneurs isolés - Écrire et exécuter du code dans n’importe quel langage - Appel d’outils programmatique (également en bêta publique) : Claude peut appeler des outils depuis l’exécution de code, réduisant la latence et l’utilisation de tokens dans les workflows multi-outils

L’outil v2 affecte principalement les utilisateurs de l’API mais indique la direction pour les capacités d’exécution cloud de Claude Code.

Que sont les subagents ?

Les subagents sont des instances Claude spécialisées qui gèrent des tâches complexes de manière indépendante. Ils constituent l’une des fonctionnalités les plus puissantes de Claude Code et l’une des moins bien comprises. Maîtriser les subagents élargit considérablement ce que vous pouvez accomplir. Consultez Cadres de décision pour des recommandations sur le choix entre Agent Teams, subagents et sessions parallèles.

Pourquoi les subagents existent : la conversation principale de Claude Code dispose d’une seule fenêtre de contexte. Tout ce que vous discutez, chaque fichier que Claude lit, chaque sortie d’outil : tout cela consomme ce contexte. Lors de longues sessions, le contexte se remplit, Claude perd la trace des décisions antérieures et les performances se dégradent. Les subagents résolvent ce problème en isolant le travail : les résultats d’exploration n’encombrent pas votre conversation principale, seul le résumé est renvoyé. Claude peut également exécuter jusqu’à 10 subagents en parallèle, permettant un travail concurrent qui serait impossible séquentiellement.²

Comment fonctionnent les subagents

Lorsque Claude rencontre une tâche qui bénéficie d’une attention ciblée (exploration approfondie, analyse en plusieurs étapes, travail spécialisé), il peut lancer un subagent. Le subagent :

1. Démarre avec un contexte vierge (aucune pollution de la conversation principale)
2. A accès aux outils spécifiés
3. Fonctionne avec un modèle spécifique (souvent moins coûteux/plus rapide)
4. Renvoie les résultats à la conversation principale

L’architecture empêche le débordement de contexte tout en permettant des flux de travail complexes.

Types de subagents intégrés

Explore (rapide, lecture seule) : - Modèle : Haiku (ultra-rapide) - Mode : strictement lecture seule - Outils : Glob, Grep, Read, et commandes bash sûres (ls, git status, git log, git diff, find, cat, head, tail) - Niveaux de profondeur : Quick, Medium, Very thorough - Utilisation : exploration du code source, recherche de fichiers, compréhension de la structure

General-purpose : - Modèle : hérité de la conversation principale - Mode : lecture/écriture complète - Outils : tous les outils disponibles - Utilisation : tâches complexes de recherche et de modification

Plan : - Modèle : hérité de la conversation principale (ou Opus avec opusplan) - Mode : lecture seule - Outils : Read, Glob, Grep, Bash - Utilisation : planification d’implémentations complexes avant exécution

Déclenchement des subagents

Claude délègue automatiquement aux subagents en fonction du type de tâche. Vous pouvez également les demander explicitement :

> Use the explore agent to find all authentication-related files

> Have a subagent analyze the database schema thoroughly

> Spawn an agent to research how error handling works in this codebase

Astuce avancée : pour les tâches complexes, demandez explicitement la délégation à un subagent. « Use an explore agent to find… » évite l’encombrement du contexte dans votre conversation principale.

Création de subagents personnalisés

Définissez les subagents dans .claude/agents/ (projet) ou ~/.claude/agents/ (personnel) :

---
name: security-reviewer
description: Expert security code reviewer. Use PROACTIVELY after any code changes to authentication, authorization, or data handling.
tools: Read, Grep, Glob, Bash
model: opus
permissionMode: plan
---

You are a senior security engineer reviewing code for vulnerabilities.

When invoked:
1. Identify the files that were recently changed
2. Analyze for OWASP Top 10 vulnerabilities
3. Check for secrets, hardcoded credentials, SQL injection
4. Report findings with severity levels and remediation steps

Focus on actionable security findings, not style issues.

Champs de configuration :

Restriction des subagents pouvant être lancés (v2.1.33+, renommé v2.1.63) : le champ tools supporte la syntaxe Agent(agent_type) pour limiter les types de subagents qu’un agent peut lancer. Par exemple, tools: Read, Grep, Agent(Explore) permet à l’agent d’utiliser Read et Grep directement mais de ne déléguer qu’aux subagents de type Explore. La restriction empêche la sur-délégation dans les agents contraints. Remarque : dans la v2.1.63, l’outil Task a été renommé en Agent. Les références Task(...) existantes dans les paramètres et définitions d’agents fonctionnent toujours comme alias rétrocompatibles.¹¹³

Subagents définis en CLI (v2.1.32+)

Définissez des subagents en JSON au lancement pour des tests rapides ou l’automatisation. Ils n’existent que pour la session et ne sont pas sauvegardés sur le disque :⁹⁶

claude --agents '{
  "code-reviewer": {
    "description": "Expert code reviewer. Use proactively after code changes.",
    "prompt": "You are a senior code reviewer. Focus on code quality and security.",
    "tools": ["Read", "Grep", "Glob", "Bash"],
    "model": "sonnet"
  }
}'

Le flag --agents accepte du JSON avec les mêmes champs de frontmatter que les subagents basés sur des fichiers : description, prompt, tools, disallowedTools, model, permissionMode, mcpServers, hooks, maxTurns, skills et memory.

Gestion des subagents

> /agents                    # Gestion interactive
> /agents create             # Créer un nouveau subagent
> /agents edit               # Modifier un existant
> /agents delete             # Supprimer un subagent
> /agents list               # Afficher tous

Listing en CLI (v2.1.50+) : listez tous les agents configurés depuis la ligne de commande sans démarrer une session interactive :

claude agents                # Affiche les agents groupés par source (built-in, user, project, plugin)

Contrôle à distance (v2.1.51+) : la sous-commande claude remote-control expose votre environnement local pour les builds externes, permettant à tous les utilisateurs d’accéder aux capacités de l’environnement local à distance :¹⁰⁵

claude remote-control                      # Démarrer l'exposition de l'environnement local
claude remote-control --name "My Project"  # Titre de session personnalisé visible dans claude.ai/code (v2.1.69+)[^117]

Exécution d’agents en arrière-plan

Pour les tâches longues :

> Run a thorough security review in the background

> /agents  # Check status of running agents

Récupérez les résultats plus tard avec l’identifiant de l’agent.

Patterns avancés

Subagents enchaînés :

> First use the code-analyzer subagent to find performance issues, then use the optimizer subagent to fix them

Exploration parallèle :

> Have three explore agents search in parallel:
> 1. Authentication code
> 2. Database models
> 3. API routes

Agents reprenables : Les agents peuvent être repris avec leur identifiant pour continuer un travail précédent :

> Resume agent abc123 and continue the analysis

Subagents asynchrones (décembre 2025)

Les subagents asynchrones permettent le multitâche et l’exécution parallèle pour les projets à grande échelle :

> Run security review in the background while I continue frontend work
> /tasks                    # Check status of running agents

Les agents asynchrones renvoient les résultats via le TaskOutputTool unifié, permettant des flux de travail efficaces de type pipeline.

Résilience au refus de permissions (v2.1.0+)

À partir de la v2.1.0, les subagents continuent de fonctionner après un refus de permission au lieu de s’arrêter complètement. Lorsqu’un subagent se heurte à un mur de permissions, il essaie automatiquement des approches alternatives. Ce changement rend les flux de travail autonomes plus résilients et réduit le besoin d’intervention humaine.⁴⁷

Agent Teams (février 2026, Research Preview)

Les Agent Teams coordonnent plusieurs instances Claude Code travaillant ensemble. Une session agit comme le team lead, lançant des teammates qui travaillent indépendamment dans leurs propres fenêtres de contexte, communiquant directement entre eux via une boîte aux lettres et une liste de tâches partagées.⁸⁶⁹¹

Contrairement aux subagents (qui s’exécutent au sein d’une seule session et ne rapportent qu’à l’appelant), les teammates sont des sessions indépendantes complètes qui peuvent s’envoyer des messages, contester les conclusions des autres et se coordonner eux-mêmes.

Activation :

// settings.json
{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

Ou via l’environnement : export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

Architecture :

Modes d’affichage :

Configurez dans les paramètres : "teammateMode": "in-process" ou "tmux". Ou par session : claude --teammate-mode in-process.

Contrôles clés : - Shift+Down : parcourir les teammates (mode in-process ; revient au lead après le dernier teammate) - Shift+Tab : activer le delegate mode (restreint le lead à la coordination uniquement, pas de modifications de code) - Ctrl+T : basculer la liste de tâches partagée - Enter sur un teammate : voir sa session ; Escape pour interrompre son tour

Quand utiliser Agent Teams vs subagents :

Meilleurs cas d’utilisation : - Recherche et revue (perspectives multiples simultanément) - Nouveaux modules/fonctionnalités (les teammates possèdent chacun des parties séparées) - Débogage avec hypothèses concurrentes (tester différentes théories en parallèle) - Coordination inter-couches (frontend, backend, tests chacun géré par un teammate différent)

Approbation de plan pour les teammates : pour les tâches complexes ou risquées, exigez que les teammates planifient avant d’implémenter. Le teammate travaille en mode plan lecture seule jusqu’à ce que le lead examine et approuve son approche :

Spawn an architect teammate to refactor the authentication module.
Require plan approval before they make any changes.

Le lead prend les décisions d’approbation de manière autonome. Influencez son jugement avec des critères : « only approve plans that include test coverage » ou « reject plans that modify the database schema ».

Exemples de prompts :

Create an agent team to review PR #142. Spawn three reviewers:
- One focused on security implications
- One checking performance impact
- One validating test coverage

Spawn a team with 4 teammates to refactor these modules in parallel.
Use Sonnet for each teammate.

Stockage : les configurations d’équipe se trouvent dans ~/.claude/teams/{team-name}/config.json (tableau members avec name, agent ID, agent type). Les listes de tâches dans ~/.claude/tasks/{team-name}/. Les tâches supportent les dépendances : les tâches bloquées se débloquent automatiquement lorsque leurs dépendances sont complétées.⁹¹

Intégration des hooks : utilisez les hooks TeammateIdle (code de sortie 2 pour envoyer du feedback et maintenir le teammate actif) et TaskCompleted (code de sortie 2 pour empêcher la complétion) afin d’appliquer des portes de qualité sur les teammates.

Limitations (expérimental) : - Pas de reprise de session pour les teammates in-process (/resume ne les restaurera pas) - Une seule équipe par session ; pas d’équipes imbriquées - Les teammates ne peuvent pas créer leurs propres équipes - Les panneaux divisés nécessitent tmux ou iTerm2 (non supporté dans le terminal VS Code, Windows Terminal ou Ghostty) - Tous les teammates démarrent avec le mode de permission du lead - Intensif en tokens : chaque teammate est une instance Claude séparée

Agent Skills (décembre 2025)

Les Agent Skills sont des dossiers organisés d’instructions, de scripts et de ressources que les agents découvrent et chargent dynamiquement.³¹ Ils fournissent une expertise de domaine composable et portable :

.claude/skills/
├── security-review/
│   ├── skill.md           # Instructions and prompts
│   ├── checklist.md       # Security checklist
│   └── common-vulns.sh    # Detection scripts
└── performance-audit/
    ├── skill.md
    └── profiling-guide.md

Les skills diffèrent des commandes : les commandes sont invoquées explicitement, tandis que les skills s’activent automatiquement en fonction du contexte de la tâche. Le Claude Agent SDK (renommé depuis Claude Code SDK) fournit le cadre pour construire des agents personnalisés avec le support des skills.³²

Qu’est-ce que le mode Extended Thinking ?

Extended thinking donne à Claude plus de temps pour raisonner sur des problèmes complexes avant de répondre. Ce mode est particulièrement utile pour les décisions architecturales, le débogage de problèmes délicats et les tâches nécessitant une analyse approfondie.

État actuel (mars 2026)

Extended thinking est désormais activé par défaut avec un budget de 31 999 tokens.⁷⁰ Anthropic a effectué ce changement car extended thinking améliore significativement les performances sur les tâches complexes de planification et de raisonnement.

Niveaux d’effort (v2.1.68+, simplifié v2.1.72) : Opus 4.6 utilise par défaut un effort moyen pour les abonnés Max et Team — le juste équilibre entre rapidité et exhaustivité. Le niveau d’effort s’affiche dans le logo et le spinner avec des symboles simplifiés : ○ (faible), ◐ (moyen), ● (élevé).¹²¹ Le mot-clé « ultrathink » a été réintroduit pour déclencher le mode effort élevé. Les autres déclencheurs en langage naturel (« think », « think hard », « think harder ») restent obsolètes — utilisez MAX_THINKING_TOKENS ou /config à la place.⁷⁰¹¹⁶

Remarque : Opus 4 et Opus 4.1 ont été retirés de Claude Code sur l’API propriétaire (v2.1.68). Les utilisateurs ayant épinglé ces modèles ont été automatiquement migrés vers Opus 4.6.¹¹⁶

Modèles pris en charge

• Claude Opus 4.6 (prend également en charge adaptive thinking, qui détermine automatiquement la profondeur de raisonnement)
• Claude Sonnet 4.6 (prend également en charge adaptive thinking)
• Claude Opus 4.5
• Claude Sonnet 4.5
• Claude Haiku 4.5

Contrôler Extended Thinking

Basculement rapide pendant une session :

Press Alt+T to toggle thinking on/off

Remarque : Anthropic a modifié le raccourci de basculement du mode thinking de Tab à Alt+T pour éviter les déclenchements accidentels.³⁹

Via /config : Naviguez vers /config → Extended Thinking pour activer/désactiver ou ajuster le budget.

Variable d’environnement (permanent) :

# Set custom budget (default is 31,999)
export MAX_THINKING_TOKENS=8000
claude

# Double the default for complex tasks
export MAX_THINKING_TOKENS=63999
claude

Désactiver pour réduire les coûts : Pour les tâches simples ne nécessitant pas de raisonnement approfondi, vous pouvez réduire les coûts en désactivant thinking dans /config ou en diminuant le budget :

export MAX_THINKING_TOKENS=8000  # Reduce from default 31,999

Budgets de tokens thinking

Considération de coût : Anthropic facture les tokens thinking comme des tokens de sortie. Le budget par défaut de 31 999 convient à la plupart des tâches, mais pour les opérations simples, vous pouvez réduire les coûts en diminuant le budget ou en désactivant complètement thinking.

Fonctionnement

Lorsque thinking est activé, Claude effectue un raisonnement interne qui influence la réponse mais n’apparaît pas dans la sortie. Claude Code chiffre le raisonnement et le renvoie dans un champ signature pour vérification.

Dans les conversations multi-tours avec utilisation d’outils, les blocs thinking doivent être renvoyés à l’API pour préserver la continuité du raisonnement. Claude Code gère cela automatiquement.

Quand envisager de désactiver ou réduire

Extended thinking est désormais le comportement par défaut, mais envisagez de réduire le budget ou de le désactiver pour : - Les modifications de fichiers simples - Le refactoring de routine - Les questions rapides - Le formatage de code - Les opérations à haut volume où les coûts s’accumulent

Comportement du cache

Claude Code préserve la mise en cache du prompt système lorsque les paramètres de thinking changent. Modifier le budget ou l’état d’activation de thinking entre les tours invalide la mise en cache des messages.

Styles de sortie

Les styles de sortie personnalisent la façon dont Claude présente l’information, ce qui est utile pour l’apprentissage, la documentation ou les préférences spécifiques d’une équipe.¹⁹

Styles intégrés

Définir un style de sortie

> /output-style Explanatory
> /output-style Learning

Ou via les paramètres :

{
  "outputStyle": "Explanatory"
}

Styles de sortie personnalisés

Créez-les dans .claude/styles/ :

# my-style

## Instructions
- Always explain the WHY behind each decision
- Include relevant documentation links
- Format code examples with comments
- End with a "What to do next" section

## Format
Use markdown headers for organization.
Keep explanations under 200 words per section.

Invoquez avec /output-style my-style.

Dépréciation (v2.1.73+) : /output-style est obsolète. Utilisez /config pour gérer les styles de sortie à la place.¹²²

Commandes Slash

Les commandes slash offrent un accès rapide aux fonctionnalités de Claude Code et permettent de créer des workflows personnalisés. Elles sont plus rapides que la saisie de prompts complets pour les opérations courantes.

Référence des commandes intégrées

Création de commandes personnalisées

Créez des commandes réutilisables dans .claude/commands/ (projet) ou ~/.claude/commands/ (personnel) :

---
description: Security-focused code review
allowed-tools: Read, Grep, Glob
model: claude-sonnet-4-5
---

Review this code for security vulnerabilities:

1. Injection attacks (SQL, command, XSS)
2. Authentication and authorization flaws
3. Sensitive data exposure
4. Insecure dependencies

Focus on actionable findings with specific line references.

Enregistrez sous .claude/commands/security-review.md, puis invoquez avec /security-review.

Options de frontmatter des commandes

---
description: Brief description for /help
allowed-tools: Read, Edit, Bash(npm:*)
model: opus
argument-hint: [arg1] [arg2]
disable-model-invocation: false
---