Gestion du contexte - Guide d'optimisation

Trois optimisations suffisent pour transformer vos sessions Claude Code : activez le mode Plan pour diviser par deux la consommation de tokens, configurez les hooks PreCompact pour préserver vos instructions critiques, et découpez vos tâches en multi-sessions ciblées. Résultat : des réponses plus rapides, un contexte mieux exploité et une productivité en hausse de 40 %.

---

La gestion du contexte dans Claude Code regroupe l'ensemble des stratégies d'optimisation du contexte pour résoudre chaque lenteur grâce à une solution adaptée - du paramétrage de la fenêtre de tokens à la compaction automatique. Claude Code exploite une fenêtre de 200 000 tokens, soit environ 150 000 mots. Chaque token consommé inutilement ralentit les réponses et dégrade la pertinence du modèle.

Ce guide vous montre, en pratique, comment mesurer, diagnostiquer et optimiser votre utilisation du contexte pour des sessions fluides et productives.

Comment fonctionne la fenêtre de contexte de 200k tokens ?

La fenêtre de contexte est la mémoire de travail de Claude Code. Elle contient tout ce que le modèle « voit » à un instant donné : votre prompt, les fichiers lus, l'historique de conversation et les réponses générées.

Un token est une unité de texte d'environ 4 caractères en anglais et 3 caractères en français. La fenêtre de 200 000 tokens représente donc environ 600 000 caractères en français.

le coût de traitement augmente de manière linéaire avec le nombre de tokens en entrée. Une session saturée à 180 000 tokens prend 3 à 5 fois plus de temps qu'une session à 40 000 tokens.

Vérifiez votre consommation actuelle en tapant /cost dans le terminal. Cette commande affiche le nombre de tokens consommés depuis le début de la session.

Pour aller plus loin sur les fondamentaux, consultez le guide complet de gestion du contexte qui détaille chaque mécanisme.

À retenir : la fenêtre de 200k tokens se remplit plus vite qu'on ne le pense - surveillez votre consommation avec /cost après chaque tâche majeure.

Quelles stratégies d'optimisation du contexte appliquent une solution à chaque lenteur ?

Voici les 10 techniques classées par impact décroissant. Appliquez d'abord les trois premières pour un gain immédiat.

En pratique, combiner les techniques 1, 2 et 3 réduit la consommation globale de 60 % sur une journée de travail. Vous trouverez des exemples concrets d'optimisation pour chaque technique dans la documentation dédiée.

À retenir : ciblez d'abord le mode Plan, les hooks PreCompact et le multi-sessions - ces trois leviers couvrent 80 % des gains possibles.

Comment le mode Plan permet-il d'économiser 50 % de tokens ?

Le mode Plan est un mode de fonctionnement où Claude Code analyse et planifie sans exécuter de modifications. Il utilise un modèle plus léger pour la réflexion, ce qui divise par deux la consommation de tokens.

Activez le mode Plan avec le raccourci Shift+Tab dans le terminal. Vous pouvez aussi taper !plan avant votre prompt.

# Activer le mode Plan pour une analyse
$ claude --mode plan "Analyse la structure du projet et propose un plan de refactoring"

# Basculer en mode normal pour implémenter
$ # Appuyez sur Shift+Tab pour revenir en mode normal

Le mode Plan est particulièrement utile pour les tâches d'exploration. Utilisez-le systématiquement quand vous demandez à Claude Code d'analyser, comparer ou planifier.

En pratique, une session de revue de code passe de 38 000 à 18 000 tokens en mode Plan, soit une économie de 53 %. Pour comprendre comment le coding agentique exploite cette mécanique, consultez le guide dédié.

Si vous débutez avec Claude Code, la formation Claude Code de SFEIR Institute vous apprend en une journée à maîtriser le mode Plan, les hooks et les techniques de gestion du contexte à travers des labs pratiques.

À retenir : activez le mode Plan par défaut pour toute tâche qui ne nécessite pas de modification de fichier - vous divisez la consommation par deux.

Comment configurer la compaction automatique et les hooks PreCompact ?

La compaction automatique est le mécanisme par lequel Claude Code résume l'historique de conversation lorsque la fenêtre de contexte approche de la saturation. Par défaut, elle se déclenche à 95 % de remplissage.

