Claude Code fonctionne comme un système agentique, et non comme une interface de chat dotée de connaissances en programmation. Le CLI analyse votre codebase, exécute des commandes, modifie des fichiers, gère les workflows git, se connecte à des services externes via MCP et délègue les tâches complexes à des subagents spécialisés. Tout passe par une interface en ligne de commande qui s’intègre à la manière dont les développeurs travaillent réellement.

La différence entre une utilisation superficielle 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 — encadre 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 multi-étapes

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

Comment fonctionne Claude Code : le modèle mental

Avant d’explorer les fonctionnalités, comprenez comment l’architecture de Claude Code influence tout ce que vous faites avec. Le système fonctionne sur 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 │
└─────────────────────────────────────────────────────────┘

Core Layer : votre conversation principale. Chaque message, lecture de fichier et sortie d’outil consomme du contexte dans une fenêtre partagée de 200K tokens (1M avec l’offre premium). 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.

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. Utilisez les subagents Haiku pour l’exploration (économique, rapide) et Sonnet pour l’implémentation.

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 le Core Layer, regardant le contexte gonfler et les coûts grimper. Les utilisateurs avancés délèguent l’exploration et le travail spécialisé au Delegation Layer, gardent l’Extension Layer configuré pour leur flux de travail, et n’utilisent le Core Layer que pour l’orchestration et les décisions finales.

Table des matières

1. Comment installer Claude Code ?
2. Modes d’interaction principaux
3. Exploration approfondie du système de configuration
4. Quel modèle choisir ?
5. Comment fonctionne le système de permissions ?
6. Comment fonctionnent les hooks ?
7. Qu’est-ce que MCP (Model Context Protocol) ?
8. Que sont les subagents ?
9. Qu’est-ce que le mode Extended Thinking ?
10. Styles de sortie
11. Commandes slash
12. Comment fonctionnent les skills ?
13. Système de plugins
14. Comment fonctionne la mémoire ?
15. Images et entrées multimodales
16. Comment fonctionne l’intégration Git ?
17. Comment utiliser Claude Code dans mon IDE ?
18. Patterns d’utilisation avancés
19. Qu’est-ce que Claude Code Remote ?
20. Que sont les Background Agents ?
21. Claude in Chrome
22. Claude Code in Slack
23. Combien coûte Claude Code ?
24. Optimisation des performances
25. Comment déboguer les problèmes ?
26. Déploiement en entreprise
27. Référence des raccourcis clavier
28. Bonnes pratiques

Comment installer Claude Code ?

Configuration système requise

Claude Code fonctionne sur macOS 10.15+, Ubuntu 20.04+/Debian 10+, et Windows 10+ via WSL ou Git Bash. Le système nécessite au minimum 4 Go de RAM et une connexion internet active. La compatibilité shell fonctionne mieux avec Bash, Zsh ou Fish.

Pour Windows, WSL 1 et WSL 2 fonctionnent tous 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 fluide sans dépendance à Node.js :

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

# Homebrew alternative
brew install --cask claude-code

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

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

Pour 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 (dépréciée)

Note : Depuis la version 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 legacy 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 chemins d’authentification, chacun 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. Cela fournit une facturation à l’usage avec un accès complet à l’API. Un workspace « Claude Code » dédié est créé automatiquement — vous ne pouvez pas créer de clés API pour ce workspace, 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 sous un seul forfait mensuel. Cela 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 des relations de facturation cloud existantes :

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

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

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

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

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

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

Vérification

claude doctor

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

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

Modes d’interaction principaux

REPL interactif

Lancez Claude Code sans arguments pour entrer dans la boucle interactive lecture-évaluation-affichage :

cd your-project
claude

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

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

claude "explain the authentication flow in this project"

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

Mode non interactif

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

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

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

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

Pour obtenir 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 '.result // empty'
done

Gestion des sessions

Les sessions conservent l’historique des conversations pour permettre leur reprise. C’est essentiel 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"

Créez des sessions reproductibles avec des identifiants explicites :

claude --session-id "feature-auth-$(date +%s)"

Astuce d’expert : Utilisez des identifiants de session qui encodent le contexte : feature-${branch}-${timestamp} ou bug-JIRA-123. Lorsque vous revenez plusieurs jours plus tard, l’identifiant vous rappelle l’objet de la session. Consultez les sessions disponibles dans le REPL avec /resume.

Les sessions sont stockées sous forme de transcriptions JSONL. L’exécution d’un agent se voit attribuer des valeurs agentId uniques, et les transcriptions sont stockées sous la forme agent-{agentId}.jsonl. La reprise préserve l’intégralité du contexte des conversations précédentes.

Sessions nommées (déc. 2025) : Nommez et gérez vos sessions plus facilement :

# Name current session
> /rename my-feature-work

# Resume by name or number
> /resume 1                    # Resume first session
> /resume my-feature-work      # Resume by name
claude --resume 3              # Resume from terminal

# Fork with custom session ID
claude --session-id "new-exploration" --resume "base-session" --fork-session

Système de configuration en profondeur

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

Hiérarchie de configuration

Astuce d’expert : Utilisez .claude/settings.local.json pour vos préférences personnelles dans les projets partagés — ce fichier devrait figurer dans .gitignore. Utilisez .claude/settings.json pour la configuration commune à l’équipe, versionnée dans le contrôle de source.

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

Une configuration exhaustive 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"]
}

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-5                 # Override default model
ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-4-5-20251101
ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-4-5-20250929-v1:0
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

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]

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

Pourquoi ces différences de prix comptent : Une session de développement typique consomme 50K-200K tokens en entrée et 10K-50K tokens en sortie. Avec Haiku, cela représente 0,10 $-0,45 $ par session. Avec Opus, la même session coûte 0,50 $-2,25 $—5 fois plus. Réservez Opus aux problèmes véritablement difficiles.¹

Quand utiliser chaque modèle

Haiku : Utilisez-le pour les subagents effectuant de l’exploration, des recherches de fichiers simples, des questions rapides. Il est 10-20 fois moins cher qu’Opus et répond plus vite. Parfait pour les tâches en arrière-plan où vous n’avez pas besoin d’un raisonnement approfondi.

Sonnet : Le cheval de bataille du développement quotidien. Gère bien la plupart des tâches de codage : implémentation de fonctionnalités, correction de bugs, écriture de tests, revue de code. Utilisez-le comme modèle par défaut.

Opus : Réservez-le au raisonnement véritablement complexe : décisions architecturales, débogage délicat, compréhension de systèmes complexes, analyse de sécurité. La différence de qualité est réelle pour les problèmes difficiles, mais le coût l’est aussi. Opus 4.5 atteint 80,9 % sur SWE-bench Verified tout en réduisant de moitié l’utilisation de tokens par rapport à ses prédécesseurs.⁴⁵ Note : Les utilisateurs avec un abonnement Pro ont désormais accès à Opus 4.5 dans le cadre de leur abonnement.²⁰

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

Changer de modèle

Pendant la session :

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

Au démarrage :

claude --model opus

Via l’environnement :

export ANTHROPIC_MODEL=opus

Dans settings.json :

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

Pour les subagents spécifiquement :

export CLAUDE_CODE_SUBAGENT_MODEL=haiku

Contexte étendu

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

claude --model sonnet[1m]

Ou pendant une session :

> /model anthropic.claude-sonnet-4-5-20250929-v1:0[1m]

Le contexte étendu coûte plus cher par token. Utilisez-le quand vous en avez vraiment besoin, pas comme paramètre par défaut.

Vérifier le modèle actuel

> /status

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

Cadres de décision

Connaître l’existence des fonctionnalités ne suffit pas—vous devez savoir quand utiliser chacune. Ces arbres de décision transforment la connaissance en action.

Quel modèle utiliser ?

DÉBUT → La tâche est-elle simple ? (recherche de fichiers, question rapide, formatage)
         │
         ├── OUI → Utilisez Haiku
         │         Coût : ~0,03 $/tâche
         │         Vitesse : La plus rapide
         │
         └── NON → Nécessite-t-elle un raisonnement approfondi ?
                  (architecture, débogage complexe, analyse de sécurité)
                  │
                  ├── OUI → Utilisez Opus
                  │         Coût : ~2,00 $/tâche
                  │         Qualité : La plus élevée
                  │
                  └── NON → Utilisez Sonnet (par défaut)
                           Coût : ~0,75 $/tâche
                           Équilibre : Meilleur compromis

Règle générale : Commencez avec Sonnet. Passez à Haiku pour les subagents. Passez à Opus uniquement quand la réponse de Sonnet vous semble superficielle.

Commande, skill ou subagent ?

Voulez-vous un contrôle explicite sur le moment d'exécution ?
│
├── OUI → Utilisez une commande slash
│         Exemple : /deploy, /test, /security-review
│         Vous l'invoquez. Vous contrôlez le timing.
│
└── NON → L'expertise doit-elle s'appliquer automatiquement selon le contexte ?
         │
         ├── OUI → Utilisez un skill
         │         Exemple : Patterns de sécurité, règles métier, standards de code
         │         Claude reconnaît le contexte et applique l'expertise.
         │
         └── NON → Le travail nécessite-t-il un contexte isolé ?
                  │
                  ├── OUI → Utilisez un subagent
                  │         Exemple : Exploration approfondie, analyse parallèle
                  │         Évite l'engorgement du contexte dans la conversation principale.
                  │
                  └── NON → Promptez directement
                           Tout n'a pas besoin d'abstraction.

Hook ou prompt ?

L'action DOIT-ELLE toujours se produire, quel que soit le jugement de Claude ?
│
├── OUI → Utilisez un hook (déterministe)
│         Exemples :
│         - Formater le code après chaque modification
│         - Logger toutes les commandes bash
│         - Bloquer l'accès aux fichiers .env
│         Claude ne peut pas l'ignorer, l'oublier ou décider autrement.
│
└── NON → Utilisez un prompt (probabiliste)
         Exemples :
         - « Envisagez d'ajouter des tests »
         - « Pensez aux cas limites »
         - « Vérifiez la sécurité si pertinent »
         Claude décide en fonction du contexte.

Quand utiliser la réflexion étendue ?

Est-ce un problème véritablement difficile ?
│
├── Décision architecturale avec de nombreux compromis → OUI, utilisez la réflexion
├── Débogage complexe avec cause racine incertaine → OUI, utilisez la réflexion
├── Analyse de sécurité nécessitant un raisonnement minutieux → OUI, utilisez la réflexion
├── Compréhension d'une base de code inconnue → OUI, utilisez la réflexion
│
├── Correction de bug routinière → NON, ignorez la réflexion
├── Refactoring simple → NON, ignorez la réflexion
├── Formatage de code → NON, ignorez la réflexion
└── Questions rapides → NON, ignorez la réflexion

