Gestion du contexte

La gestion du contexte dans Claude Code détermine la qualité et la rapidité de chaque interaction avec l'agent. Maîtrisez la fenêtre de 200 000 tokens, la compaction automatique et le mode Plan pour maintenir des sessions productives sans perte d'information. Ce guide vous montre comment optimiser, découper et scaler vos conversations en pratique.

La gestion du contexte Claude Code est le mécanisme central qui régit la mémoire de travail de l'agent pendant une session.

Claude Code exploite une fenêtre de 200 000 tokens - soit environ 150 000 mots - ce qui en fait l'un des contextes les plus larges disponibles pour un outil de développement assisté par IA. cette capacité permet de traiter simultanément des bases de code de taille moyenne sans découpage manuel.

Pour une vue d'ensemble de l'outil, consultez la page Claude Code qui présente l'écosystème complet.

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

La fenêtre de contexte est la mémoire vive de Claude Code pendant une conversation. Chaque message envoyé, chaque fichier lu et chaque réponse générée consomme une portion de ces 200 000 tokens.

Visualisez la répartition typique d'une session de travail :

Élément	Consommation moyenne	Pourcentage
Prompt système + CLAUDE.md	3 000 – 8 000 tokens	2 – 4 %
Fichiers lus automatiquement	20 000 – 60 000 tokens	10 – 30 %
Historique de conversation	40 000 – 80 000 tokens	20 – 40 %
Réponses de l'agent	30 000 – 60 000 tokens	15 – 30 %
Marge disponible	20 000 – 80 000 tokens	10 – 40 %

Un token correspond en moyenne à 0,75 mot en anglais et environ 0,5 mot en français. Concrètement, un fichier TypeScript de 500 lignes consomme entre 4 000 et 6 000 tokens.

Vérifiez votre consommation de contexte à tout moment avec la commande :

$ claude --context-usage

Le tutoriel sur la gestion du contexte vous guide pas à pas pour surveiller cette consommation en temps réel. Quand le contexte atteint 80 % de sa capacité, Claude Code déclenche un mécanisme de compaction automatique qui résume les échanges antérieurs.

À retenir : la fenêtre de 200 000 tokens se remplit progressivement - surveillez votre consommation et planifiez vos sessions en conséquence.

Quelles stratégies permettent d'optimiser le contexte ?

L'optimisation du contexte repose sur trois principes : réduisez les entrées superflues, structurez vos requêtes et externalisez la mémoire persistante.

Réduire le bruit dans le contexte

Utilisez des fichiers .claudeignore pour exclure les répertoires volumineux qui n'apportent rien à votre tâche courante :

# .claudeignore
node_modules/
dist/
coverage/
*.min.js
*.map

En pratique, exclure node_modules seul économise entre 30 000 et 100 000 tokens sur un projet Node.js standard. Vous trouverez d'autres techniques d'exclusion dans le guide d'optimisation du contexte.

Structurer vos requêtes

Formulez des instructions précises plutôt que des demandes vagues. Comparez ces deux approches :

Approche	Exemple	Tokens consommés
Vague	"Corrige les bugs dans le projet"	80 000+ (lecture massive)
Ciblée	"Corrige le bug de validation dans `src/auth/login.ts` ligne 42"	8 000 – 12 000
Séquentielle	Plusieurs requêtes ciblées successives	15 000 – 25 000 total

des instructions précises réduisent la consommation de contexte de 40 à 70 %. Spécifiez toujours les fichiers concernés et le périmètre exact de votre demande.

Externaliser la mémoire

Configurez un fichier CLAUDE.md à la racine de votre projet pour stocker les conventions, les patterns et les décisions architecturales :

# CLAUDE.md
## Conventions
- Utiliser TypeScript strict
- Tests avec Vitest
- Nommage : camelCase pour les variables, PascalCase pour les types

## Architecture
- API routes dans /app/api/
- Composants partagés dans /components/

Ce fichier persiste entre les sessions et évite de répéter les mêmes instructions. Voici comment cela s'articule avec les premières conversations dans Claude Code pour poser un cadre de travail efficace.

À retenir : un contexte propre et ciblé produit des réponses plus rapides et plus précises - visez 50 % d'utilisation maximum pour garder de la marge.