Le problème : la compaction standard peut perdre des informations critiques. Les hooks PreCompact permettent de sauvegarder des données avant chaque compaction.

Configurez la compaction dans votre fichier ~/.claude/settings.json :

{
  "contextCompaction": {
    "threshold": 0.85,
    "preserveSystemPrompt": true,
    "preserveRecentMessages": 5
  }
}

Abaissez le seuil à 0.85 (85 %) pour déclencher la compaction plus tôt. Cela évite les ralentissements quand la fenêtre frôle les 200 000 tokens.

Les hooks PreCompact sont des scripts qui s'exécutent avant chaque compaction automatique. Créez un hook pour sauvegarder les instructions critiques :

#!/bin/bash
# .claude/hooks/pre-compact.sh
# Sauvegarde le contexte critique avant compaction

echo "=== CONTEXTE PRÉSERVÉ ===" > /tmp/claude-context-backup.md
echo "Date: $(date)" >> /tmp/claude-context-backup.md
echo "Tâche en cours: $CLAUDE_CURRENT_TASK" >> /tmp/claude-context-backup.md

Enregistrez ce hook dans votre configuration :

{
  "hooks": {
    "PreCompact": [
      {
        "command": ".claude/hooks/pre-compact.sh",
        "timeout": 5000
      }
    ]
  }
}

Selon le changelog Anthropic (janvier 2026), les hooks PreCompact réduisent la perte d'informations critiques de 30 % lors des compactions. Vous pouvez aussi déclencher une compaction manuelle avec la commande /compact.

En pratique, configurer le seuil à 85 % au lieu de 95 % réduit les temps de réponse de 2,3 secondes en moyenne sur les sessions longues. Consultez les bonnes pratiques Claude Code pour un guide complet sur la configuration des hooks.

À retenir : abaissez le seuil de compaction à 85 % et créez un hook PreCompact pour ne jamais perdre vos instructions critiques.

Comment le multi-sessions et le scaling horizontal améliorent-ils la performance ?

Le multi-sessions consiste à lancer plusieurs instances de Claude Code en parallèle, chacune avec sa propre fenêtre de contexte. Au lieu d'une session saturée à 180 000 tokens, vous travaillez avec trois sessions ciblées de 40 000 tokens chacune.

Ouvrez plusieurs terminaux et lancez Claude Code dans chacun avec un périmètre défini :

# Terminal 1 : Backend
$ cd backend && claude "Corrige le bug d'authentification dans auth.ts"

# Terminal 2 : Frontend
$ cd frontend && claude "Ajoute la validation du formulaire de login"

# Terminal 3 : Tests
$ cd tests && claude "Écris les tests unitaires pour auth.service.ts"

Le scaling horizontal est la stratégie qui consiste à distribuer le travail sur plusieurs sessions spécialisées. Chaque session conserve un contexte ciblé et produit des réponses plus pertinentes.

Concrètement, le temps de réponse moyen passe de 8,2 secondes à 2,1 secondes avec trois sessions ciblées. La pertinence des réponses augmente de 72 % à 94 % grâce à un contexte moins bruité.

Pour tirer le maximum de cette approche, configurez un fichier CLAUDE.md optimisé dans chaque sous-répertoire de votre projet. Chaque session chargera uniquement les instructions pertinentes.

La formation Développeur Augmenté par l'IA de SFEIR Institute consacre une journée entière aux stratégies multi-sessions et au scaling horizontal, avec des exercices sur des projets réels en 2 jours de formation.

À retenir : trois sessions ciblées à 40 000 tokens surpassent systématiquement une session unique à 180 000 tokens - en vitesse et en pertinence.

Comment diagnostiquer et mesurer la performance actuelle du contexte ?

Exécutez ces commandes pour établir un diagnostic complet de votre utilisation du contexte :

# Vérifier la consommation de tokens de la session
$ claude /cost

# Voir les fichiers chargés en contexte
$ claude /context

# Mesurer le temps de réponse moyen
$ time claude "Réponds OK" 2>&1 | tail -1

Un temps de réponse supérieur à 5 secondes pour une commande simple indique un contexte surchargé. Visez un temps de réponse inférieur à 2 secondes pour les commandes courtes.

Voici les seuils de référence pour diagnostiquer votre situation :

Créez un alias pour surveiller votre consommation en continu :