Basculez avec Tab pendant la session. Les budgets de réflexion plus élevés coûtent plus cher—commencez avec le minimum et augmentez uniquement si les réponses vous semblent précipitées.

Comment fonctionne le système de permissions ?

Le système de permissions de Claude Code offre un contrôle granulaire sur les opérations autorisées. Le comprendre est essentiel tant pour la sécurité que pour l’efficacité du flux de travail.

Niveaux de permission

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

Capacités de l’outil LSP (v2.0.74+) : L’outil LSP fournit une intelligence de code similaire à celle d’un IDE : - Aller à la définition : Accéder à l’endroit où un symbole est défini - Trouver les références : Lister toutes les utilisations d’un symbole dans 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 avec 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’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 session sauf configuration contraire explicite.

Modes de permission

Mode YOLO (v2.0.68+) : Pour un fonctionnement entièrement autonome, utilisez le flag --dangerously-skip-permissions. Cela accepte tout—modifications de fichiers, commandes bash, tous les appels d’outils. Le mot « dangerous » est intentionnel. Utilisez-le dans des environnements sandboxés ou quand 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 la session :

Shift+Tab  # Parcourt les modes

Dans settings.json :

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

Syntaxe des règles de permission

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

Patterns 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 de préfixe : Bash(npm run test:*) autorise npm run test, npm run test:unit et npm run test:integration.

Limitation importante : Les patterns Bash correspondent uniquement aux préfixes, pas aux regex. Un pattern comme Bash(curl http:*) ne correspondra pas à curl -X GET http://... car les options viennent avant l’URL. Pour un blocage robuste, refusez entièrement la commande : Bash(curl:*).

