Gestion du contexte - Analyse approfondie

La gestion du contexte dans Claude Code détermine la qualité de chaque réponse générée. Maîtriser la fenêtre de contexte (jusqu'à 1 million de tokens sur les modèles actuels), la compaction automatique et le mode Plan vous permet de maintenir des sessions productives sur des projets complexes. Voici comment optimiser chaque token pour un scaling horizontal efficace via les multi-sessions.

La gestion du contexte dans Claude Code est le mécanisme qui contrôle quelles informations l'agent conserve, compresse ou évacue au fil d'une session de travail. Claude Code exploite une fenêtre pouvant atteindre 1 million de tokens sur les modèles actuels (Opus 4.6 et plus récents, Sonnet 4.6) pour analyser votre codebase, générer du code et maintenir la cohérence de ses réponses. La fenêtre de 200 000 tokens reste la valeur par défaut sur les modèles plus anciens et sur les déploiements Bedrock, Vertex et Foundry.

La fenêtre de contexte de Claude représente l'un des plus grands espaces de travail disponibles parmi les modèles de langage actuels, avec jusqu'à 1 million de tokens sur les modèles récents. Cette capacité influence directement la profondeur d'analyse possible sur un projet.

Comment fonctionne la fenêtre de contexte dans Claude Code ?

La fenêtre de contexte est la mémoire de travail active de Claude Code pendant une session. Chaque élément consommé (prompt système, fichiers lus, réponses générées) occupe une portion mesurable de cette fenêtre, qui peut atteindre 1 million de tokens sur les modèles actuels (200 000 par défaut sur les modèles plus anciens et sur Bedrock, Vertex ou Foundry).

Décomposez cette fenêtre en plusieurs zones distinctes : le prompt système et les instructions CLAUDE.md, les fichiers de code lus, l'historique de conversation et les réponses générées. Les proportions varient fortement selon votre configuration et votre usage. Anthropic ne publie pas de répartition fixe ; la seule source fiable est la commande /context, qui affiche la décomposition réelle en temps réel.

Pour comprendre la répartition concrète, consultez le guide complet de gestion du contexte qui détaille chaque composant de la fenêtre.

À titre purement indicatif, la répartition peut ressembler à ceci sur une session de développement classique. Ces ordres de grandeur ne sont pas des valeurs documentées : reportez-vous à /context pour les chiffres exacts de votre session.

Un token correspond à environ 0,75 mot en anglais et 0,5 mot en français. En pratique, la fenêtre permet de charger simultanément plusieurs dizaines de fichiers de taille moyenne dans une seule session.

Vérifiez la répartition de votre fenêtre de contexte en cours de session avec la commande /context, qui affiche l'utilisation par zone sous forme de grille colorée. Pour suivre le coût et les statistiques d'usage de la session, utilisez /cost (alias de /usage).

# Visualiser l'utilisation du contexte en session
$ claude # dans le répertoire du projet
> /context
# Affiche la répartition des tokens par zone (système, fichiers, historique, réponses)

À retenir : la fenêtre de contexte se décompose en plusieurs zones dont la répartition varie selon votre usage et n'est pas figée. Surveillez votre consommation réelle avec /context pour éviter les compactions prématurées.

Quelles stratégies d'optimisation du contexte appliquer ?

L'optimisation du contexte consiste à maximiser la quantité d'informations utiles par token consommé. Adoptez trois stratégies complémentaires pour y parvenir.

Première stratégie : le fichier CLAUDE.md. Ce fichier permet de fournir des instructions persistantes sans les répéter à chaque message. Créez un fichier CLAUDE.md à la racine de votre projet avec vos conventions de code, vos patterns architecturaux et vos règles de nommage.

# CLAUDE.md
## Conventions
- TypeScript strict, pas de `any`
- Tests avec Vitest, couverture > 80%
- Commits conventionnels (feat:, fix:, chore:)
## Architecture
- Clean architecture avec ports/adapters
- Services injectés via constructeur

le fichier CLAUDE.md réduit fortement la consommation de tokens sur les sessions longues en éliminant les instructions répétées. Pour approfondir les bonnes pratiques de configuration, consultez le guide des bonnes pratiques Claude Code.

Deuxième stratégie : les instructions ciblées. Formulez vos prompts avec précision en indiquant le fichier exact, la fonction concernée et le résultat attendu. Un prompt précis consomme nettement moins de tokens qu'un prompt vague, car Claude Code n'a pas besoin d'explorer pour comprendre votre intention.

La consommation réelle dépend entièrement de votre codebase et du chemin d'exploration suivi par Claude Code, et non d'une valeur fixe liée à la formulation. Le tableau ci-dessous compare donc qualitativement l'efficacité de chaque style de prompt.

Troisième stratégie : la segmentation des tâches. Divisez les modifications complexes en sous-tâches indépendantes. Une refactorisation de 20 fichiers consomme moins de contexte quand elle est découpée en 4 sessions de 5 fichiers qu'en une seule session massive.

Découvrez des exemples concrets d'optimisation du contexte pour appliquer ces stratégies sur vos projets réels.

À retenir : combinez CLAUDE.md, prompts ciblés et segmentation des tâches pour réduire sensiblement votre consommation de tokens.

Comment le mode Plan permet-il d'économiser 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. Activez-le avec la touche Shift+Tab ou en tapant la commande dédiée dans votre session.

En mode Plan, Claude Code analyse votre demande, explore le code et propose une stratégie, sans exécuter de modifications. Concrètement, cette séparation économise des tokens sur les tâches complexes.

# Activer le mode Plan dans Claude Code
$ claude
> [Shift+Tab] # Bascule en mode Plan
> Refactorise le module d'authentification pour utiliser JWT
# Claude Code analyse et propose un plan sans modifier de fichiers

Le mode Plan est un mode de permission : il sépare la phase d'exploration et de planification de la phase d'exécution, sans que Claude Code modifie de fichiers tant que vous n'avez pas validé le plan. En mode Plan, l'exploration ciblée évite de charger inutilement des fichiers, ce qui réduit la consommation de tokens utiles dans la fenêtre de contexte. Au lieu d'ouvrir de nombreux fichiers pour deviner votre intention, Claude Code raisonne sur une demande structurée puis propose un plan. Le raisonnement étendu (extended thinking) est une fonctionnalité distincte, activable indépendamment, qui peut compléter le mode Plan mais n'en constitue pas le mécanisme.

Utilisez le mode Plan systématiquement pour les tâches impliquant plus de 3 fichiers. Avant toute refactorisation, lancez une analyse en mode Plan pour identifier les fichiers impactés et les dépendances, puis validez le plan avant l'exécution.

Le guide d'optimisation du contexte de SFEIR Institute détaille des workflows avancés combinant le mode Plan et les sessions segmentées.

L'arbre de décision est simple. Si votre tâche touche 1 à 2 fichiers → mode normal. Si elle touche 3 fichiers ou plus → mode Plan. Si elle implique une refactorisation transverse → mode Plan + multi-sessions.

À retenir : le mode Plan économise un nombre significatif de tokens sur les tâches complexes en séparant réflexion et exécution.

Comment fonctionne la compaction automatique dans Claude Code ?

La compaction automatique est le mécanisme par lequel Claude Code compresse l'historique de conversation quand la fenêtre de contexte approche sa limite. Ce processus se déclenche automatiquement lorsque la conversation approche la limite de la fenêtre de contexte.

Comprenez le processus en trois étapes. D'abord, Claude Code identifie les messages les plus anciens dans la conversation. Ensuite, il résume ces échanges en conservant les décisions clés, les fichiers modifiés et les erreurs rencontrées. Enfin, il remplace les messages originaux par ce résumé compressé.

Le schéma conceptuel ci-dessous illustre la logique de la compaction. Il ne s'agit pas d'une configuration réelle : ces seuils sont gérés en interne par Claude Code et ne sont pas exposés via des clés de settings.json.

// Illustration conceptuelle - PAS une configuration valide
{
 "compaction": {
 "declenchement": "à l'approche de la limite de la fenêtre de contexte",
 "elements_preserves": [
 "modifications de fichiers",
 "messages d'erreur",
 "décisions utilisateur",
 "contexte de la tâche en cours"
 ]
 }
}

En pratique, une compaction réduit nettement la taille du contexte tout en conservant la grande majorité des informations pertinentes, ce qui préserve la qualité des réponses pour les tâches de codage standard.

Le hook PreCompact vous donne un contrôle supplémentaire. Configurez ce hook dans votre fichier .claude/settings.json pour exécuter des actions avant chaque compaction : par exemple sauvegarder l'état du projet ou journaliser les décisions.

// .claude/settings.json
{
 "hooks": {
 "PreCompact": [
 {
 "matcher": "auto",
 "hooks": [
 {
 "type": "command",
 "command": "echo 'Compaction declenchee a $(date)' >> .claude/compaction.log"
 }
 ]
 }
 ]
 }
}

Pour maîtriser la compaction manuelle, consultez l'aide-mémoire sur la gestion du contexte qui liste toutes les commandes disponibles.

La commande /compact déclenche une compaction manuelle avec un texte libre personnalisé. Exécutez /compact focus sur le module auth pour orienter la compression vers les informations pertinentes pour votre tâche en cours. Vous pouvez aussi utiliser /context pour visualiser l'utilisation du contexte sous forme de grille colorée, ou /rewind (ou Esc+Esc) pour revenir en arrière dans la conversation.

# Compaction manuelle ciblée
> /compact conserve les décisions d'architecture et les erreurs TypeScript
# Réduit la taille du contexte en conservant les informations spécifiées

À retenir : la compaction automatique se déclenche à l'approche de la limite de la fenêtre de contexte et compresse l'historique. Utilisez le hook PreCompact et la commande /compact pour garder le contrôle.

Comment configurer les hooks PreCompact pour un contrôle avancé ?

Les hooks PreCompact sont des scripts shell exécutés automatiquement avant chaque opération de compaction. Configurez-les dans le fichier .claude/settings.json au niveau projet ou dans ~/.claude/settings.json au niveau global.

Un hook PreCompact reçoit en entrée un objet JSON via stdin contenant les champs communs aux hooks (session_id, transcript_path, cwd, hook_event_name) ainsi qu'un champ trigger qui indique si la compaction est manual ou auto. Exploitez ces données pour automatiser vos workflows.

#!/bin/bash
# .claude/hooks/pre-compact.sh
# Sauvegarde automatique avant compaction

# Lire les données de compaction depuis stdin
COMPACTION_DATA=$(cat)
SESSION_ID=$(echo "$COMPACTION_DATA" | jq -r '.session_id')
TRIGGER=$(echo "$COMPACTION_DATA" | jq -r '.trigger')

# Créer un snapshot git de l'état courant
git stash push -m "pre-compact-$(date +%s)"

echo "Snapshot créé pour la session $SESSION_ID (déclencheur : $TRIGGER)"

Voici un cas d'usage concret : vous travaillez sur une migration de base de données avec 15 fichiers de migration. Configurez un hook PreCompact qui sauvegarde l'état de progression pour le restaurer après compaction.

Pour aller plus loin sur les workflows automatisés, le guide sur le coding agentique en profondeur explore les patterns avancés d'orchestration avec Claude Code.

En pratique, les équipes qui utilisent des hooks PreCompact limitent sensiblement les pertes d'information lors des sessions longues.

À retenir : les hooks PreCompact automatisent la sauvegarde d'état avant compaction : configurez-les pour ne jamais perdre le fil d'une session longue.

Comment mettre en place les multi-sessions et le scaling horizontal ?

Le scaling horizontal avec Claude Code consiste à distribuer le travail sur plusieurs sessions parallèles plutôt que de surcharger une seule fenêtre de contexte. Lancez plusieurs instances de Claude Code, chacune focalisée sur un sous-ensemble de votre projet.

L'architecture multi-sessions repose sur les flags --continue (ou -c, pour reprendre la dernière conversation), --resume (ou -r, pour reprendre une session spécifique par ID ou nom) et --session-id (pour utiliser un UUID de session spécifique). Créez des sessions dédiées par domaine fonctionnel pour maintenir un contexte spécialisé et réduit.

# Lancer 3 sessions parallèles spécialisées
$ # Launch separate claude instances in different directories &
$ # cd ../api-routes && claude &
$ # cd ../frontend && claude &

Le modèle de données partagé entre sessions passe par le fichier CLAUDE.md et le système de fichiers. Documentez les décisions prises dans chaque session via des commentaires de code ou un fichier de décisions partagé. Consultez les bonnes pratiques d'intégration Git pour coordonner les commits entre sessions parallèles.

Pour un isolation complète, combinez les multi-sessions avec les Git worktrees. Chaque session opère sur sa propre copie de travail, éliminant les conflits de fichiers.

# Créer des worktrees isolés pour chaque session
$ git worktree add ../projet-auth feature/auth
$ git worktree add ../projet-api feature/api

# Lancer Claude Code dans chaque worktree
$ cd ../projet-auth && # Launch claude in the auth directory
$ cd ../projet-api && # Launch claude in the api directory

En pratique, le scaling sur plusieurs sessions parallèles améliore le débit de modifications tout en réduisant la fréquence des compactions. Cette approche devient particulièrement utile sur les grandes bases de code.

À retenir : distribuez le travail sur 2 à 4 sessions parallèles avec des Git worktrees pour maximiser le débit sans sacrifier la cohérence du contexte.

Quand ne pas utiliser l'optimisation poussée du contexte ?

Toutes les situations ne justifient pas une stratégie complexe de gestion du contexte. Identifiez les cas où la simplicité l'emporte sur l'optimisation.

Pour les tâches courtes (moins de 10 000 tokens), l'overhead de configuration d'un mode Plan ou de sessions multiples dépasse le bénéfice. Restez en mode normal pour les corrections de bugs ponctuels, les modifications de 1 à 2 fichiers ou les questions exploratoires.

Le prototypage rapide ne bénéficie pas du scaling horizontal. Quand vous explorez des idées, la compaction automatique suffit. Laissez Claude Code gérer le contexte automatiquement pendant les phases d'expérimentation. Consultez les recommandations pour vos premières conversations avant de complexifier votre workflow.

Voici l'arbre de décision complet :

• Si votre tâche touche 1 à 3 fichiers et dure moins de 30 minutes → mode normal, pas d'optimisation
• Si votre tâche touche 4 à 10 fichiers → activez le mode Plan, utilisez /compact manuellement
• Si votre tâche touche plus de 10 fichiers ou dure plus de 2 heures → multi-sessions avec worktrees
• Si vous travaillez en équipe sur le même projet → multi-sessions + CLAUDE.md partagé + hooks PreCompact
• Si votre codebase dépasse 100 000 lignes → considérez le coding agentique avec orchestration

En pratique, la majorité des tâches quotidiennes d'un développeur se résolvent en mode normal sans optimisation du contexte. L'optimisation apporte ses gains sur les 30 % restants : les tâches longues, complexes ou multi-fichiers.

SFEIR Institute propose la formation Claude Code d'une journée pour maîtriser ces techniques de gestion du contexte en conditions réelles avec des labs pratiques. Pour aller plus loin, la formation Développeur Augmenté par l'IA sur 2 jours couvre l'ensemble du workflow agentique, y compris le scaling horizontal sur des projets d'entreprise. Les profils confirmés peuvent suivre la formation Développeur Augmenté par l'IA – Avancé d'une journée pour approfondir les hooks, la compaction et les architectures multi-agents.

À retenir : n'optimisez pas par défaut, réservez les stratégies avancées aux tâches qui dépassent 4 fichiers ou 30 minutes de travail.

Quels outils comparer pour la gestion du contexte entre agents IA ?

Claude Code n'est pas le seul agent IA à proposer une gestion du contexte. Comparez les approches pour choisir l'outil adapté à votre besoin. Avant de commencer, consultez le guide d'installation et premier lancement pour vérifier vos prérequis.

Claude Code se distingue par trois avantages : la fenêtre de contexte la plus large (jusqu'à 1M tokens sur les modèles actuels), les hooks personnalisables et le mode Plan natif. Son principal compromis est le modèle de tarification à l'usage, qui incite à optimiser chaque token consommé.

Concrètement, le temps de réponse dépend de la taille du contexte chargé et de la longueur des fichiers traités. Plus le contexte reste ciblé, plus les itérations restent rapides sur les sessions chargées.

À retenir : Claude Code offre la fenêtre de contexte la plus large et le meilleur contrôle via les hooks : choisissez-le pour les projets nécessitant des sessions longues et un contrôle fin.

Comment mesurer et surveiller la performance du contexte ?

Surveiller la consommation de contexte est une pratique essentielle pour maintenir des sessions productives. Mesurez trois métriques clés : le taux de remplissage, la fréquence de compaction et le ratio tokens utiles/tokens totaux.

L'inspection de l'utilisation du contexte se fait de manière interactive, à l'intérieur d'une session Claude Code, avec la commande /context. Elle affiche la répartition des tokens sous forme de grille colorée par zone (prompt système, fichiers lus, historique, etc.).

# Visualiser l'utilisation du contexte pendant une session
$ claude
> /context
# Affiche la répartition des tokens par zone sous forme de grille colorée

Un taux de remplissage élevé maintenu pendant plusieurs minutes indique qu'une compaction imminente va interrompre votre flux de travail. Anticipez en déclenchant /compact manuellement avec un prompt ciblé.

Pour consolider vos connaissances sur ces métriques, le guide d'optimisation du contexte de SFEIR fournit des tableaux de bord prêts à l'emploi.

Les indicateurs de santé d'une session se résument ainsi :

• Taux de remplissage faible → session saine, continuez normalement
• Taux de remplissage modéré → planifiez une compaction manuelle ou un découpage en sous-tâches
• Fenêtre proche de sa limite → déclenchez /compact immédiatement ou démarrez une nouvelle session
• Compactions répétées en peu de temps → votre tâche nécessite un scaling horizontal

En pratique, les développeurs formés atteignent un bien meilleur ratio de tokens utiles par rapport à ceux sans formation, avec un gain d'efficacité notable sur les sessions longues.

À retenir : surveillez le taux de remplissage affiché par /context et déclenchez /compact lorsque la fenêtre approche de sa limite, afin de préserver un ratio de tokens utiles élevé.