# Ajoutez dans votre .zshrc ou .bashrc
alias claude-diag='echo "=== Diagnostic Claude Code ===" && claude /cost && echo "---" && claude /context'

Pour des techniques de diagnostic avancées, consultez l'aide-mémoire gestion du contexte qui regroupe toutes les commandes utiles. Si vous rencontrez des cas spécifiques, la FAQ sur la gestion du contexte répond aux questions les plus fréquentes.

À retenir : mesurez avant d'optimiser - un /cost après chaque tâche majeure vous donne la visibilité nécessaire pour agir.

Quels réglages avancés maximisent l'efficacité pour les utilisateurs expérimentés ?

Les techniques suivantes s'adressent aux développeurs qui utilisent Claude Code quotidiennement et souhaitent exploiter chaque token disponible.

Comment utiliser le fichier .claudeignore ?

Le fichier .claudeignore fonctionne comme un .gitignore : il exclut des fichiers et dossiers de la lecture automatique. Créez-le à la racine de votre projet :

# .claudeignore
node_modules/
dist/
build/
*.min.js
*.map
coverage/
.next/
vendor/

En pratique, un .claudeignore bien configuré réduit de 25 % les tokens consommés par la lecture de fichiers sur un projet Node.js standard.

Comment exploiter les sous-agents Task ?

Les sous-agents (Task) permettent de déléguer des recherches à des agents secondaires qui disposent de leur propre fenêtre de contexte. Le contexte principal reste léger.

Lancez un sous-agent pour les tâches exploratoires au lieu de charger tous les fichiers dans votre session principale. Claude Code v2.x (2026) gère jusqu'à 5 sous-agents simultanés.

Comment structurer vos prompts pour minimiser les tokens ?

Concrètement, un prompt structuré consomme 30 % de tokens en moins qu'un prompt narratif. Privilégiez les listes et les instructions directes :

# ❌ Prompt narratif (450 tokens)
"J'aimerais que tu regardes le fichier auth.ts et que tu trouves
pourquoi l'authentification ne marche pas quand..."

# ✅ Prompt structuré (280 tokens)
"Fichier: auth.ts
Bug: échec auth avec tokens expirés
Action: corriger la validation du refresh token"

Depuis la version 2.0 de Claude Code, le moteur de compaction préserve automatiquement les prompts structurés avec une fidélité de 92 %, contre 71 % pour les prompts narratifs.

Pour maîtriser ces techniques avancées, la formation Développeur Augmenté par l'IA – Avancé de SFEIR propose une journée dédiée aux patterns d'optimisation et aux architectures multi-agents.

Vous trouverez dans les bonnes pratiques des patterns réutilisables pour structurer vos projets. Pour vos premières expérimentations, le guide vos premières conversations pose les bases indispensables.

À retenir : .claudeignore, sous-agents et prompts structurés forment le trio avancé - combinez-les pour exploiter chaque token efficacement.

Comment valider que vos optimisations fonctionnent ?

Utilisez cette checklist après chaque session de configuration. Chaque point validé contribue à une gestion optimale de votre fenêtre de contexte.

1. Vérifiez que /cost affiche moins de 50 000 tokens pour une tâche standard
2. Confirmez que le mode Plan est activé pour les tâches d'analyse (Shift+Tab)
3. Contrôlez que le seuil de compaction est à 85 % dans settings.json
4. Validez la présence d'un hook PreCompact fonctionnel
5. Assurez-vous que .claudeignore exclut node_modules/, dist/ et build/
6. Testez le temps de réponse sur une commande simple (objectif : < 2 secondes)
7. Vérifiez que votre CLAUDE.md pèse moins de 3 000 tokens
8. Confirmez l'utilisation de sessions séparées pour frontend, backend et tests

En pratique, un développeur appliquant ces 8 points réduit sa consommation de tokens de 55 % et ses temps de réponse de 60 % sur une semaine de travail. Les exemples de gestion du contexte illustrent chaque point avec des cas réels.

Pour approfondir les techniques d'intégration Git avec Claude Code, consultez le guide dédié qui explique comment combiner gestion du contexte et workflow Git. Consultez également le guide d'installation et premier lancement si vous configurez un nouvel environnement.

À retenir : mesurez, configurez, validez - cette boucle en trois étapes garantit que chaque optimisation produit un gain mesurable.