TL;DR : Claude Code est un CLI agentique qui lit votre base de code, exécute des commandes et modifie des fichiers à travers un système en couches 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 base de code, exécute des commandes, modifie des fichiers, gère les workflows git, se connecte à des services externes via MCP et délègue 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 GitHub publics (~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 l’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 raisonnement architectural véritable — 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 sur des bases de code en 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 document 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 antérieures 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 reviennent. Orientez les subagents vers des niveaux de modèle moins coûteux pour l’exploration, ou utilisez votre modèle principal tout au long si la qualité prime sur 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 regroupent tout cela pour la distribution.

L’insight clé : la plupart des utilisateurs travaillent entièrement dans la couche principale, observant le contexte gonfler et les coûts grimper. Les utilisateurs avancés déportent l’exploration et le travail spécialisé vers la couche de délégation, gardent 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. Exploration approfondie du système de configuration
5. Quel modèle choisir ?
6. Combien coûte Claude Code ?
7. Cadres de décision
8. Comment fonctionne le système de permissions ?
9. Comment fonctionnent les hooks ?
10. Qu’est-ce que MCP (Model Context Protocol) ?
11. Que sont les subagents ?
12. Qu’est-ce que le mode Extended Thinking ?
13. Styles de sortie
14. 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. Comment fonctionne l’intégration Git ?
20. Comment utiliser Claude Code dans mon IDE ?
21. Schémas d’utilisation avancée
22. Agents distants et en arrière-plan [APERÇU RECHERCHE]
23. Claude in Chrome
24. Claude Code in Slack [APERÇU RECHERCHE]
25. Optimisation des performances
26. Comment déboguer les problèmes ?
27. Déploiement en entreprise
28. Référence des raccourcis clavier
29. Bonnes pratiques
30. Recettes de flux de travail
31. Guide de migration
32. Conseils par profil d’utilisateur
33. Carte de référence rapide
34. Journal des modifications
35. 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 4 Go de RAM minimum et une connexion internet active.⁹⁹ La compatibilité shell est optimale avec Bash, Zsh ou Fish.

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

apk add libgcc libstdc++ ripgrep
export USE_BUILTIN_RIPGREP=0

Méthodes d’installation

Installation native (recommandée)

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

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

# Homebrew alternative
brew install --cask claude-code

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

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

Pour une installation de version spécifique :

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

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

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

Installation NPM (obsolète)

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 avez 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 fournit 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 de travail, mais vous pouvez surveiller l’utilisation.

Abonnement Claude Pro ou Max

Utilisez les identifiants de votre compte claude.ai. L’abonnement couvre à la fois l’interface web et l’utilisation du CLI dans 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

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

Gestion de l’authentification (v2.1.41+)

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

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

Flux de travail courant pour changer de compte ou d’organisation :

claude auth logout && claude auth login

Voir aussi : Comment déboguer les problèmes ? pour le dépannage des échecs d’authentification.

Mises à jour

Claude Code se met à jour automatiquement par défaut, 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. Installer et lancer :

claude                           # Launch in current directory

2. Naviguer vers un projet :

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

3. Demander à Claude de faire quelque chose :

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

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

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

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

Modes d’interaction principaux

REPL interactif

Lancez Claude Code sans arguments pour accéder à 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’à quitter avec /exit ou Ctrl+D.

Commencez avec un prompt initial pour cibler la session :

claude "explain the authentication flow in this project"

Astuce d’expert : Le REPL conserve son état entre les événements de compaction. Lorsque le contexte devient trop volumineux, Claude résume automatiquement les échanges antérieurs tout en préservant les décisions clés et les extraits de code. Vous pouvez déclencher cette opération manuellement avec /compact ou ajouter des instructions personnalisées pour définir ce qui doit être conservé.

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

Patron d’intégration CI/CD :

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

Gestion des sessions

Les sessions conservent l’historique de conversation pour pouvoir les reprendre. La persistance des sessions est essentielle pour les travaux complexes répartis sur plusieurs sessions :

# Continue most recent session
claude -c

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

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

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

Sessions liées aux PR (v2.1.27+) : 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 (déc. 2025) : Nommez et gérez vos sessions pour les retrouver facilement :

# Name current session
> /rename auth-refactor

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

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

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

Claude Code stocke les sessions sous forme de transcriptions JSONL. L’exécution de l’agent attribue des valeurs agentId uniques, les transcriptions étant 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 — aucune modification de fichier, aucune exécution Bash, aucune action destructive. Claude conçoit une approche d’implémentation, la rédige dans un fichier de plan et attend votre approbation avant d’exécuter quoi que ce soit.

Accéder au mode Plan :

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

# 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 validation
5. Vous approuvez, demandez des modifications ou rejetez

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

Après l’approbation du plan (v2.1.32+) : Claude propose trois options : - « Oui, réinitialiser le contexte et accepter automatiquement les modifications » (Shift+Tab) — repart à zéro avec le contexte complet du plan - « Oui, 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 vierge, ce qui améliore considérablement 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 valider l’approche au préalable - Codebases inconnus où l’exploration doit précéder toute modification - Toute tâche pour laquelle plusieurs approches valides existent et où vous souhaitez un avis

Astuce d’expert : Plus vous passez de temps en mode Plan, plus Claude a de chances de réussir l’implémentation. Le mode Plan est essentiellement une exploration gratuite — aucun appel d’outil risqué, aucune modification gaspillée. Utilisez-le généreusement.

Exploration approfondie du système de configuration

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

Hiérarchie de configuration

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

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]

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