Patterns 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 settings : Edit(/build/**) - relatif à l’emplacement du fichier settings - Véritablement absolu : Edit(//tmp/**) - commence par // - Répertoire personnel : Read(~/.zshrc)

Patterns d’outils MCP :

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

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

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

C’est essentiel pour les monorepos ou quand Claude doit référencer du code dans des répertoires adjacents.

Mode sandbox

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

> /sandbox

Ou configurez dans settings :

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

Quand le sandbox est activé : - 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 auto-approuvées si autoAllowBashIfSandboxed est true

Conseil d’expert : Le mode sandbox est excellent pour exécuter Claude sur des bases de code non fiables. Activez-le lors de l’exploration de projets inconnus ou quand vous voulez une couche de protection supplémentaire. Les tests internes d’Anthropic ont montré que le sandboxing réduit les demandes de permission de 84 %.⁴⁵

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 aux instructions données à Claude pour effectuer des actions, les hooks garantissent l’exécution indépendamment du comportement du modèle. Ils sont essentiels pour faire respecter les standards d’équipe et automatiser les tâches répétitives.

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

Événements disponibles

Configuration des Hooks

Définissez les hooks dans settings.json ou 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"
}

Les codes de sortie contrôlent le comportement : - 0 : Succès — l’opération continue. La sortie standard est affichée en mode verbose (Ctrl+O). Pour UserPromptSubmit et SessionStart, la sortie standard est ajoutée au contexte. - 2 : Erreur bloquante — l’opération s’arrête. La sortie d’erreur devient le message d’erreur transmis à Claude. - 1, 3, etc. : Erreur non bloquante — l’opération continue. La sortie d’erreur est affichée comme avertissement en mode verbose.

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

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

Hooks PreToolUse avec permission ask (v2.1.0+) : Les hooks PreToolUse peuvent désormais retourner updatedInput lors de l’utilisation de la décision de permission « ask », permettant aux hooks d’agir comme middleware tout en demandant le consentement de l’utilisateur.³⁹

{
  "decision": "ask",
  "message": "Modified command requires approval",
  "updatedInput": {
    "command": "npm test -- --coverage --ci"
  }
}

Hooks PreToolUse avec additionalContext (v2.1.9+) : Les hooks peuvent injecter du contexte dans le modèle en retournant additionalContext. C’est utile pour fournir des informations dynamiques (documentation API, schémas de base de données, état de l’environnement) que le modèle devrait prendre en compte.⁵¹

{
  "decision": "allow",
  "additionalContext": "Note: This database has a 5-second query timeout. Complex joins may need optimization."
}

La chaîne additionalContext est ajoutée au contexte du modèle pour ce tour, la rendant disponible pour le raisonnement sans modifier définitivement la conversation.

Exemples pratiques de Hooks

Formatage automatique des 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 1
fi
exit 0

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

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

Système de notification personnalisé :

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

Injecter du contexte dynamique dans les prompts :

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

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

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

Débogage des Hooks

Activez le mode debug pour dépanner les hooks :

claude --debug

Cela 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 slash commands en utilisant le frontmatter. Ces hooks sont limités au cycle de vie du composant et ne s’exécutent que lorsque ce composant est actif.⁴¹

Skill avec hooks intégrés :

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

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

L’option once (skills et slash commands uniquement) garantit que le hook ne s’exécute qu’une seule fois par session — 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 test comme garde-fous qui forcent 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 que tous les critères d’acceptation sont remplis avant que Claude ne déclare « terminé »
4. Notification : Les hooks Stop peuvent vous notifier via Slack/Pushover lorsque Claude termine ou se retrouve bloqué

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

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

MCP étend Claude Code en offrant un accès à des outils externes, des bases de données, des API et des services via un protocole standardisé. L’écosystème a connu une croissance fulgurante : MCP comptabilise 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 comme 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 PR 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, évitant ainsi la dépendance à un fournisseur unique.

Support MCP distant (juin 2025)

Claude Code prend désormais en charge les serveurs MCP distants avec authentification OAuth native.²⁸ Connectez-vous à des outils et sources de données sans gérer de serveurs locaux — il suffit de s’authentifier une fois et Claude Code gère automatiquement le renouvellement des 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

MCP Tool Search (v2.1.7+)

À mesure que les serveurs MCP gagnaient en capacités (certains exposant plus de 50 outils), les descriptions d’outils consommaient un contexte excessif. MCP Tool Search résout ce problème en chargeant dynamiquement les descriptions d’outils uniquement lorsque c’est nécessaire — une forme de chargement différé 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 en tokens : 85 %

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

Configuration :

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

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

Conseil avancé : Avec Tool Search activé, vous pouvez connecter bien plus de serveurs MCP sans vous soucier des limites de contexte. La réduction de 95 % du contexte signifie que les serveurs qui se disputaient auparavant le contexte coexistent désormais sans conflit.

Assistant de configuration MCP interactif

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

Types de transport

HTTP (recommandé pour les serveurs distants) :

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

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

SSE (obsolète mais fonctionnel) :

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

Stdio (serveurs locaux) :

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

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

Windows nécessite un wrapper cmd pour stdio :

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

Gestion des portées

Les serveurs MCP existent à trois niveaux de portée avec une priorité claire (local remplace projet, 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} et supportent 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 en tant que commandes slash :

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

Limites de sortie

La sortie MCP est limitée pour éviter le débordement de contexte : - Seuil d’avertissement : 10 000 tokens - Maximum par défaut : 25 000 tokens

Augmentez si nécessaire :

export MAX_MCP_OUTPUT_TOKENS=50000

Serveurs MCP populaires

Cas d’utilisation pratiques de 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 de 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é MCP Apps, une extension du Model Context Protocol qui permet des interfaces utilisateur interactives pour les outils directement dans l’interface Claude.⁷⁸ MCP Apps permet aux utilisateurs de visualiser, modifier et interagir avec du contenu provenant de services externes sans quitter Claude — notamment Asana, Box, Canva, Figma, Hex, monday.com et Slack. Tout serveur MCP peut fournir une interface interactive qui s’affiche dans Claude. Bien que MCP Apps apparaisse actuellement dans l’interface web claude.ai, les extensions du protocole MCP sous-jacent sont pertinentes pour l’écosystème MCP de Claude Code à mesure que les serveurs adoptent les nouvelles capacités interactives.

Plateforme API : Code Execution Tool v2 (janvier 2026)

Anthropic a lancé la v2 du Code Execution Tool en bêta publique, remplaçant le bac à sable Python d’origine 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 d’outils programmatique (également en bêta publique) : Claude peut appeler des outils depuis l’exécution de code, réduisant la latence et la consommation de tokens dans les workflows multi-outils

Cela 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 autonome. C’est 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.

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 consomme ce contexte. Lors de longues sessions, 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 retourné. Claude peut également exécuter jusqu’à 10 subagents en parallèle, permettant un travail concurrent qui serait impossible de manière séquentielle.²

Comment fonctionnent les subagents

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

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

Cette architecture évite le débordement de contexte tout en permettant des flux de travail complexes.

Types de subagents intégrés

Explore (rapide, lecture seule) : - Modèle : Haiku (ultra-rapide) - Mode : Strictement lecture seule - Outils : Glob, Grep, Read et commandes bash sécurisées (ls, git status, git log, git diff, find, cat, head, tail) - Niveaux de minutie : Rapide, Moyen, Très approfondi - À utiliser pour : Exploration de codebase, recherche de fichiers, compréhension de la structure

General-purpose : - Modèle : Sonnet - Mode : Lecture/écriture complète - Outils : Tous les outils disponibles - À utiliser pour : Recherche complexe + tâches de modification

Plan : - Modèle : Sonnet (ou Opus avec opusplan) - Mode : Lecture seule - Outils : Read, Glob, Grep, Bash - À utiliser pour : Planification d’implémentations complexes avant exécution

Déclencher 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

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

Créer des 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 :

Gérer les 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

Exécuter des 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 plus tard avec l’ID 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 parallèle :

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

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

> Resume agent abc123 and continue the analysis

Subagents asynchrones (décembre 2025)

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

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

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

Résilience aux refus de permission (v2.1.0+)

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

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 métier 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 (anciennement Claude Code SDK) fournit l’infrastructure pour construire des agents personnalisés avec support des skills.³²

Qu’est-ce que le mode Extended Thinking ?

Le mode Extended Thinking donne à 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)

Le mode 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 ».⁷⁰ Ce changement a été effectué car le mode 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. Ces mots-clés sont désormais interprétés comme des instructions de prompt ordinaires et n’allouent 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 supportés

• Claude Opus 4.5
• Claude Sonnet 4.5
• Claude Haiku 4.5

Contrôler le mode Extended Thinking

Basculement rapide pendant la session :

Press Alt+T to toggle thinking on/off

Note : Le basculement du mode thinking a été changé de Tab à Alt+T pour éviter les déclenchements accidentels.³⁹

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

Variable d’environnement (permanent) :

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

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

Désactiver pour économiser les coûts : Pour les tâches plus simples où un raisonnement approfondi n’est pas nécessaire, vous pouvez réduire les coûts en désactivant le mode thinking 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 : Les tokens de réflexion sont facturés comme des tokens de sortie. Le budget par défaut de 31 999 fonctionne bien pour la plupart des tâches, mais pour les opérations simples, vous pouvez économiser en réduisant le budget ou en désactivant complètement le mode thinking.

Comment ça fonctionne

Lorsque le mode thinking est activé, la réponse de Claude inclut un raisonnement interne qui n’est pas affiché dans la sortie mais influence la réponse. La réflexion est chiffrée et retournée dans un champ signature pour vérification.

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

Quand envisager de désactiver/réduire

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

Comportement du cache

La mise en cache du prompt système est préservée lorsque les paramètres de thinking changent. La mise en cache des messages est invalidée lorsque le budget de thinking ou le statut activé change entre les tours.

Styles de sortie

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

Styles intégrés

Définir le style de sortie

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

Ou via les paramètres :

{
  "outputStyle": "Explanatory"
}

Styles de sortie personnalisés

Créez 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 des flux de travail 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.

Sauvegardez 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 comme 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?

Espacement 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 de domaine 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 de domaine — 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 skills, vous devez soit réexpliquer ce contexte à chaque session, soit espérer que Claude le déduise des commentaires de code. Avec les skills, vous l’encodez une fois. Claude lit la définition du skill et applique automatiquement cette expertise chaque fois que c’est pertinent. Vos développeurs juniors reçoivent des conseils de niveau senior sans avoir à demander. Vos patterns de sécurité sont appliqués sans avoir à se souvenir de les invoquer.

Cette distinction est importante. Une commande slash est un raccourci dont vous devez vous souvenir. Un skill est une connaissance que Claude a toujours à disposition. Quand vous créez un skill de revue de sécurité avec les patterns de vulnérabilité spécifiques de votre équipe et vos exigences de conformité, Claude applique cette expertise chaque fois qu’il rencontre du code pertinent — lors des revues de PR, du 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 la duplication et maximise l’efficacité :

Utilisez les commandes slash quand vous voulez un contrôle explicite : /deploy, /test, /review PR 456. Vous décidez quand les exécuter.

Utilisez les skills quand l’expertise doit être automatiquement disponible : patterns de sécurité, application du style de code, connaissances spécifiques au domaine. Claude décide quand les appliquer.

Utilisez les subagents quand 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 requis plus 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 commités dans le contrôle de version. Quand vos coéquipiers font un pull, ils obtiennent automatiquement vos skills — pas d’installation, pas de configuration. C’est ainsi que vous standardisez l’expertise au sein d’une é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

## Format de sortie des revues

Pour chaque constatation :
- **Fichier** : path/to/file.ts:123
- **Sévérité** : Critique | Élevée | Moyenne | Faible
- **Catégorie** : Sécurité | Performance | Maintenabilité
- **Problème** : Description claire du problème
- **Recommandation** : Correction spécifique avec exemple de code
- **Justification** : Pourquoi c'est important

Consultez [SECURITY_PATTERNS.md](SECURITY_PATTERNS.md) pour les modèles de vulnérabilités détaillés.
Consultez [PERFORMANCE_CHECKLIST.md](PERFORMANCE_CHECKLIST.md) pour les directives d'optimisation.

Référence du frontmatter

Substitutions de chaînes (v2.1.9+) : Les skills peuvent accéder au contexte de session en utilisant la substitution ${CLAUDE_SESSION_ID}. Utile pour la journalisation, le suivi ou la génération de sorties spécifiques à la session.⁵¹

Le champ description est crucial. Claude découvre les skills en faisant correspondre vos requêtes aux descriptions des skills. Une description vague signifie que Claude ne reconnaîtra pas quand utiliser le skill. Une description spécifique avec des conditions de déclenchement claires signifie une activation fiable.

Mauvaise description :

description: Helps with code

Description efficace :

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, audit, or check code.

La description efficace inclut : - Ce que fait le skill (réviser le code pour des problèmes spécifiques) - Quand l’utiliser (examen des modifications, PRs, analyse de qualité) - Phrases déclencheuses (review, audit, check)

Restrictions d’outils

Le champ allowed-tools limite ce que Claude peut faire lorsqu’un skill est actif. C’est essentiel pour les skills qui doivent être en lecture seule ou limités en portée :

---
name: security-auditor
description: Audit code for security vulnerabilities without making changes
allowed-tools: Read, Grep, Glob
---

Avec cette configuration, Claude peut analyser le code mais ne peut pas modifier les fichiers, exécuter des commandes bash ou apporter des modifications. Le skill impose un comportement en lecture seule.

Modèles de restriction courants :

Fichiers de support

Les skills peuvent inclure plusieurs fichiers. Claude lit le SKILL.md principal lors de l’activation, puis accède aux fichiers de support selon les besoins — une divulgation progressive qui gère efficacement le contexte.

Structure type :

my-skill/
├── SKILL.md           # Required: overview + quick reference
├── DETAILED_GUIDE.md  # Deep documentation
├── EXAMPLES.md        # Concrete examples
├── PATTERNS.md        # Reference patterns
├── templates/         # Reusable templates
│   └── component.tsx
└── scripts/           # Helper utilities
    └── validate.py

Référencer les fichiers de support depuis SKILL.md :

For detailed security patterns, see [SECURITY_PATTERNS.md](SECURITY_PATTERNS.md).

Use this template for new components:
@templates/component.tsx

Validate configurations with:
```bash
python scripts/validate.py config.json

**Conseil d'expert :** Mettez les informations essentielles directement dans SKILL.md. Réservez les fichiers de support pour le matériel de référence approfondi. Claude lit SKILL.md immédiatement mais n'accède aux fichiers de support qu'en cas de besoin. Si des informations critiques sont enfouies dans un fichier de support, Claude pourrait ne pas les trouver.

### Exemple complet : Skill d'expert domaine

Voici un skill de qualité production pour une application fintech :

**Structure du répertoire :**

.claude/skills/payments-domain/ ├── SKILL.md ├── BUSINESS_RULES.md ├── COMPLIANCE.md └── DATA_MODELS.md

**SKILL.md :**
```markdown
---
name: payments-domain
description: Expert knowledge of payment processing domain including transaction flows, compliance requirements, and business rules. Use when working with payment code, transaction handling, refunds, disputes, or financial calculations.
---

# Payments Domain Expertise

## Core Concepts

### Transaction States

PENDING → AUTHORIZED → CAPTURED → SETTLED ↘ VOIDED AUTHORIZED → DECLINED CAPTURED → REFUNDED (partial or full) SETTLED → CHARGEBACK → REPRESENTED

### Money Handling Rules
- ALL monetary values stored as integers (cents, not dollars)
- Currency always explicitly tracked (never assume USD)
- Rounding: HALF_EVEN for calculations, HALF_UP for display
- Never use floating point for money

### Idempotency Requirements
Every payment operation MUST be idempotent:
```typescript
// Required pattern
async function processPayment(idempotencyKey: string, amount: number) {
  const existing = await findByIdempotencyKey(idempotencyKey);
  if (existing) return existing; // Return cached result

  const result = await executePayment(amount);
  await storeWithIdempotencyKey(idempotencyKey, result);
  return result;
}

Quick Reference

Fee Calculations

• Interchange: 1.5% + $0.10 (debit), 2.1% + $0.10 (credit)
• Platform fee: 2.9% + $0.30 (standard), 2.2% + $0.30 (enterprise)
• International: +1% cross-border fee
• Currency conversion: mid-market rate + 1%

Compliance Thresholds

• $3,000: Enhanced due diligence trigger
• $10,000: CTR filing required
• $25,000: Additional verification required

Refund Windows

• Full refund: 120 days from capture
• Partial refund: 180 days from capture
• Chargeback window: 120 days (Visa), 180 days (Mastercard)

Key Files

• src/payments/processor.ts - Core payment logic
• src/payments/refunds.ts - Refund handling
• src/compliance/aml.ts - AML checks
• src/models/transaction.ts - Transaction model

See BUSINESS_RULES.md for detailed business logic. See COMPLIANCE.md for regulatory requirements. See DATA_MODELS.md for schema documentation.

Avec ce skill en place, Claude applique automatiquement l'expertise du domaine des paiements lorsque vous travaillez sur du code de transaction, posez des questions sur la logique de remboursement ou déboguez des flux de paiement. Vous n'invoquez rien — l'expertise est simplement là.

### Créer des skills efficaces

**Commencez par la description.** Rédigez d'abord la description, puis construisez le contenu du skill en conséquence. La description détermine quand Claude utilise le skill, donc faites-la correctement :

1. Indiquez ce que fournit le skill
2. Listez les conditions de déclenchement spécifiques
3. Incluez les mots-clés et phrases pertinents

**Gardez les skills ciblés.** Un skill devrait couvrir un domaine ou une capacité :

| Bon (ciblé) | Mauvais (trop large) |
|-------------|----------------------|
| `security-auditor` | `code-helper` |
| `react-patterns` | `frontend-stuff` |
| `postgres-optimization` | `database-expert` |
| `api-documentation` | `docs-generator` |

Si un skill essaie de couvrir trop de choses, sa description devient vague et Claude ne reconnaîtra pas de manière fiable quand l'utiliser.

**Utilisez la divulgation progressive.** Mettez les informations les plus importantes directement dans SKILL.md. Référencez les fichiers de support pour la profondeur :

```markdown

## Quick Reference
[Essential patterns here - Claude sees this immediately]

## Deep Dive
For comprehensive coverage, see [DETAILED_GUIDE.md](DETAILED_GUIDE.md).

Incluez des exemples concrets. Les descriptions abstraites sont moins utiles que les modèles concrets :

## Input Validation

### Pattern
```typescript
// Good: Explicit validation with typed errors
const validated = PaymentSchema.safeParse(input);
if (!validated.success) {
  throw new ValidationError(validated.error.issues);
}

// Bad: Implicit coercion
const amount = Number(input.amount); // Silent NaN on invalid input

**Testez avec des requêtes réalistes.** Après avoir créé un skill, testez si Claude l'active :

Review this payment processing code for issues

Should activate payments-domain skill

How should I handle refunds?

Should activate payments-domain skill

What’s the weather like?

Should NOT activate payments-domain skill

Si Claude n'active pas le skill comme prévu, révisez la description pour inclure les phrases déclencheuses que vous utilisez.

### Stratégies de partage en équipe

**Partage basé sur Git (recommandé pour les skills de projet) :**
```bash
# Add skill to project
mkdir -p .claude/skills/team-standard
# Create SKILL.md and supporting files

# Commit
git add .claude/skills/
git commit -m "Add team coding standards skill"
git push

# Teammates get it automatically
git pull
claude  # Skill now available

Partage entre projets via symlinks :

# Create canonical skill location
mkdir -p ~/shared-skills/security-reviewer
# Create SKILL.md

# Symlink into projects
ln -s ~/shared-skills/security-reviewer ~/.claude/skills/security-reviewer
# Now available in all your projects

Distribution via plugin : Pour une distribution plus large, empaquetez les skills dans des plugins :

my-plugin/
├── .claude-plugin/
│   └── plugin.json
└── skills/
    └── my-skill/
        └── SKILL.md

Les skills intégrés dans les plugins deviennent disponibles lorsque les utilisateurs installent le plugin.

Débogage des skills

Le skill ne s’active pas :

1. Vérifiez que la description correspond à votre requête : yaml # If you're saying "check this code" but description says "review" description: Review OR check code for issues...

2. Vérifiez l’emplacement du fichier : ```bash # Personal ls ~/.claude/skills/my-skill/SKILL.md

# Project ls .claude/skills/my-skill/SKILL.md ```

1. Validez le frontmatter YAML :
2. La première ligne doit être exactement ---
3. --- de fermeture avant le contenu markdown
4. Pas de tabulations dans YAML (utilisez des espaces)

5. Le champ name doit être en minuscules avec des tirets uniquement

6. Exécutez en mode debug : bash claude --debug # Watch for skill loading messages

Le skill s’active de manière inattendue :

Affinez la description. Si votre skill s’active quand il ne le devrait pas, la description est trop large :

# Too broad - activates on any "code" mention
description: Help with code

# Specific - activates only for security contexts
description: Audit code for security vulnerabilities including injection attacks, authentication flaws, and data exposure. Use when specifically asked about security, vulnerabilities, or when reviewing code for security issues.

Fichiers de support introuvables :

• Utilisez des chemins relatifs depuis l’emplacement de SKILL.md
• Barres obliques uniquement (même sous Windows)
• Vérifiez que le fichier existe : ls .claude/skills/my-skill/REFERENCED.md

Quand créer un skill

Créez un skill quand : - L’expertise du domaine doit être automatiquement disponible - Plusieurs membres de l’équipe ont besoin des mêmes connaissances - Vous expliquez répétitivement les mêmes modèles ou règles - Le contexte doit être injecté sans invocation explicite - Les connaissances s’étendent sur plusieurs fichiers et nécessitent une organisation

Ne créez pas de skill quand : - Vous voulez un contrôle explicite sur l’invocation (utilisez une slash command) - La tâche nécessite un contexte séparé (utilisez un subagent) - C’est un prompt ponctuel (tapez-le simplement) - Le « skill » n’est en réalité qu’un seul template (utilisez une slash command)

Conseil d’expert : Si vous vous retrouvez à taper répétitivement /security-review avant de travailler sur du code d’authentification, convertissez-le en skill. L’expertise devrait être ambiante, pas explicitement invoquée. Si vous voulez une invocation explicite, gardez-le comme commande.

Système de plugins

Les plugins permettent de distribuer des extensions pour Claude Code. Un plugin peut inclure des commandes personnalisées, des subagents, des skills, des hooks et des serveurs MCP. Anthropic a officiellement lancé la marketplace de plugins en décembre 2025 avec 36 plugins sélectionnés.⁴⁷

Structure d’un plugin

my-plugin/
├── .claude-plugin/
│   └── plugin.json              # Required: metadata
├── commands/                     # Slash commands
│   └── hello.md
├── agents/                       # Subagents
│   └── helper.md
├── skills/                       # Skills
│   └── my-skill/
│       └── SKILL.md
├── hooks/                        # Event handlers
│   └── hooks.json
└── .mcp.json                     # MCP servers

Manifeste du plugin

plugin.json minimal :

{
  "name": "my-plugin",
  "description": "What this plugin does",
  "version": "1.0.0",
  "author": {
    "name": "Your Name"
  }
}

Gestion des plugins

> /plugin                              # Interactive interface
> /plugin install name@marketplace     # Install
> /plugin enable name@marketplace      # Enable
> /plugin disable name@marketplace     # Disable
> /plugin uninstall name@marketplace   # Remove
> /plugin marketplace add ./local      # Add local marketplace
> /plugin marketplace list             # View marketplaces

Développement local

Créez une marketplace locale pour vos tests :

mkdir dev-marketplace && cd dev-marketplace
mkdir my-plugin
# Create plugin structure

cd ..
claude
> /plugin marketplace add ./dev-marketplace
> /plugin install my-plugin@dev-marketplace

Composants d’un plugin

• Commands : disponibles en tant que commandes slash (/plugin-command)
• Agents : apparaissent dans la liste /agents
• Skills : se chargent automatiquement selon la configuration du skill
• Hooks : fusionnés avec les hooks utilisateur/projet, exécutés en parallèle
• MCP Servers : démarrent automatiquement lorsque le plugin est activé

Comment fonctionne la mémoire ?

Le système de mémoire de Claude Code permet de conserver le contexte entre les sessions. Une gestion efficace de la mémoire fait la différence entre un Claude qui comprend profondément votre projet et un Claude qui traite chaque session comme un nouveau départ.

Hiérarchie des fichiers CLAUDE.md

Structure efficace d’un CLAUDE.md

# Project Context

## Architecture
- Monorepo with packages in /packages
- React frontend in /packages/ui
- Node.js API in /packages/api
- Shared types in /packages/types
- PostgreSQL database via Prisma

## Code Standards
- TypeScript strict mode everywhere
- ESLint + Prettier enforced (pre-commit hooks)
- No default exports
- JSDoc on all public APIs
- Tests required for all new code

## Commands
- `npm test` - Run all tests
- `npm run test:watch` - Watch mode
- `npm run lint` - Check linting
- `npm run lint:fix` - Auto-fix lint issues
- `npm run build` - Production build
- `npm run dev` - Start dev servers
- `npm run db:migrate` - Run migrations
- `npm run db:seed` - Seed database

## Patterns

### API Endpoints
Create in packages/api/src/routes/
Use Zod for request/response validation
All endpoints need OpenAPI documentation

### React Components
Create in packages/ui/src/components/
Use React Query for server state
Prefer composition over inheritance

### Database
Prisma schema in packages/api/prisma/
Always create migration for schema changes
Use transactions for multi-table operations

## Important Notes
- NEVER commit .env files
- API runs on :3000, UI on :3001
- Local DB: postgres://localhost:5432/myapp
- Feature flags in packages/api/src/flags.ts

## Recent Decisions
- 2025-12-01: Migrated to React Query v5
- 2025-11-15: Adopted Zod for all validation
- 2025-11-01: Moved to ESM modules

# Summary Instructions
When using compact, focus on:
- Recent code changes
- Test results
- Architecture decisions made this session

Imports de fichiers

Référencez d’autres fichiers dans votre CLAUDE.md :

See @README.md for project overview
Coding standards: @docs/STYLE_GUIDE.md
API documentation: @docs/API.md
Personal preferences: @~/.claude/preferences.md

Syntaxe d’import : - Relatif : @docs/file.md - Absolu depuis le projet : @/absolute/path.md - Répertoire home : @~/.claude/file.md - Profondeur maximale : 5 niveaux d’imports

Répertoire des règles de mémoire

Pour une mémoire mieux organisée, utilisez .claude/rules/ pour stocker des fichiers de règles par catégorie :¹⁸

.claude/rules/
├── testing.md          # Testing conventions
├── security.md         # Security requirements
├── api-patterns.md     # API design patterns
└── deployments.md      # Deployment procedures

Les règles se chargent automatiquement et fournissent un contexte structuré sans encombrer CLAUDE.md.

Ajout rapide en mémoire

Utilisez le préfixe # pour ajouter des notes pendant une session :

# Always run tests before committing
# The payment module is especially fragile
# Use the new logger from packages/api/src/logger.ts

Vous serez invité à sélectionner dans quel fichier de mémoire stocker la note.

Commandes de gestion du contexte

Afficher l’utilisation du contexte :

> /context

Affiche une grille visuelle de la répartition du contexte entre le prompt système, la conversation, les outils et le contenu des fichiers.

Compacter la conversation :

> /compact
> /compact focus on the authentication changes
> /compact preserve test output and error messages

Résume intelligemment les anciennes parties de la conversation tout en préservant les informations essentielles.

Instructions de compaction personnalisées (dans CLAUDE.md) :

# Summary Instructions
When using compact, focus on:
- Test output and failures
- Code changes made this session
- Architecture decisions

Extended thinking pour le contexte :

export MAX_THINKING_TOKENS=10000

Plus de tokens de réflexion signifie plus de capacité de raisonnement, mais des coûts plus élevés.

Stratégies d’optimisation du contexte

1. Utilisez des références de fichiers spécifiques au lieu de demander à Claude de chercher
2. Effacez les conversations sans rapport avec /clear entre les tâches
3. Compactez de manière proactive lors des longues sessions
4. Utilisez des subagents pour isoler le travail exploratoire
5. Découpez les tâches complexes en interactions ciblées
6. Reprenez les sessions pour le travail en cours au lieu de tout réexpliquer

Images et entrées multimodales

Claude Code peut analyser des images : captures d’écran, diagrammes, maquettes, messages d’erreur, schémas de base de données.

Méthodes d’entrée

1. Glisser-déposer : faites glisser des fichiers image dans la fenêtre Claude Code
2. Coller : Ctrl+V (pas Cmd+V sur Mac) pour coller depuis le presse-papiers
3. Référence par chemin : « Analyse cette image : /path/to/screenshot.png »

Affichage des images jointes

Lorsque Claude fait référence à une image dans sa réponse, des liens cliquables permettent de la visualiser directement :³⁴

[Image #1]   # Click to open in default image viewer
[Image #2]   # Navigate attached screenshots

C’est utile pour examiner des captures d’écran ou déboguer des problèmes visuels : cliquez sur la référence pour voir exactement ce que Claude a analysé.

Cas d’utilisation

• Déboguer des problèmes d’interface : « Voici une capture d’écran du bug, qu’est-ce qui le cause ? »
• Implémenter des designs : « Construis ce composant d’après la maquette »
• Analyser des diagrammes : « Explique ce diagramme d’architecture »
• Schémas de base de données : « Crée des modèles Prisma correspondant à ce MCD »
• Analyse d’erreurs : « Que signifie cette capture d’écran d’erreur ? »

Conseil d’expert : Lorsque vous implémentez à partir de maquettes, incluez plusieurs captures d’écran montrant différents états (défaut, survol, chargement, erreur). Plus vous fournissez de contexte visuel, meilleure sera l’implémentation.

Comment fonctionne l’intégration Git ?

Claude Code dispose d’une intégration Git approfondie avec des protocoles de sécurité intégrés.

Protocoles de sécurité

• Respecte automatiquement .gitignore
• Ne modifie pas les branches sans permission
• Affiche les diffs avant les commits
• Suit les conventions de commit du projet
• Ne fait jamais de force push sans demande explicite
• Vérifie la paternité avant de modifier un commit

Workflows courants

Créer des commits :

> commit these changes
> create a commit with a meaningful message

Claude va : 1. Exécuter git status et git diff 2. Analyser les modifications 3. Générer un message de commit conventionnel 4. Attendre votre approbation avant de commiter

Créer des pull requests :

> create a PR for this feature
> summarize the changes and create a PR

Réviser du code :

> review the changes in this PR
> what could go wrong with these changes?

Intégration GitHub Actions

Automatisez Claude dans votre CI/CD avec l’action officielle :

Configuration rapide :

> /install-github-app

Fichier de workflow manuel :

name: Claude Code Review
on:
  pull_request:
    types: [opened, synchronize]
  issue_comment:
    types: [created]

jobs:
  claude-review:
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: "Review this PR for bugs, security issues, and performance problems"
          claude_args: "--max-turns 5"

Pour Bedrock (avec OIDC) :

- name: Configure AWS
  uses: aws-actions/configure-aws-credentials@v4
  with:
    role-to-assume: ${{ secrets.AWS_ROLE_TO_ASSUME }}
    aws-region: us-west-2

- uses: anthropics/claude-code-action@v1
  with:
    use_bedrock: "true"
    claude_args: '--model us.anthropic.claude-sonnet-4-5-20250929-v1:0'

Comment utiliser Claude Code dans mon IDE ?

Extension VS Code

Prérequis : VS Code 1.98.0+

Installation : recherchez « Claude Code » dans la marketplace des extensions

Fonctionnalités : - Panneau latéral (icône Spark) - Mode plan avec aperçu des diffs - Option d’acceptation automatique des modifications - Option extended thinking - Pièces jointes et collage d’images - Historique des conversations - Sessions simultanées multiples

Note de sécurité : une vulnérabilité de contournement d’authentification WebSocket (CVE-2025-52882) a été corrigée dans les extensions IDE v1.0.24+. Assurez-vous que votre extension est à jour : toutes les versions vulnérables ont été retirées des stores d’extensions.³⁸

Configuration de fournisseurs tiers (dans .claude/settings.json) :

{
  "env": {
    "CLAUDE_CODE_USE_BEDROCK": "1",
    "AWS_REGION": "us-east-1",
    "AWS_PROFILE": "your-profile"
  }
}

Plugin JetBrains

Compatible avec : IntelliJ IDEA, PyCharm, WebStorm, GoLand, PhpStorm, DataGrip

Installation : Settings → Plugins → Rechercher « Claude Code » → Install → Restart

Raccourcis clavier : - Cmd+Esc (Mac) / Ctrl+Esc (Windows) : lancement rapide - Cmd+Option+K (Mac) / Alt+Ctrl+K (Windows) : ajouter une référence de fichier

Fonctionnalités : - Visualisation des diffs dans le visualiseur de diff de l’IDE - Partage automatique du contexte de sélection - Intégration des diagnostics - Sessions multiples

Configuration WSL2 : Définissez la commande Claude sur :

wsl -d Ubuntu -- bash -lic "claude"

Intégration terminal

Connectez un terminal externe à votre IDE :

> /ide

Claude Code détecte automatiquement VS Code, Cursor, Windsurf et les IDE JetBrains.

Intégration Slack (décembre 2025)

Claude Code s’intègre désormais directement avec Slack, permettant aux développeurs de déléguer des tâches de codage depuis les fils de discussion.¹⁴

Fonctionnement : 1. Mentionnez @Claude dans un canal ou fil Slack 2. Claude examine le message pour déterminer s’il s’agit d’une tâche de codage 3. Une session Claude Code démarre automatiquement sur l’infrastructure Anthropic 4. Claude récupère le contexte des messages récents du canal/fil 5. Des mises à jour de progression sont publiées dans votre fil Slack 6. Des liens pour examiner les modifications et ouvrir des PRs sont fournis à la fin

Cas d’utilisation : - Investigation de bugs à partir de rapports postés dans Slack - Revues de code rapides basées sur les retours de l’équipe - Implémentation de petites fonctionnalités à partir de demandes

Prérequis : - Application Claude installée via la Slack App Marketplace - Forfait Slack payant - Accès à Claude Code sur le web

Confidentialité : Claude respecte la structure de permissions existante de Slack. Il ne peut pas accéder aux conversations ou dépôts auxquels vous n’êtes pas autorisé. Les conversations ne sont pas utilisées pour l’entraînement du modèle.

Modèles d’utilisation avancés

Mode headless et CI

Exécutez Claude Code dans des scripts et des pipelines CI :

#!/bin/bash
# Automated code review

result=$(claude -p "Review this code for quality issues" \
  --output-format json \
  --allowedTools "Read,Grep,Glob" \
  --permission-mode plan \
  --disable-slash-commands \
  --max-turns 5)

if echo "$result" | jq -e '.result | test("critical|high severity")' > /dev/null; then
  echo "Issues found:"
  echo "$result" | jq -r '.result'
  exit 1
fi

echo "Review passed"
exit 0

Redirection et chaînage (piping)

# Analyze logs
cat production.log | claude -p "summarize errors" > error-summary.md

# Process multiple files
find . -name "*.ts" -exec cat {} \; | claude -p "find security issues"

# Chain with jq
claude -p "generate config" --output-format json | jq -r '.result' > config.json

Tâches en arrière-plan

Lancez des opérations longues sans bloquer votre terminal :

> start the build in the background

Ou appuyez sur Ctrl+B pendant l’exécution d’une commande.

Gérez les tâches en arrière-plan :

> /bashes                    # List running tasks
> get output from task xyz   # Retrieve output

Sessions parallèles avec Git Worktrees

# Create worktrees for parallel work
git worktree add ../project-feature-a -b feature-a
git worktree add ../project-bugfix bugfix-123

# Run Claude in each
cd ../project-feature-a && claude --session-id "feature-a"
cd ../project-bugfix && claude --session-id "bugfix-123"

Chaque worktree est un répertoire de projet indépendant avec sa propre session.

Analyse de la sortie JSON

result=$(claude -p "analyze this code" --output-format json)

# Extract fields
echo "Result: $(echo $result | jq -r '.result')"
echo "Cost: $(echo $result | jq -r '.total_cost_usd')"
echo "Session: $(echo $result | jq -r '.session_id')"
echo "Duration: $(echo $result | jq -r '.duration_ms')ms"

Gestion programmatique des sessions

# Named sessions for tracking
claude --session-id "feature-$(git branch --show-current)-$(date +%s)"

# Continue previous work
claude -c "continue implementing the tests"

# Fork for parallel exploration
claude -r "main-session" --fork-session "try alternative approach"

Qu’est-ce que Claude Code Remote ?

Claude Code Remote comble le fossé entre le web et le terminal, vous permettant de lancer des tâches dans le cloud et de les poursuivre localement — ou inversement. Cette fonctionnalité transforme votre façon de travailler sur différents appareils.

Le concept fondamental

L’interface web sur claude.ai/code exécute Claude Code dans le cloud. Les tâches s’exécutent en arrière-plan pendant que vous êtes loin de votre terminal. Lorsque vous êtes prêt à reprendre, téléportez la session sur votre machine locale et reprenez exactement là où Claude s’est arrêté.

Cela permet des flux de travail qui n’étaient pas possibles auparavant : - Lancez un refactoring complexe depuis votre téléphone, laissez-le s’exécuter pendant votre trajet, puis finalisez sur votre poste de travail - Mettez en file d’attente plusieurs tâches sur l’interface web, consultez les résultats à votre retour au bureau - Déléguez les opérations longues au cloud lorsque vous devez fermer votre ordinateur portable

Le préfixe &

Envoyez une tâche pour qu’elle s’exécute sur Claude Code web en arrière-plan :

& Build a comprehensive REST API for user management with authentication, CRUD operations, and proper error handling

Le préfixe & envoie votre prompt vers le cloud. Claude y travaille de manière asynchrone — vous pouvez fermer votre terminal, changer d’appareil ou continuer d’autres tâches. L’interface web sur claude.ai/code affiche vos sessions en cours et terminées.

Le flag --teleport

Récupérez une session cloud dans votre terminal local :

claude --teleport session_abc123

Cela récupère l’état de la session depuis le web et la reprend localement. Vous obtenez l’historique complet de la conversation, tous les fichiers que Claude a modifiés, et vous pouvez poursuivre l’interaction comme si vous aviez été présent tout du long.

L’identifiant de session apparaît dans l’interface web. Cliquez sur n’importe quelle session pour voir son identifiant et son statut actuel.

Prérequis

Claude Code Remote est disponible pour les abonnés Pro, Max, Team (sièges premium) et Enterprise (sièges premium).⁷³ L’interface web s’exécute sur l’infrastructure d’Anthropic, offrant les mêmes capacités Claude Code que celles dont vous disposez localement — opérations sur les fichiers, commandes Bash, intégrations MCP — mais dans un environnement cloud géré. L’accès pour les plans Team et Enterprise a été étendu en janvier 2026 — les administrateurs de compte peuvent activer l’accès dans les paramètres Claude.

Application iOS (novembre 2025) : Claude Code est également disponible sur l’application iOS Claude, vous permettant de lancer des tâches de programmation en déplacement et de suivre la progression de l’agent depuis votre téléphone.²² Vous pouvez démarrer des tâches loin de votre bureau et les téléporter ensuite vers votre terminal lorsque vous êtes prêt à les examiner.

Flux de travail pratique

Trajet du matin :

& Review all PRs assigned to me and prepare summaries with recommendations

À votre bureau :

# Check what completed
# Visit claude.ai/code to see session list

# Pull the session locally to review and act on recommendations
claude --teleport pr-review-session-xyz

Avant de quitter le travail :

& Run the full test suite, fix any failures, and prepare a summary of what was changed

Le lendemain matin :

claude --teleport test-fixes-session-abc
# Review what Claude did overnight, make final adjustments

Statut actuel

Claude Code Remote est actuellement en aperçu de recherche (research preview). Attendez-vous à ce que la fonctionnalité évolue à mesure qu’Anthropic recueille des retours. Le flux de travail principal — exécution dans le cloud avec téléportation locale — permet un développement IA continu : Claude travaille pendant que vous êtes loin de votre clavier, et vous reprenez exactement là où il s’est arrêté.

Limitation actuelle : La téléportation de session est actuellement unidirectionnelle uniquement — vous pouvez récupérer les sessions web dans votre terminal, mais vous ne pouvez pas envoyer une session terminal existante vers le web. Il n’est pas encore possible de poursuivre une session locale sur une machine distante (par exemple, une instance AWS via SSH).

Que sont les agents en arrière-plan ?

Les agents en arrière-plan s’exécutent pendant que vous continuez à travailler — sans attendre la fin des tâches longues.¹⁷

Comment fonctionnent les agents en arrière-plan

Au lieu de bloquer votre terminal pendant que Claude exécute une tâche complexe, les agents en arrière-plan : 1. S’exécutent de manière indépendante dans un processus séparé 2. Continuent de fonctionner même si vous fermez votre terminal 3. Signalent les résultats une fois terminés via une notification 4. Peuvent être surveillés et gérés pendant leur exécution

Lancer un agent en arrière-plan

Avec Ctrl+B : Pendant que Claude travaille, appuyez sur Ctrl+B pour envoyer la tâche en cours en arrière-plan. Votre terminal redevient immédiatement disponible.

Avec le préfixe & :

& Run all tests and fix any failures
& Refactor the authentication module to use JWT
& Generate comprehensive API documentation

Le préfixe & envoie la tâche vers Claude Code Remote (exécution dans le cloud). Pour une exécution locale en arrière-plan, utilisez Ctrl+B sur une tâche déjà en cours.

Surveiller les tâches en arrière-plan

> /tasks                    # List all running tasks
> /task status abc123       # Check specific task
> /task cancel abc123       # Stop a task
> /task output abc123       # View task output so far

Flux de travail parallèles en arrière-plan

Exécutez plusieurs agents simultanément :

& Fix all failing tests in src/
& Update documentation for the API module
& Run security scan on the codebase

Chacun s’exécute de manière indépendante. Suivez la progression avec /tasks et récupérez les résultats au fur et à mesure qu’ils se terminent.

Claude in Chrome (décembre 2025)

Claude Code s’intègre désormais à votre navigateur grâce à l’extension Claude in Chrome, permettant le contrôle direct du navigateur depuis votre terminal.²⁴

Installation

1. Installez l’extension Chrome depuis https://claude.ai/chrome
2. Lancez Claude Code et l’intégration est automatiquement détectée
3. Utilisez le langage naturel pour contrôler votre navigateur

Fonctionnalités

Automatisation du navigateur depuis le terminal :

> Navigate to github.com and open my repositories
> Fill out this form with the test user data
> Take a screenshot of the current page
> Click the submit button and wait for the page to load

Web scraping et tests :

> Extract all product prices from this e-commerce page
> Run through the signup flow and report any issues
> Check if the mobile menu works correctly

Cas d’utilisation

• Tests E2E : Exécutez des tests d’intégration directement depuis Claude Code
• Web scraping : Extrayez des données de pages sans écrire de code d’automatisation de navigateur
• Remplissage de formulaires : Automatisez les flux de travail web répétitifs
• Vérification visuelle : Capturez et analysez les mises en page

L’intégration Chrome fonctionne au sein de votre session navigateur existante, accédant à votre état de connexion et vos cookies — utile pour tester les flux authentifiés.

Claude Code in Slack (décembre 2025)

Anthropic a lancé Claude Code in Slack, permettant aux développeurs de déléguer des tâches de programmation directement depuis les fils de discussion.²⁶

Fonctionnement

1. Mentionnez @Claude dans n’importe quel canal ou fil Slack
2. Décrivez la tâche de programmation avec le contexte nécessaire
3. Claude analyse les messages Slack pour déterminer le dépôt concerné
4. Les mises à jour de progression apparaissent dans le fil
5. Claude partage des liens pour examiner le travail et ouvrir des PRs

Exemple de flux de travail

@Claude The login form validation is broken on mobile devices.
Can you fix it? Check the bug report from earlier in this thread.

Claude va : 1. Lire le fil pour obtenir le contexte 2. Identifier le dépôt concerné 3. Cloner et analyser le code source 4. Publier des mises à jour de progression 5. Créer une PR avec le correctif 6. Partager le lien de la PR pour examen

Avantages

• Prise en compte du contexte : Claude lit l’historique Slack pour les rapports de bugs, les demandes de fonctionnalités et les discussions
• Visibilité d’équipe : Les mises à jour de progression dans les fils tiennent tout le monde informé
• Faible friction : Aucun terminal ni IDE requis — démarrez depuis le chat
• Intégration GitHub : Les PRs sont créées automatiquement avec des descriptions appropriées

Prérequis

• Espace de travail Slack avec l’intégration Claude activée
• Dépôt GitHub connecté
• Permissions appropriées pour que Claude puisse créer des branches et des PRs

Cette fonctionnalité est actuellement en aperçu de recherche (research preview) pour les utilisateurs Pro, Max, Team et Enterprise.

Combien coûte Claude Code ?

Comprendre et maîtriser les coûts est essentiel pour une utilisation durable de Claude Code.

Afficher 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 API standard.²¹

Tarification des tokens API (janvier 2026)⁵⁷

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

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

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

Politique sur les 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 - Les abonnements payants multiples depuis la même IP/réseau sont explicitement pris en charge - Les comptes sont complètement séparés : pas de transfert de conversations ou de projets entre eux

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

Note concrète : 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 intensivement pour des projets professionnels et personnels sur plusieurs comptes, c’est exactement ce pour quoi le service est conçu — évitez simplement d’essayer de contourner le système.

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

Facteurs de coût

Exemples de coûts réels

Astuce pour économiser : 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 d’é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 séparés :¹⁶

Ces frais s’accumulent dans les boucles d’agent. 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 d’économie

1. Utiliser Haiku pour les subagents : La plupart des explorations n’ont pas besoin de Sonnet
2. Activer le prompt caching : Par défaut, mais vérifier qu’il n’est pas désactivé
3. Définir le nombre max de tours : claude --max-turns 5 évite 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. API Batch pour le travail non urgent : 50 % de réduction sur les tokens d’entrée et de sortie

Surveillance de l’utilisation

• Claude Console : platform.claude.com (nécessite le rôle Admin ou Billing)
• Limites par workspace : Définir des limites de dépenses par workspace
• Bedrock/Vertex : Utiliser la surveillance des coûts cloud native
• LiteLLM : Pour un suivi détaillé par utilisateur avec des fournisseurs tiers

Utilisation de tokens en arrière-plan

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

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

API Claude Code Analytics (Team/Enterprise)⁵³

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

Endpoint : GET /v1/organizations/usage_report/claude_code

Prérequis : - Clé Admin API (sk-ant-admin...) - Abonnement 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 allocation des coûts entre équipes - Justification du ROI des outils de codage IA

Note : 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.

Optimisation des performances

Réduction de la latence

Sélection du modèle : - Haiku : Réponses les plus rapides, coût le plus bas - Sonnet : Bon équilibre - Opus : Meilleure qualité, latence la plus élevée

Streaming : Toutes les réponses sont diffusées par défaut — vous voyez la sortie au fur et à mesure de sa génération.

Prompt caching : Activé par défaut. Réduit la latence pour le contexte répété (prompts système, définitions d’outils).

Stratégies de mise en cache

Les prompts système et les définitions d’outils sont mis en cache automatiquement : - Durée du cache : 5 minutes (éphémère) - Cache hit : Tokens d’entrée réduits et réponse plus rapide

Les blocs de réflexion des tours précédents sont mis en cache dans les conversations multi-tours.

Désactivez la mise en cache par modèle si nécessaire :

export DISABLE_PROMPT_CACHING_SONNET=1
export DISABLE_PROMPT_CACHING_OPUS=1
export DISABLE_PROMPT_CACHING_HAIKU=1

Opérations parallèles

Parallélisation des subagents : Plusieurs subagents peuvent s’exécuter simultanément. Chacun fonctionne indépendamment sans polluer le contexte principal.

Bash en arrière-plan : Les commandes longues ne bloquent pas la conversation :

> run the full test suite in the background

Git worktrees : Permettent de véritables sessions parallèles sur des branches séparées.

Optimisation de la mémoire

• Références de fichiers spécifiques : @src/auth.ts au lieu de « trouver le fichier auth »
• Recherches ciblées : « rechercher dans src/api » et non « rechercher partout »
• Sessions fraîches : /clear entre les tâches non liées
• Compactage personnalisé : Ajoutez des instructions dans CLAUDE.md pour ce qu’il faut préserver

Comment déboguer les problèmes ?

Problèmes d’installation

Problèmes de chemin WSL :

npm config set os linux
npm install -g @anthropic-ai/claude-code --force --no-os-check
which npm  # Should start with /usr not /mnt/c

Conflits de version Node (nvm) : Ajoutez à ~/.bashrc ou ~/.zshrc :

export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"

Erreurs de permission : Utilisez l’installation native au lieu de npm :

curl -fsSL https://claude.ai/install.sh | bash

Problèmes d’authentification

# Complete reset
/logout
rm -rf ~/.config/claude-code/auth.json
claude  # Fresh login

Problèmes de performance

CPU/mémoire élevés : - Utilisez /compact pour réduire le contexte - Redémarrez entre les tâches majeures - Ajoutez les gros répertoires à .gitignore - Exécutez claude doctor

Recherche lente : Installez ripgrep au niveau système :

# macOS
brew install ripgrep

# Windows
winget install BurntSushi.ripgrep.MSVC

# Linux
sudo apt install ripgrep

Puis :

export USE_BUILTIN_RIPGREP=0

Lenteur sur WSL : - Déplacez le projet vers le système de fichiers Linux (pas /mnt/c/) - Utilisez des filtres de répertoires spécifiques dans les recherches

Problèmes d’intégration IDE

JetBrains non détecté (WSL2) :

Option 1 - Pare-feu Windows :

wsl hostname -I  # Get WSL IP
New-NetFirewallRule -DisplayName "Allow WSL2" -Direction Inbound -Protocol TCP -Action Allow -RemoteAddress 172.21.0.0/16

Option 2 - Réseau en miroir (ajoutez à ~/.wslconfig) :

[wsl2]
networkingMode=mirrored

Puis : wsl --shutdown

Touche Échap non fonctionnelle dans JetBrains : Settings → Tools → Terminal → Décochez « Move focus to the editor with Escape »

Mode débogage

claude --debug                    # Full debug output
ANTHROPIC_LOG=debug claude       # API request logging
claude doctor                    # Health check

Réinitialisation de la configuration

# Reset user settings
rm ~/.claude.json
rm -rf ~/.claude/

# Reset project settings
rm -rf .claude/
rm .mcp.json

Messages d’erreur courants

Déploiement en entreprise

Comparaison des fournisseurs cloud

Déploiement de paramètres gérés

Déployez des politiques à l’échelle de l’organisation via managed-settings.json :

Emplacement : - macOS : /Library/Application Support/ClaudeCode/managed-settings.json - Linux : /etc/claude-code/managed-settings.json - Windows : C:\Program Files\ClaudeCode\managed-settings.json

Exemple de politique :

{
  "permissions": {
    "allow": [
      "Read",
      "Glob",
      "Grep",
      "Bash(npm run:*)",
      "Bash(git:*)"
    ],
    "deny": [
      "Bash(rm -rf:*)",
      "Bash(curl:*)",
      "Read(.env*)",
      "WebFetch"
    ],
    "defaultMode": "default"
  },
  "model": "claude-sonnet-4-5-20250929",
  "disableBypassPermissionsMode": "disable"
}

Les utilisateurs ne peuvent pas remplacer les paramètres gérés.

CLAUDE.md d’entreprise

Déployez un contexte à l’échelle de l’organisation :

Emplacement : - macOS : /Library/Application Support/ClaudeCode/CLAUDE.md - Linux : /etc/claude-code/CLAUDE.md

Contenu :

# Company Standards

## Security Requirements
- Never commit secrets or credentials
- All external API calls require security review
- Use parameterized queries for all database access

## Code Standards
- Follow company style guide at @docs/STYLE.md
- All PRs require two approvals
- Test coverage minimum: 80%

## Approved Tools
- npm, yarn, pnpm for package management
- Jest for testing
- ESLint + Prettier for formatting

Stratégie de déploiement

1. Commencez par la documentation : mettez au point le CLAUDE.md avant le déploiement
2. Groupe pilote : commencez avec 5 à 10 développeurs
3. Phase de questions-réponses : laissez les pilotes utiliser Claude pour l’exploration du code
4. Développement guidé : passez aux corrections de bugs mineures
5. Déploiement complet : déployez avec les paramètres gérés
6. Suivi des coûts : surveillez l’utilisation par équipe

Audit et conformité

• Les transcriptions de sessions sont stockées localement par défaut
• Utilisez la journalisation du fournisseur cloud pour l’audit en entreprise
• Envisagez LiteLLM pour un suivi détaillé de l’utilisation
• Les paramètres gérés imposent les politiques de conformité

API Analytics (Admin)

Les plans Enterprise et Team ont accès à l’API Claude Code Analytics pour le suivi programmatique de l’utilisation.

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

Authentification : nécessite une clé API Admin (sk-ant-admin...), provisionnée dans la Console par les administrateurs de l’organisation.

Métriques disponibles :

Paramètres de requête : - starting_at - Date pour l’agrégation quotidienne (AAAA-MM-JJ) - Renvoie les données par utilisateur pour le jour spécifié

Exemple :

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

Limitations : - Agrégats quotidiens uniquement (~1 h de délai pour la cohérence) - Pour la surveillance en temps réel, utilisez l’intégration OpenTelemetry - Ne suit que l’utilisation de l’API propriétaire (pas Bedrock/Vertex)

Coût : gratuit pour les organisations disposant d’un accès à l’API Admin.

Référence des raccourcis clavier

Commandes générales

Raccourcis personnalisables (v2.1.18+) : exécutez /keybindings pour personnaliser les raccourcis clavier. Prend en charge les raccourcis contextuels, les séquences d’accords (combinaisons multi-touches) et une personnalisation complète. Les raccourcis sont stockés dans ~/.claude/keybindings.json. Consultez la documentation des raccourcis pour la référence complète de configuration.⁷⁷

Suggestions de prompts (déc. 2025) : Claude propose désormais des suggestions de prompts pour accélérer votre flux de travail. Appuyez sur Tab pour accepter une suggestion ou sur Enter pour soumettre votre propre prompt.¹³

Saisie multiligne

Préfixes rapides

Performances des références de fichiers (janv. 2026) : les mentions @ sont désormais 3 fois plus rapides dans les dépôts git. Claude Code respecte également les fichiers .ignore et .rgignore lors de la suggestion de complétions de fichiers — utile pour exclure les artefacts de build ou les fichiers générés des suggestions.³⁵

Mode Vim

Activez-le avec /vim :

Mode normal : - h/j/k/l - Navigation - w/e/b - Déplacement par mot - 0/$ - Début/fin de ligne - gg/G - Début/fin du tampon - dd - Supprimer la ligne - cc/C - Modifier la ligne/jusqu’à la fin - dw/de/db - Variantes de suppression de mot - x - Supprimer le caractère - . - Répéter la dernière modification

Mode insertion : - i/I - Insérer avant/en début de ligne - a/A - Insérer après/en fin de ligne - o/O - Ouvrir une ligne en dessous/au-dessus - Esc - Revenir au mode normal

Bonnes pratiques

Stratégie de session

Utilisez des identifiants de session descriptifs :

claude --session-id "feature-$(git branch --show-current)-$(date +%s)"
claude --session-id "bug-JIRA-456"
claude --session-id "spike-new-architecture"

Reprenez les sessions pour le travail en cours plutôt que de réexpliquer le contexte.

Conception du CLAUDE.md

Gardez-le lisible d’un coup d’œil. Claude le lit à chaque session — un texte dense gaspille du contexte.

Concentrez-vous sur ce qui n’est pas évident. Documentez les patterns spécifiques au projet, les conventions inhabituelles, les décisions. Omettez ce que Claude peut déduire du code.

Mettez-le à jour en continu. Ajoutez des notes pendant le développement avec #. Révisez et consolidez chaque semaine.

Incluez une référence des commandes. Les commandes que vous exécutez constamment devraient être documentées.

Commandes personnalisées

Créez des commandes pour les flux de travail répétitifs :

---
description: Start new feature
allowed-tools: Bash(git:*), Read, Edit
---

1. Create branch: !`git checkout -b feature/$ARGUMENTS`
2. Pull latest main
3. Set up boilerplate
4. Begin implementation

Rédaction efficace des prompts

Soyez précis :

# Bien
"Add email validation to LoginForm in src/components/LoginForm.tsx"

# Trop vague
"Improve the login"

Référencez les fichiers directement :

"Review @src/auth/middleware.ts for security issues"

Fournissez des contraintes :

"Refactor using the same pattern as @src/repositories/UserRepository.ts"

Utilisez les subagents pour l’exploration :

"Have an explore agent find all places where we handle errors"

Contrôle des coûts

• Utilisez /cost régulièrement
• Utilisez Haiku pour les tâches simples et les subagents
• Ne définissez MAX_THINKING_TOKENS que lorsque c’est nécessaire
• Utilisez --max-turns pour les scripts automatisés
• Compactez de manière proactive lors des longues sessions

Sécurité

• Configurez des règles de blocage dans .claude/settings.json pour les fichiers sensibles
• Utilisez le mode sandbox pour les projets non fiables
• N’autorisez jamais Bash(rm -rf:*) ou Bash(sudo:*)
• Utilisez les hooks pour bloquer l’accès aux secrets
• Déployez les paramètres gérés en entreprise

Conseils et techniques de la communauté⁵⁶⁵⁸

La communauté Claude Code a découvert des patterns puissants qui vont au-delà de la documentation officielle. Ces conseils proviennent d’utilisateurs expérimentés, notamment Boris Cherny (créateur de Claude Code) et le dépôt des 40+ astuces.

Utilisez le mode Plan avant de coder

Si vous ne devez retenir qu’un seul conseil, que ce soit celui-ci. Plus vous passez de temps à planifier, plus Claude a de chances de réussir. Appuyez sur Shift+Tab pour passer en mode plan avant de commencer l’implémentation.

Nouveau en janvier 2026 : Lorsque vous acceptez un plan, Claude propose désormais d’effacer automatiquement votre contexte, offrant au plan une fenêtre de contexte vierge. Cela améliore considérablement le respect du plan : Claude reste sur la bonne voie plus longtemps sans que l’ancien contexte n’interfère. Les options incluent : « Oui, effacer le contexte et accepter automatiquement les modifications » (Shift+Tab), « Oui, et approuver manuellement les modifications », ou « Oui, accepter automatiquement les modifications » (sans effacer).

Effacez le contexte fréquemment

Utilisez /clear souvent. Chaque fois que vous commencez quelque chose de nouveau, effacez le chat. Vous n’avez pas besoin que l’ancien historique consomme des tokens ou déclenche des appels de compaction coûteux. Effacez-le simplement et passez à autre chose.

Utilisez des images et des captures d’écran

Claude excelle avec les entrées visuelles. Sur macOS : Cmd+Ctrl+Shift+4 capture une capture d’écran dans le presse-papiers, puis Ctrl+V pour la coller directement dans Claude Code. Utilisez ceci pour partager des maquettes d’interface, des messages d’erreur ou des références de design.

Installez l’application GitHub pour les revues de PR

Exécutez /install-github-app et Claude examinera automatiquement vos PR. C’est particulièrement précieux car le développement assisté par IA augmente le volume de PR : Claude détecte souvent des erreurs de logique et des problèmes de sécurité que les relecteurs humains manquent.

Opération autonome basée sur des conteneurs

Pour une opération entièrement autonome, exécutez Claude Code dans un conteneur Docker avec tmux comme couche de contrôle. Votre Claude Code local contrôle l’instance conteneurisée, qui peut exécuter des tâches longues ou expérimentales sans approbation manuelle. En cas de problème, c’est isolé dans le sandbox.

# Conceptual pattern (varies by setup)
# Local Claude Code → tmux → Container Claude Code
# Results pulled back when complete

Mode Docker Sandbox (démarrage rapide) : Claude Code prend en charge un sandbox Docker simplifié via la sous-commande docker. Cela crée un environnement isolé pour explorer des bases de code non fiables ou exécuter des prompts expérimentaux en toute sécurité.⁶³

# Run Claude Code in Docker sandbox
docker sandbox run claude

# Or with specific project
docker sandbox run claude /path/to/project

Utilisez le mode sandbox lorsque : - Vous explorez des bases de code inconnues ou non fiables - Vous testez des prompts expérimentaux qui pourraient modifier des fichiers - Vous exécutez des sessions autonomes que vous voulez complètement isolées - Vous apprenez Claude Code sans risque pour vos fichiers réels

Gemini CLI comme solution de repli

L’outil WebFetch de Claude Code ne peut pas accéder à certains sites (comme Reddit). Créez un skill qui indique à Claude d’utiliser Gemini CLI comme solution de repli : Gemini a un accès web et peut récupérer du contenu depuis des sites que Claude ne peut pas atteindre directement.

Pattern Meta-Agent Factory

Au lieu de créer des agents qui effectuent des tâches, créez un agent qui crée d’autres agents. Ce n’est pas de la récursion astucieuse : c’est un véritable multiplicateur de productivité pour les workflows d’automatisation complexes.

Claude Squad : gestionnaire multi-agents

Claude Squad gère plusieurs instances Claude Code en parallèle, chacune dans sa propre session tmux avec des worktrees isolés. Exécutez plusieurs agents simultanément sur différentes tâches, surveillez leur progression depuis un tableau de bord unique et récupérez les résultats une fois terminés.⁶⁵

# Install
npm install -g @smtg-ai/claude-squad

# Start multiple agents
claude-squad start "Implement auth feature" --worktree auth-feature
claude-squad start "Write API tests" --worktree api-tests
claude-squad start "Update documentation" --worktree docs-update

# Monitor all agents
claude-squad status

Cas d’utilisation : - Paralléliser des fonctionnalités indépendantes entre plusieurs agents - Exécuter des prompts exploratoires sans bloquer votre session principale - Faire évoluer le codage autonome au-delà d’une seule fenêtre de contexte

Statistiques de productivité des utilisateurs expérimentés

Boris Cherny a démontré le potentiel de Claude Code : en 30 jours, il a fusionné 259 PR avec 497 commits — 40 000 lignes ajoutées et 38 000 supprimées. Cela illustre ce qui est possible lorsque Claude Code est pleinement intégré au workflow de développement.

Personnes à suivre

Restez informé des développements de Claude Code en suivant ces comptes :

Équipe Anthropic (sources primaires)

Meilleurs créateurs de contenu

Ressources clés

• GitHub Releases : anthropics/claude-code/releases - Surveillez uniquement les releases
• Discord : Canaux de la communauté Anthropic
• Liste complète : Voir ~/.claude/docs/following-list.md pour 20+ comptes sélectionnés

Boris et l’équipe Anthropic partagent les fonctionnalités dès leur livraison — souvent le moyen le plus rapide de découvrir les nouvelles capacités avant que la documentation ne rattrape.

Anti-patterns courants

Apprendre ce qu’il ne faut PAS faire apporte souvent plus de valeur que les bonnes pratiques. Ces patterns causent systématiquement des problèmes :

Anti-patterns de coût

Anti-patterns de contexte

Anti-patterns de workflow

Anti-patterns de configuration

Anti-patterns de prompt

Recettes de workflow

Patterns de bout en bout pour les scénarios courants.

Recette 1 : Démarrer un nouveau projet

# 1. Initialize
cd my-project
claude

# 2. Let Claude understand the codebase
> "Explore this codebase and summarize the architecture"

# 3. Set up project configuration
> /init

# 4. Create CLAUDE.md with learned patterns
> "Create CLAUDE.md documenting the patterns you observed"

# 5. Add team commands
> "Create a /test command that runs our test suite"
> "Create a /deploy command for staging deployment"

Recette 2 : Flux de développement quotidien

# 1. Continue yesterday's session
claude -c

# 2. Quick context recap
> "What did we work on yesterday?"

# 3. Check current state
> /status

# 4. Work on feature (Sonnet handles most tasks)
> "Implement the user profile endpoint"

# 5. Proactive context management
> /compact  # Before context exceeds 50%

# 6. Check spending
> /cost

# 7. End session cleanly
> "Summarize what we accomplished today"

Recette 3 : Refactoring complexe

# 1. Use Opus for planning, Sonnet for execution
> /model opusplan

# 2. Plan the refactoring
> "Plan refactoring our authentication from sessions to JWT"

# 3. Review the plan
# (Claude presents approach, you approve or modify)

# 4. Execute with Sonnet
> "Execute the plan"

# 5. Verify nothing broke
> "Have an explore agent verify all auth-related tests pass"

# 6. Review the diff
> !git diff

Recette 4 : Automatisation de la revue de PR

# In CI/CD (GitHub Actions, etc.)
claude -p "Review this PR for:" \
  --input-file pr_diff.txt \
  --output-format json \
  --permission-mode plan \
  --max-turns 5 << EOF
- Security vulnerabilities
- Performance issues
- Code style violations
- Missing test coverage
Provide findings in JSON format.
EOF

Recette 5 : Débogage de problèmes en production

# 1. Configure Sentry MCP for error access
claude --add-mcp sentry

# 2. Get error context
> "Fetch the last 10 errors from Sentry for the auth service"

# 3. Deep dive with thinking
> Tab  # Enable extended thinking
> "Analyze these errors and identify the root cause"

# 4. Fix and verify
> "Implement a fix and add a regression test"
> !npm test

Guide de migration

Vous venez d’un autre outil de codage IA ? Voici comment les concepts correspondent.

Depuis GitHub Copilot

Ce que vous gagnez : Une véritable capacité agentique — Claude Code lit votre codebase, exécute les tests, crée des PR et délègue à des subagents. Pas seulement des suggestions.

Depuis Cursor

Ce que vous gagnez : Les intégrations MCP (bases de données, GitHub, Sentry), la délégation aux subagents, les hooks pour l’automatisation et un workflow natif au terminal.

Depuis ChatGPT / Claude Web

Ce que vous gagnez : Tout. Les interfaces web nécessitent des workflows de copier-coller ; Claude Code opère directement sur votre codebase.

Changements de mentalité essentiels

1. Arrêtez de copier du code. Claude Code écrit directement dans les fichiers.
2. Arrêtez de changer de contexte. MCP intègre les outils externes dans la session.
3. Déléguez agressivement. Les subagents gèrent l’exploration sans alourdir votre contexte.
4. Automatisez avec les hooks. Le formatage, le linting et la journalisation s’exécutent automatiquement.
5. Pensez en sessions. Continuez votre travail avec -c, pas avec de nouvelles conversations.

Points clés à retenir

Pour les développeurs : - Haiku coûte 10 à 20 fois moins cher qu’Opus — utilisez-le pour les subagents et les tâches simples - Utilisez /compact de manière proactive pendant les longues sessions pour gérer le contexte - Les identifiants de session encodant le contexte (feature-${branch}-${timestamp}) aident à revenir aux travaux précédents - Préfixez les prompts courants avec # pour les ajouter à la mémoire persistante sans frappe supplémentaire

Pour les équipes DevOps et plateforme : - Le mode headless (flag -p) permet l’intégration CI/CD avec une sortie JSON pour l’analyse - Les hooks garantissent l’exécution indépendamment du comportement du modèle — utilisez-les pour le linting, le formatage et les vérifications de sécurité - MCP étend les capacités aux bases de données, GitHub, Sentry et plus de 300 intégrations - Les tâches en arrière-plan (préfixe &) s’exécutent sur Claude Code Remote pour une exécution asynchrone

Pour les équipes sécurité : - Les règles de permission sont évaluées selon le principe « première correspondance gagnante » — structurez soigneusement les listes allow/deny - Le mode sandbox isole le système de fichiers et le réseau pour les codebases non fiables - Les patterns Bash ne correspondent qu’aux préfixes — Bash(curl:*) bloque tous les curl, pas seulement des URL spécifiques - Les paramètres gérés en entreprise ne peuvent pas être remplacés par les utilisateurs

Pour les responsables d’équipe : - Les skills s’activent automatiquement en fonction du contexte — intégrez l’expertise métier sans invocation explicite - Les skills de projet sont committés dans git — les coéquipiers obtiennent automatiquement une expertise standardisée - Le suivi des coûts via /cost affiche la répartition de la session ; prévoyez 10K à 300K TPM par utilisateur selon la taille de l’équipe - Les commandes personnalisées dans .claude/commands/ créent des workflows réutilisables

Pour les architectes entreprise : - Les paramètres gérés déploient des politiques à l’échelle de l’organisation via /etc/claude-code/managed-settings.json - AWS Bedrock, Google Vertex AI et Microsoft Foundry s’intègrent à la facturation cloud existante - La réflexion étendue (Tab pour basculer) améliore le raisonnement complexe à un coût plus élevé - Commencez le pilote avec 5 à 10 développeurs avant le déploiement complet

Carte de référence rapide

Imprimez ceci. Collez-le sur votre écran.

╔═══════════════════════════════════════════════════════════════╗
║                    CLAUDE CODE QUICK REFERENCE                 ║
╠═══════════════════════════════════════════════════════════════╣
║  MODELS                                                        ║
║    haiku     $1/$5/M     Exploration, simple tasks            ║
║    sonnet    $3/$15/M    Daily coding (default)               ║
║    opus      $5/$25/M    Architecture, hard problems          ║
║    sonnet[1m] $6/$22.50/M Large codebases (1M context)        ║
╠═══════════════════════════════════════════════════════════════╣
║  ESSENTIAL COMMANDS                                            ║
║    /compact        Reduce context (do at 50% capacity)        ║
║    /cost           Check session spending                     ║
║    /model opus     Switch to Opus                             ║
║    /status         Show current state                         ║
║    /init           Set up project config                      ║
║    /mcp            Configure integrations                     ║
╠═══════════════════════════════════════════════════════════════╣
║  KEYBOARD SHORTCUTS                                            ║
║    Tab             Toggle extended thinking                   ║
║    Shift+Tab       Cycle permission modes                     ║
║    Ctrl+C          Interrupt current operation                ║
║    Esc → Esc       Rewind last change                         ║
║    Ctrl+L          Clear screen                               ║
╠═══════════════════════════════════════════════════════════════╣
║  PREFIXES                                                      ║
║    #message        Add to persistent memory                   ║
║    @path/file      Reference file in prompt                   ║
║    !command        Execute bash directly                      ║
║    &task           Send to cloud (async)                      ║
╠═══════════════════════════════════════════════════════════════╣
║  CONFIG FILE HIERARCHY (first found wins)                      ║
║    .claude/settings.local.json    Personal (gitignored)       ║
║    .claude/settings.json          Project (shared)            ║
║    ~/.claude/settings.json        User global                 ║
║    /etc/.../managed-settings.json Enterprise (locked)         ║
║    CLAUDE.md                      Project context             ║
╠═══════════════════════════════════════════════════════════════╣
║  DAILY WORKFLOW                                                ║
║    1. claude -c              Continue session                 ║
║    2. Work on features       Use Sonnet                       ║
║    3. /compact               Before context bloats            ║
║    4. /cost                  Check spending                   ║
║    5. Summarize              Clean exit                       ║
╠═══════════════════════════════════════════════════════════════╣
║  DECISION RULES                                                ║
║    Simple task?        → Haiku                                ║
║    Hard reasoning?     → Opus                                 ║
║    Everything else?    → Sonnet                               ║
║    Must always run?    → Hook (not prompt)                    ║
║    Auto-apply wisdom?  → Skill (not command)                  ║
║    Needs isolation?    → Subagent                             ║
╚═══════════════════════════════════════════════════════════════╝

Journal des modifications

Cette référence est un document évolutif. Les mises à jour sont appliquées au fur et à mesure de l’évolution de Claude Code.

Exécutez /update-cc-guide pour rechercher et appliquer les dernières mises à jour de Claude Code.

Références