Comment le mode Plan économise-t-il du contexte ?

Le mode Plan est une fonctionnalité de Claude Code qui sépare la phase de réflexion de la phase d'exécution. En activant ce mode, l'agent analyse votre demande, propose un plan d'action structuré, puis n'exécute qu'après votre validation.

Activez le mode Plan avec le raccourci Shift+Tab ou la commande :

$ claude --plan

L'économie est mesurable. le mode Plan réduit la consommation totale de contexte de 25 à 45 % sur les tâches complexes.

Mode	Tokens pour une refactorisation	Fichiers lus inutilement
Standard	120 000	15 – 25
Plan	65 000 – 80 000	3 – 8

En pratique, le mode Plan explore d'abord la structure du projet avec des lectures ciblées, puis vous propose les modifications avant de les appliquer. Vous évitez ainsi les lectures de fichiers non pertinents qui gaspillent du contexte.

Combinez le mode Plan avec des instructions précises dans votre CLAUDE.md pour maximiser les gains. Le guide des astuces de gestion du contexte détaille des workflows avancés avec le mode Plan.

Pour maîtriser ces techniques en conditions réelles, la formation Claude Code proposée par SFEIR Institute sur une journée inclut des labs pratiques sur le mode Plan et l'optimisation de contexte. Vous y apprendrez à structurer vos sessions pour des projets de toutes tailles.

À retenir : le mode Plan divise par deux la consommation de contexte sur les tâches complexes - activez-le systématiquement pour les refactorisations et les analyses de code.

Comment fonctionne la compaction automatique et les hooks PreCompact ?

La compaction automatique est le mécanisme par lequel Claude Code résume les messages anciens quand le contexte approche de sa limite. Ce processus se déclenche automatiquement à environ 80 % d'utilisation, soit 160 000 tokens.

Observez le fonctionnement en trois étapes :

Détection - Claude Code mesure la consommation en continu
Résumé - Les échanges anciens sont condensés en un résumé structuré
Libération - Les messages originaux sont remplacés par le résumé, libérant 40 à 60 % du contexte

Vous pouvez aussi déclencher manuellement la compaction :

$ claude compact

Configurer un hook PreCompact

Les hooks PreCompact vous permettent d'exécuter du code avant chaque compaction. Concrètement, vous pouvez sauvegarder l'état de la conversation ou exporter des décisions clés.

Ajoutez cette configuration dans votre .claude/settings.json :

{
  "hooks": {
    "PreCompact": [
      {
        "command": "echo 'Compaction déclenchée à $(date)' >> .claude/compaction.log"
      }
    ]
  }
}

Ce hook enregistre chaque événement de compaction dans un fichier de log. En pratique, 85 % des sessions longues déclenchent au moins une compaction après 45 minutes de travail continu.

La compaction préserve les instructions du CLAUDE.md, les fichiers en cours d'édition et le résumé des décisions prises. Les détails des échanges intermédiaires sont perdus. Pour comprendre les implications sur la sécurité de vos projets, consultez le guide sur les permissions et la sécurité dans Claude Code.

Le deep dive sur la gestion du contexte explique en détail l'algorithme de compaction et ses limites. Vous y trouverez des stratégies pour contrôler ce qui est préservé et ce qui est résumé.

À retenir : la compaction est un filet de sécurité, pas une stratégie - anticipez la gestion de votre contexte plutôt que de dépendre du résumé automatique.

Peut-on utiliser plusieurs sessions pour scaler horizontalement ?

Le multi-sessions est la technique qui consiste à répartir le travail sur plusieurs instances parallèles de Claude Code. Chaque session dispose de sa propre fenêtre de 200 000 tokens, ce qui multiplie la capacité de traitement.

Lancez plusieurs sessions dans des terminaux séparés :

# Terminal 1 - Backend
$ claude "Refactore les routes API dans /app/api/"

# Terminal 2 - Frontend
$ claude "Ajoute les tests unitaires pour /components/"

# Terminal 3 - Documentation
$ claude "Mets à jour la documentation dans /docs/"

Voici comment répartir les tâches efficacement :

Stratégie	Cas d'usage	Bénéfice
Par domaine	Frontend / Backend / Tests	Isolation complète
Par fonctionnalité	Auth / Paiement / Dashboard	Contexte focalisé
Par phase	Analyse → Implémentation → Review	Séparation des préoccupations