CLAUDE_CODE_ACCOUNT_UUID=uuid                  # Provide account UUID synchronously for SDK callers
CLAUDE_CODE_USER_EMAIL=[email protected]        # Provide user email for SDK callers
CLAUDE_CODE_ORGANIZATION_UUID=uuid             # Provide organization UUID for SDK callers

Débogage :

ANTHROPIC_LOG=debug                             # Enable API request logging

Quel modèle choisir ?

Choisir le bon modèle pour chaque tâche a un impact 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 (bêta), une sortie maximale de 128K, le raisonnement adaptatif et les agent teams.⁸⁶ Même tarification qu’Opus 4.5 (5 $/25 $ par MTok). Le contexte long (>200K en entrée) coûte 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é remplaçant 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 de recherche agentique améliorées 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. Date de coupure des 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 historique.¹⁰⁰

Pourquoi ces différences de prix comptent : Une session de programmation typique consomme 50K à 200K tokens en entrée et 10K à 50K tokens en sortie. Avec Haiku, cela revient à 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 véritablement complexes.¹

Quand utiliser chaque modèle

Haiku : À utiliser pour les subagents d’exploration, les recherches de fichiers simples, 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 où un raisonnement approfondi n’est pas nécessaire.

Sonnet : Le modèle de référence pour le développement quotidien. Gère la plupart des tâches de programmation efficacement : implémentation de fonctionnalités, correction de bugs, écriture de tests, 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 la prise en charge du raisonnement adaptatif et la fenêtre de contexte 1M en bêta.¹⁰⁰

Opus : À réserver pour le raisonnement véritablement 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 une avancée majeure : il planifie plus soigneusement, maintient les tâches agentiques plus longtemps, fonctionne de manière plus fiable dans les grandes bases de code et détecte mieux ses propres erreurs lors des revues 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 de réflexion. Selon Anthropic, sur Terminal-Bench 2.0, Opus 4.6 obtient le score de programmation agentique le plus élevé de l’industrie. Sur GDPval-AA (travail intellectuel à valeur économique), Anthropic rapporte qu’il surpasse GPT-5.2 d’environ 144 points Elo.⁸⁶ Remarque : Les utilisateurs de l’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é compte). Excellent pour le refactoring complexe quand 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 with 1M context (beta)

Ou en cours de session :

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

