Gestion du contexte - Guide d'optimisation

Trois optimisations suffisent pour transformer vos sessions Claude Code : activez le mode Plan pour planifier sans consommer le contexte en modifications, 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é accrue.

---

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. Sur les modèles actuels (Opus 4.6 et plus récents, Sonnet 4.6), Claude Code exploite une fenêtre pouvant atteindre 1 000 000 de tokens. La valeur historique de 200 000 tokens reste celle des modèles plus anciens et des configurations Bedrock, Vertex et Foundry par défaut. 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 ?

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. Sur les modèles actuels, la fenêtre peut atteindre 1 000 000 de tokens (sur les plans Max, Team et Enterprise, Opus est automatiquement étendu à 1M ; la fenêtre 1M de Sonnet nécessite des crédits d'usage). La valeur historique de 200 000 tokens, qui représente environ 600 000 caractères en français, reste celle des modèles plus anciens et des configurations Bedrock, Vertex et Foundry par défaut.

le coût de traitement augmente de manière linéaire avec le nombre de tokens en entrée. Une session saturée proche de la limite prend nettement plus de temps qu'une session légère au contexte ciblé.

Vérifiez votre consommation actuelle en tapant /context dans une session interactive. Cette commande visualise l'occupation de la fenêtre de contexte, et /context all en détaille la répartition par élément. La commande /cost (alias de /usage), elle, renseigne sur le coût de la session et les limites de votre plan.

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

À retenir : même large, la fenêtre de contexte se remplit plus vite qu'on ne le pense. Surveillez son occupation avec /context 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 (la colonne « Impact » donne des ordres de grandeur indicatifs, pas des mesures officielles).

En pratique, combiner les techniques 1, 2 et 3 réduit nettement la consommation globale 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 la majorité des gains possibles.

Comment le mode Plan permet-il d'économiser des tokens ?

Le mode Plan est un mode de permission (que l'on fait défiler avec Shift+Tab) dans lequel Claude Code analyse et planifie sans exécuter de modification de fichier. En se limitant à la réflexion et à l'exploration, il évite les allers-retours d'édition qui alourdissent le contexte.

Activez le mode Plan avec le raccourci Shift+Tab dans le terminal.

# Activer le mode Plan pour une analyse
> # Appuyez sur Shift+Tab pour activer le 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.

Le tableau ci-dessous illustre, à titre indicatif, le type de scénarios où le mode Plan évite la consommation liée aux modifications (les valeurs sont des ordres de grandeur, pas des mesures officielles) :

En pratique, une session de revue de code reste plus légère en mode Plan, puisque Claude se concentre sur l'analyse sans déclencher d'éditions. 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 limitez ainsi les éditions inutiles qui saturent le contexte.

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 lorsque le contexte approche de sa limite.

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

La compaction automatique se déclenche d'elle-même lorsque la fenêtre de contexte approche de sa limite : il n'existe pas de clé dans settings.json pour fixer un seuil de déclenchement en pourcentage. Vous pouvez en revanche déclencher une compaction manuellement avec la commande /compact dans une session interactive, sans attendre la saturation.

Les hooks PreCompact sont des scripts qui s'exécutent avant chaque compaction (automatique ou manuelle). 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 "Projet: $CLAUDE_PROJECT_DIR" >> /tmp/claude-context-backup.md
# Le hook reçoit aussi un JSON sur stdin (lisible avec jq)

Enregistrez ce hook dans votre configuration :

{
 "hooks": {
 "PreCompact": [
 {
 "matcher": "auto",
 "hooks": [
 {
 "type": "command",
 "command": ".claude/hooks/pre-compact.sh",
 "timeout": 30
 }
 ]
 }
 ]
 }
}

Chaque entrée de l'événement comporte un matcher (ici auto pour la compaction automatique, manual pour /compact) et un tableau hooks dont chaque handler précise "type": "command". Le timeout est exprimé en secondes (600 par défaut).

Les hooks PreCompact vous permettent de persister le contexte important avant chaque compaction, ce qui limite le risque de perdre des informations critiques au moment où l'historique est résumé. Vous pouvez aussi déclencher une compaction manuelle avec la commande /compact dans une session interactive.

En pratique, déclencher la compaction au bon moment (manuellement avec /compact plutôt qu'au dernier moment) garde les sessions longues plus réactives. Consultez les bonnes pratiques Claude Code pour un guide complet sur la configuration des hooks.

À retenir : créez un hook PreCompact et compactez régulièrement avec /compact 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 tableau ci-dessous compare, à titre illustratif, une session saturée et un découpage en sessions ciblées (ordres de grandeur, pas des mesures officielles) :

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 s'améliore nettement avec trois sessions ciblées, et la pertinence des réponses augmente 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 comme en pertinence.

Comment diagnostiquer et mesurer la performance actuelle du contexte ?

Lancez d'abord une session interactive, puis utilisez les commandes slash pour établir un diagnostic complet de votre utilisation du contexte :

# Dans une session Claude Code interactive (après avoir lancé `claude`)
/context        # Visualiser l'occupation de la fenêtre de contexte
/context all    # Détailler la répartition par élément
/compact        # Compacter le contexte si nécessaire

Pour mesurer le temps de réponse d'une commande simple en mode non interactif, vous pouvez utiliser le drapeau -p (prompt) depuis le terminal :

# Mesurer le temps de réponse moyen
$ time claude -p "Réponds OK"

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 :

Pensez à utiliser /context au fil de la session pour garder un œil sur l'occupation de la fenêtre, et /cost (alias de /usage) pour suivre le coût et vos limites de plan.

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 /context 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 tirer parti du fichier .gitignore ?

Claude Code respecte par défaut votre fichier .gitignore (réglage respectGitignore, activé par défaut) et exclut donc les fichiers ignorés de la lecture automatique. Créez-le ou complétez-le à la racine de votre projet :

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

En pratique, un .gitignore bien configuré réduit notablement 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 prend en charge les sous-agents pour les tâches exploratoires.

Comment structurer vos prompts pour minimiser les tokens ?

Concrètement, un prompt structuré consomme moins de tokens 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"

Un prompt structuré, plus dense et explicite, est aussi plus facile à résumer fidèlement lors d'une compaction qu'un long prompt narratif. Privilégier ce format aide donc à préserver l'essentiel de vos instructions tout au long de la session.

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 : respect du .gitignore, 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 /context indique moins de 50 000 tokens occupés pour une tâche standard
2. Confirmez que le mode Plan est activé pour les tâches d'analyse (Shift+Tab)
3. Compactez régulièrement avec /compact au lieu d'attendre la saturation du contexte
4. Validez la présence d'un hook PreCompact fonctionnel
5. Assurez-vous que .gitignore 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 nettement sa consommation de tokens et améliore sensiblement ses temps de réponse 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.