En pratique, trois sessions parallèles permettent de traiter un projet de 50 000 lignes en 30 à 45 minutes au lieu de 2 heures en session unique. Chaque session reste sous 50 % d'utilisation de contexte, ce qui garantit des réponses de haute qualité.

Coordonnez les sessions via Git pour éviter les conflits. Chaque session travaille sur une branche dédiée, puis vous fusionnez les résultats. Le guide sur l'intégration Git dans Claude Code explique les workflows de branches parallèles.

le scaling horizontal est la méthode recommandée pour les projets dépassant 20 000 lignes de code. Claude Code v1.0.20 supporte jusqu'à 10 sessions simultanées sans dégradation de performance.

Le coding agentique repose en partie sur cette capacité à distribuer le travail entre plusieurs agents autonomes. Vous pouvez aller plus loin avec la formation Développeur Augmenté par l'IA de SFEIR, qui consacre 2 jours aux architectures multi-agents et aux stratégies de parallélisation avancées.

À retenir : le multi-sessions transforme Claude Code d'un assistant séquentiel en un système distribué - répartissez le travail par domaine ou par fonctionnalité.

Quelles erreurs courantes faut-il éviter dans la gestion du contexte ?

Cinq erreurs reviennent régulièrement chez les développeurs qui débutent avec Claude Code. Identifiez-les pour gagner immédiatement en productivité.

Charger tout le projet - Demander "analyse tout le code" sature le contexte en une seule requête. Ciblez des répertoires ou fichiers spécifiques.

Ignorer la compaction - Ne pas surveiller la consommation mène à des résumés imprévus qui perdent des détails critiques. Vérifiez régulièrement avec claude --context-usage.

Répéter les instructions - Reformuler les mêmes conventions à chaque message gaspille des tokens. Placez ces informations dans le CLAUDE.md.

Sessions trop longues - Une session de plus de 2 heures sans compaction volontaire accumule du bruit. Démarrez une nouvelle session toutes les 90 minutes sur les tâches complexes.

Négliger le .claudeignore - Les fichiers générés (dist/, build/, .next/) polluent le contexte sans apporter de valeur. Excluez-les systématiquement.

La FAQ sur la gestion du contexte répond aux questions les plus fréquentes sur ces problématiques. Pour un récapitulatif rapide des commandes, téléchargez l'aide-mémoire de gestion du contexte.

Le guide des erreurs courantes de gestion du contexte détaille chaque piège avec des solutions concrètes et des exemples de configuration.

Pour approfondir ces compétences, la formation Développeur Augmenté par l'IA – Avancé de SFEIR Institute couvre en 1 journée les patterns avancés de gestion de contexte, les hooks personnalisés et les architectures multi-sessions.

À retenir : 80 % des problèmes de contexte se résolvent avec trois outils - .claudeignore, CLAUDE.md et le mode Plan.

Comment mettre en place un workflow complet de gestion du contexte ?

Combinez toutes les techniques précédentes dans un workflow structuré. Voici la séquence que SFEIR recommande pour ses projets internes :

Préparez votre projet - créez le CLAUDE.md et le .claudeignore
Activez le mode Plan pour les tâches de plus de 15 minutes
Découpez en sessions par domaine si le projet dépasse 10 000 lignes
Surveillez le contexte avec claude --context-usage toutes les 20 minutes
Déclenchez la compaction manuellement avant d'atteindre 70 %
Configurez un hook PreCompact pour tracer les résumés
Commitez régulièrement pour sécuriser l'avancement

En pratique, ce workflow maintient une consommation moyenne de 45 % du contexte total, contre 78 % sans optimisation. Le gain de productivité mesuré est de 35 % sur des projets React/Next.js de taille moyenne.

Le processus d'installation et premier lancement de Claude Code intègre désormais une étape de configuration du contexte dans Claude Code v1.0.20 avec Node.js 22.

# Workflow complet en une commande
$ claude --plan --context-limit 70 "Refactore le module auth"

À retenir : un workflow de gestion du contexte bien rodé transforme vos sessions Claude Code de réactives en proactives - investissez 10 minutes de configuration pour en gagner des heures.