Opus 4.6 est le premier modèle de classe Opus avec un support natif du contexte 1M. Il atteint 76 % de précision sur la variante 8-needle 1M de 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 lorsque >200K tokens en entrée). 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 actuel, les informations du compte, les paramètres appliqués et d’autres états 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 exemple « 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 significativement plus rapide du même modèle ; il ne bascule pas vers un modèle moins cher. Activez-le en cours de session avec /fast.⁹³

> /fast            # Toggle fast mode on/off

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 de plus de 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 le prompt caching 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 standard où la rapidité compte plus que le coût - Traitement séquentiel d’une liste de tâches similaires

Quand NE PAS utiliser le mode rapide : - Tâches agentiques de longue durée (le coût s’accumule rapidement à 6x le tarif) - Travail de subagents en arrière-plan (personne n’attend le résultat) - Sessions à 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 désormais 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

Formules 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 des tokens 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 du cache). En cas de dépassement, Anthropic facture tous les tokens au tarif contexte long.¹

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

Le prompt caching réduit considérablement les coûts d’entrée répétés : les écritures en cache coûtent 1,25× le tarif de base (cache de 5 min) ou 2× (cache de 1 h), mais les lectures du 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étitif, la mise en cache peut réduire les coûts de 88 à 95 %.

Le Batch API 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 de nuit.

Politique de 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 IP/le même réseau sont explicitement pris en charge - Les comptes sont entièrement séparés ; aucun transfert de conversations ou de projets entre eux

Ce qui est interdit (conformément à 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 échapper à la détection - Utiliser plusieurs comptes pour contourner les limites de débit ou les crédits de l’offre gratuite

Exemple concret : En janvier 2026, 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 faire 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 cachés des outils

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

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

Stratégies de réduction des coûts

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

Suivi de l’utilisation

• Console Claude : platform.claude.com (nécessite le rôle Admin ou Billing)
• Limites de workspace : définir des limites de dépenses par workspace
• Bedrock/Vertex : utiliser le suivi natif 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.

Claude Code Analytics API (Team/Enterprise)⁵³

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

Point de terminaison : GET /v1/organizations/usage_report/claude_code

Prérequis : - Clé Admin API (sk-ant-admin...) - Forfait 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 garantir la cohérence.

Cadres de décision

Connaître l’existence des fonctionnalités ne suffit pas. Vous devez savoir quand utiliser chacune d’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 agent teams (v2.1.32+), Opus peut coordonner plusieurs agents travaillant en parallèle sur différentes sous-tâches.⁸⁶

Commande, skill, subagent ou agent team ?

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

Hook ou prompt ?

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

Quand utiliser la réflexion é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 davantage ; commencez au minimum et n’augmentez que 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 plus 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

Agent teams 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 pouvant être exécutées. Le comprendre est essentiel tant pour la sécurité que pour l’efficacité de votre flux de travail. Consultez également Enterprise Deployment 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)²⁵

Fonctionnalités de l’outil LSP (v2.0.74+) : L’outil LSP fournit une intelligence de code similaire à 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 la base de 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 du 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

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

Modes de permissions

YOLO Mode (v2.0.68+) : Pour un fonctionnement entièrement autonome, utilisez le flag --dangerously-skip-permissions. Ce flag accepte tout automatiquement : 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 à la base de code.⁶¹

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 correspondent uniquement 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 - Absolu depuis le fichier de paramètres : Edit(/build/**) - relatif à l’emplacement du fichier de paramètres - Véritablement absolu : 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.³⁹ La syntaxe avec caractère générique est utile pour activer rapidement tous les outils de serveurs de confiance ou bloquer des serveurs entiers provenant de sources 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 actuel :

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

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 excellent pour exécuter Claude sur des bases de code non fiables. Activez-le lorsque vous explorez des projets inconnus ou lorsque vous 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 est entièrement contenue. Anthropic a publié en open source le runtime du sandbox pour les équipes qui construisent leurs propres agents.⁸⁹

Notes de sécurité (v2.1.34+) : Les commandes exclues du sandboxing via sandbox.excludedCommands ou dangerouslyDisableSandbox pouvaient auparavant contourner la règle de permission Bash lorsque autoAllowBashIfSandboxed était activé ; cela a été corrigé dans la v2.1.34.⁹⁴ À partir de 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.⁹⁵

Comment fonctionnent les hooks ?

Les hooks exécutent des commandes shell déterministes à des points spécifiques du flux de travail de Claude Code. Contrairement au fait de demander à Claude d’effectuer des actions via des prompts, 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 Cadres de décision pour l’arbre de décision « Quel type de hook ? » couvrant les hooks de commande, de prompt et d’agent.

Pourquoi des hooks plutôt que des prompts : Dire à Claude « exécute toujours Prettier après avoir modifié des fichiers » fonctionne parfois. Mais Claude peut oublier, privilégier la rapidité, ou décider 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"
}

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

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

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 standard devient le message d’erreur transmis à Claude. - 1, 3, etc. : Erreur non bloquante : l’opération continue. La sortie d’erreur standard est affichée comme avertissement en mode verbeux.

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

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

Contrôle de décision PreToolUse (format préféré) : Les hooks PreToolUse utilisent hookSpecificOutput pour un contrôle plus riche : trois issues possibles (allow/deny/ask) plus 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."
  }
}

Note : Les champs de niveau supérieur decision et reason sont dépréciés pour PreToolUse. Utilisez hookSpecificOutput.permissionDecision et hookSpecificOutput.permissionDecisionReason à la place. 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 se terminer 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 en utilisant le raisonnement IA plutôt que des scripts.⁹⁶

Les hooks 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 une 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 (retournent du JSON avec decision et reason). Ils sont routés via le proxy réseau du sandbox lorsque le sandboxing est activé. Non pris en charge pour les événements SessionStart/Setup.

Les hooks 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 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êtes. Les hooks HTTP sont également routés via le proxy réseau du sandbox 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 hooks 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

Formater automatiquement les fichiers TypeScript après modification :

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

Journaliser toutes les commandes bash :

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

Bloquer l’accès aux fichiers sensibles :

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

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

Exécuter les tests après les modifications du 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 diagnostiquer les 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)

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

Les hooks peuvent être définis directement dans les Skills, subagents et commandes slash 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 commandes slash uniquement) garantit que le hook ne s’exécute qu’une seule fois par session, ce qui est utile pour les tâches de nettoyage ou de finalisation.

Stratégie pour les sessions longues

Pour les sessions Claude Code nocturnes ou sans surveillance, configurez des hooks pour maintenir Claude sur la bonne voie sans intervention manuelle. L’idée clé : utilisez les hooks de linting et de tests 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éalable : Utilisez un hook Setup pour vérifier que l’environnement est prêt
2. Validation continue : Les hooks PostToolUse exécutent les tests après chaque modification
3. Contrôle de complétion : Les hooks Stop vérifient tous les critères d’acceptation avant que Claude ne déclare « terminé »
4. Notification : Les hooks Stop peuvent vous notifier via Slack/Pushover lorsque Claude a terminé ou est 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 en lui donnant 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 manière dont les outils d’IA se connectent aux services externes, empêchant 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 authentification native OAuth.²⁸ 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 rafraîchissement des jetons.

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

Connecteurs MCP claude.ai (v2.1.46+)

Claude Code peut désormais utiliser les connecteurs MCP configurés dans votre compte claude.ai. Cela fait le lien 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 les reconfigurer localement.¹⁰²

Désactivation : Définissez ENABLE_CLAUDEAI_MCP_SERVERS=false dans votre environnement ou dans le bloc env de settings.json pour empêcher le chargement des serveurs MCP de 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 jetons : 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 au démarrage) - auto:N — Activer lorsque les outils dépassent N % du contexte (0-100)

Conseil d’expert : Avec la recherche d’outils activée, vous pouvez 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 étaient auparavant en concurrence pour le contexte coexistent désormais harmonieusement.

Assistant interactif de configuration MCP

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, qui 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 jetons - Maximum par défaut : 25 000 jetons

Augmentez si nécessaire :

export MAX_MCP_OUTPUT_TOKENS=50000

Serveurs MCP populaires

Patrons pratiques MCP

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 en 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é les MCP Apps, une extension du Model Context Protocol qui permet des interfaces utilisateur interactives directement dans l’interface Claude.⁷⁸ Les MCP Apps permettent 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 les MCP Apps apparaissent actuellement dans l’interface web de claude.ai, les extensions du 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 original limité à Python par l’exécution de commandes Bash et la manipulation directe de fichiers.⁷⁹ Changements clés : - Exécution de commandes Bash (pas seulement Python) dans des conteneurs isolés - Écriture et exécution de code dans n’importe quel langage - Appel programmatique d’outils (également en bêta publique) : Claude peut appeler des outils depuis l’exécution de code, réduisant la latence et la consommation de jetons dans les workflows multi-outils

L’outil v2 concerne 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 conseils 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 sessions longues, le contexte se remplit, Claude perd le fil 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 de manière séquentielle.²

Fonctionnement des subagents

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

1. Démarre avec un contexte vierge (pas de pollution depuis 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 en lecture seule - Outils : Glob, Grep, Read, et commandes bash sûres (ls, git status, git log, git diff, find, cat, head, tail) - Niveaux de minutie : rapide, moyen, très approfondi - Utilisation : exploration du codebase, recherche de fichiers, compréhension de la structure

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

Plan : - Modèle : Sonnet (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 d’expert : pour les tâches complexes, demandez explicitement la délégation à un subagent. « Use an explore agent to find… » empêche l’engorgement 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 invocables (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é 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 par CLI (v2.1.32+)

Définissez des subagents en tant que JSON au lancement pour des tests rapides ou l’automatisation. Ceux-ci n’existent que pour la session et ne sont pas enregistré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 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               # Voir tous les subagents

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

claude agents                # Shows agents grouped by source (built-in, user, project, plugin)

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

claude remote-control        # Start serving local environment for external builds

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

Pour les tâches de longue durée :

> Run a thorough security review in the background

> /agents  # Check status of running agents

Récupérez les résultats ultérieurement avec l’identifiant de l’agent.

Patterns avancés

Subagents chaînés :

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

Exploration en parallèle :

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

Agents résumables : 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 de grande envergure :

> 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 aux refus de permission (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 rendent compte qu’à l’appelant), les teammates sont des sessions indépendantes complètes qui peuvent s’envoyer des messages, remettre en question les conclusions des autres et se coordonner d’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 :

Configuration 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 les Agent Teams vs les subagents :

Meilleurs cas d’utilisation : - Recherche et revue (perspectives multiples simultanément) - Nouveaux modules/fonctionnalités (les teammates possèdent chacun des parties distinctes) - 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 de membres avec nom, identifiant d’agent, type d’agent). 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 terminées.⁹¹

Intégration des hooks : utilisez les hooks TeammateIdle (code de sortie 2 pour envoyer un retour et maintenir le teammate actif) et TaskCompleted (code de sortie 2 pour empêcher la complétion) afin d’appliquer des portes de qualité aux 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 scindé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 - Consommation intensive de 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 framework pour construire des agents personnalisés avec le support des skills.³²

Qu’est-ce que le mode Extended Thinking ?

L’Extended Thinking accorde à Claude plus de temps pour raisonner sur des problèmes complexes avant de répondre. C’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 (janvier 2026)

L’Extended Thinking est désormais activé par défaut avec un budget de 31 999 tokens, le budget maximum qui était auparavant déclenché par « ultrathink ».⁷⁰ Anthropic a effectué ce changement car l’Extended Thinking améliore significativement les performances sur les tâches complexes de planification et de raisonnement.

Important : Les déclencheurs en langage naturel comme « think », « think hard », « think harder » et « ultrathink » ne fonctionnent plus. Claude interprète désormais ces mots-clés comme des instructions de prompt ordinaires et n’alloue pas de tokens de réflexion. Le budget de réflexion est contrôlé exclusivement par la variable d’environnement MAX_THINKING_TOKENS ou via /config.⁷⁰

Modèles pris en charge

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

Contrôler l’Extended Thinking

Basculement rapide pendant une session :

Press Alt+T to toggle thinking on/off

Remarque : Anthropic a changé le raccourci de basculement de la réflexion de Tab à Alt+T pour éviter les déclenchements accidentels.³⁹

Via /config : Accédez à /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 où un raisonnement approfondi n’est pas nécessaire, vous pouvez réduire les coûts en désactivant la réflexion dans /config ou en diminuant le budget :

export MAX_THINKING_TOKENS=8000  # Reduce from default 31,999

Budgets de tokens de réflexion

Considération de coût : Anthropic facture les tokens de réflexion comme des tokens de sortie. Le budget par défaut de 31 999 convient bien à 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 entièrement la réflexion.

Fonctionnement

Lorsque la réflexion est activée, Claude effectue un raisonnement interne qui influence la réponse mais n’apparaît pas dans la sortie. Claude Code chiffre la réflexion et la renvoie dans un champ signature à des fins de vérification.

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

Quand envisager de désactiver ou réduire le budget

L’Extended Thinking est désormais activé par défaut, mais envisagez de réduire le budget ou de le désactiver pour : - Les modifications simples de fichiers - Le refactoring de routine - Les questions rapides - Le formatage de code - Les opérations à fort 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 réflexion changent. Modifier le budget de réflexion ou le statut d’activation 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 les informations, 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.

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 de taper des 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, invoquez avec /security-review.

Options du frontmatter des commandes

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

Interpolation des arguments

Tous les arguments sous forme de chaîne unique :

---
description: Fix GitHub issue
argument-hint: [issue-number]
---

Fix GitHub issue #$ARGUMENTS following our coding standards.

Utilisation : /fix-issue 123

Arguments numérotés :

---
description: Create component
argument-hint: [name] [type]
---

Create a new $2 component named $1 in src/components/.

Utilisation : /create-component Button functional

Exécution Bash en ligne

Exécutez des commandes bash dans les prompts de commande :

---
description: Git status summary
allowed-tools: Bash(git:*)
---

Current branch: !`git branch --show-current`
Recent commits: !`git log --oneline -5`
Changed files: !`git status --short`

Summarize the current state of this repository.

Références de fichiers

Incluez le contenu de fichiers dans les commandes :

---
description: Compare implementations
---

Compare these files:
@src/v1/handler.ts
@src/v2/handler.ts

Which implementation is more maintainable?

Espaces de noms des commandes

Organisez les commandes dans des sous-répertoires :

.claude/commands/
├── backend/
│   ├── test.md
│   └── deploy.md
├── frontend/
│   ├── test.md
│   └── build.md
└── review.md

Les commandes portant le même nom affichent leur espace de noms dans l’aide : /test (project:backend) vs /test (project:frontend).

Comment fonctionnent les Skills ?

Les Skills représentent une approche fondamentalement différente pour étendre Claude Code. Contrairement aux commandes slash que vous invoquez explicitement, les Skills sont invoquées par le modèle — Claude les découvre et les utilise automatiquement en fonction du contexte. Vous intégrez une expertise métier dans un skill, et Claude s’appuie sur cette expertise chaque fois que la situation l’exige, sans que vous ayez besoin de penser à le demander.

Pourquoi les Skills changent tout : Considérez l’expertise métier : les règles de traitement des paiements, les exigences de conformité, les patterns architecturaux que votre équipe a affinés au fil des années. Sans les Skills, vous devez soit réexpliquer ce contexte à chaque session, soit espérer que Claude le déduise des commentaires dans le code. Avec les Skills, vous l’encodez une seule fois. Claude lit la définition du skill et applique cette expertise automatiquement chaque fois qu’elle est pertinente. Vos développeurs juniors bénéficient de conseils de niveau senior sans avoir à les demander. Vos patterns de sécurité sont appliqués sans avoir besoin de s’en souvenir.

La distinction est importante. Une commande slash est un raccourci que vous pensez à utiliser. Un skill est une connaissance que Claude a toujours à disposition. Lorsque vous créez un skill de revue de sécurité intégrant les patterns de vulnérabilités spécifiques à votre équipe et vos exigences de conformité, Claude applique cette expertise chaque fois qu’il rencontre du code pertinent, que ce soit lors de revues de PR, de refactoring ou de toute tâche où la sécurité compte. Vous n’invoquez pas /security-review ; Claude reconnaît le contexte et applique le skill automatiquement.

Skills vs Commandes vs Subagents

Comprendre quand utiliser chaque mécanisme d’extension évite les doublons et maximise l’efficacité :

Utilisez les commandes slash lorsque vous souhaitez un contrôle explicite : /deploy, /test, /review PR 456. C’est vous qui décidez quand les exécuter.

Utilisez les Skills lorsque l’expertise doit s’activer automatiquement : patterns de sécurité, application du style de code, connaissances spécifiques au domaine. C’est Claude qui décide quand les appliquer.

Utilisez les subagents lorsque les tâches nécessitent une isolation : exploration en arrière-plan, analyse parallèle, raisonnement spécialisé qui ne doit pas polluer votre conversation principale.

Structure et emplacement des Skills

Les Skills résident dans des répertoires dédiés contenant un fichier SKILL.md obligatoire ainsi que des ressources de support optionnelles :

Skills personnels (disponibles dans tous vos projets) :

~/.claude/skills/
├── code-reviewer/
│   ├── SKILL.md
│   ├── SECURITY_PATTERNS.md
│   └── PERFORMANCE_CHECKLIST.md
├── sql-analyst/
│   ├── SKILL.md
│   └── QUERY_PATTERNS.md
└── api-designer/
    └── SKILL.md

Skills de projet (partagés avec l’équipe via git) :

.claude/skills/
├── domain-expert/
│   ├── SKILL.md
│   ├── BUSINESS_RULES.md
│   └── DATA_MODELS.md
└── deployment/
    ├── SKILL.md
    └── RUNBOOKS.md

Les Skills de projet sont versionnés dans le contrôle de source. Lorsque vos coéquipiers font un pull, ils obtiennent automatiquement vos Skills — pas d’installation, pas de configuration. La distribution automatique standardise l’expertise au sein de l’équipe.

Format de SKILL.md

Chaque skill nécessite un fichier SKILL.md avec un frontmatter YAML :

---
name: code-reviewer
description: Review code for security vulnerabilities, performance issues, and best practice violations. Use when examining code changes, reviewing PRs, analyzing code quality, or when asked to review or audit code.
allowed-tools: Read, Grep, Glob
---

# Code Review Expertise

## Security Analysis

When reviewing code, check for:

### Input Validation
- All user input sanitized before use
- Parameterized queries for database operations
- Output encoding for rendered content

### Authentication & Authorization
- Session tokens properly validated
- Permission checks before sensitive operations
- No hardcoded credentials or API keys

### Data Exposure
- Sensitive data not logged
- PII properly masked in error messages
- API responses don't leak internal details

## Performance Patterns

### Database
- N+1 query detection
- Missing indexes on filtered columns
- Unbounded result sets

### Memory
- Large object lifecycle management
- Stream processing for big files
- Connection pool exhaustion risks

## Review Output Format

For each finding:
- **File**: path/to/file.ts:123
- **Severity**: Critical | High | Medium | Low
- **Category**: Security | Performance | Maintainability
- **Issue**: Clear description of the problem
- **Recommendation**: Specific fix with code example
- **Rationale**: Why this matters

See [SECURITY_PATTERNS.md](SECURITY_PATTERNS.md) for detailed vulnerability patterns.
See [PERFORMANCE_CHECKLIST.md](PERFORMANCE_CHECKLIST.md) for optimization guidelines.