Gestion du contexte - Astuces

Maîtriser la gestion du contexte dans Claude Code transforme votre productivité : vous exploitez chaque token utile, évitez les pertes de mémoire et scalez vos sessions sur plusieurs terminaux. Voici 18 astuces concrètes pour optimiser votre fenêtre de contexte, activer la compaction intelligente et tirer parti du mode Plan.

La gestion du contexte dans Claude Code est l'ensemble des techniques qui permettent de maximiser l'utilisation des tokens disponibles par session. Sur les modèles actuels (Opus 4.6 et supérieurs, Sonnet 4.6), la fenêtre de contexte atteint jusqu'à 1 million de tokens (disponibilité générale). La limite historique de 200 000 tokens reste celle des anciens modèles et des configurations par défaut sur Bedrock, Vertex et Foundry. Claude Code, dont le modèle par défaut dépend de votre plan (Sonnet 4.6 sur Pro et Team Standard, Opus 4.8 sur Max, Team Premium, Enterprise et API), offre une fenêtre parmi les plus larges du marché, mais sans stratégie d'optimisation, vous la saturez rapidement en travail intensif.

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

La fenêtre de contexte est la mémoire de travail de votre session Claude Code. Visualisez-la comme un buffer circulaire : chaque message envoyé, chaque fichier lu et chaque résultat de commande consomme des tokens.

En pratique, un fichier TypeScript de 500 lignes occupe environ 4 000 tokens. Une réponse détaillée de Claude en consomme entre 1 500 et 3 000. Sur une fenêtre de 200k tokens, vous disposez donc d'un budget réel d'environ 50 échanges complets avant saturation, et bien davantage sur une fenêtre de 1M tokens.

À titre de repère, une fenêtre de 200k tokens correspond à environ 150 000 mots anglais ou 120 000 mots français ; une fenêtre de 1M tokens élargit ce volume d'un facteur cinq. Pour approfondir la mécanique complète, consultez l'analyse approfondie de la gestion du contexte qui détaille chaque composant.

Astuce 1 : Surveillez votre consommation. La barre de statut de Claude Code affiche un indicateur de remplissage. Quand il dépasse 60 %, envisagez une compaction ou une nouvelle session.

Astuce 2 : Limitez les lectures de fichiers volumineux. Demandez à Claude de ne lire qu'une plage de lignes (par exemple : « lis les lignes 50 à 120 de file.ts ») plutôt que le fichier entier ; l'outil Read accepte une plage via ses paramètres offset/limit. Vous économisez une grande quantité de tokens sur un fichier de 400 lignes.

Astuce 3 : Préférez grep ciblé aux lectures complètes. Plutôt que de lire un fichier pour chercher une fonction, utilisez Grep. Concrètement, une recherche ciblée consomme 200 tokens contre 3 000 pour une lecture intégrale.

À retenir : chaque token compte. Mesurez votre consommation et ciblez vos lectures pour maximiser le nombre d'échanges productifs.

Quelles stratégies d'optimisation du contexte appliquer au quotidien ?

L'optimisation du contexte repose sur un principe simple : injecter uniquement l'information nécessaire à la tâche en cours. Vous trouverez des techniques complémentaires dans le guide d'optimisation du contexte dédié à ce sujet.

Astuce 4 : Structurez votre CLAUDE.md avec parcimonie. Ce fichier est chargé à chaque session. Gardez-le sous 100 lignes (environ 800 tokens). Déplacez les instructions spécifiques dans des fichiers .claude/ séparés que Claude Code charge à la demande.

Astuce 5 : Utilisez des prompts concis et précis. Un prompt de 20 mots bien formulé produit de meilleurs résultats qu'un paragraphe de 150 mots. En pratique, remplacer "Est-ce que tu pourrais s'il te plaît regarder le fichier X et me dire ce qui ne va pas avec la fonction Y" par "Corrige le bug dans X:functionY" réduit nettement la consommation de tokens.

# Mauvais : prompt verbeux
claude "J'aimerais que tu regardes le fichier src/auth.ts et que tu analyses la fonction login pour trouver pourquoi elle ne fonctionne pas correctement quand l'utilisateur entre un mauvais mot de passe"

# Bon : prompt ciblé
claude "Corrige le bug de gestion d'erreur dans src/auth.ts:login"

Astuce 6 : Regroupez les modifications liées dans une même requête. Au lieu de demander 5 modifications séparées sur un composant React, décrivez les 5 changements dans un seul message. Vous économisez les tokens de contexte accumulés entre chaque échange.

Astuce 7 : Évitez les résultats de commande volumineux. Redirigez la sortie des commandes longues dans un fichier puis lisez seulement les lignes pertinentes.

# Au lieu de laisser Claude ingérer 10 000 lignes de logs
npm test 2>&1 | head -50

les utilisateurs qui appliquent ces stratégies prolongent sensiblement leurs sessions productives.

À retenir : concentrez chaque message sur l'essentiel. Un prompt chirurgical vaut mieux qu'une explication fleuve.

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

Le mode Plan est une fonctionnalité de Claude Code qui sépare la phase de réflexion de la phase d'exécution. Cyclez avec le raccourci Shift+Tab (ou Alt+M selon votre configuration) jusqu'au mode Plan : ce raccourci fait défiler les modes de permission (default, acceptEdits, plan). Vous retrouverez d'autres raccourcis dans les astuces sur les commandes slash essentielles.

En mode Plan, Claude Code analyse votre requête et propose une stratégie sans exécuter d'actions. Cette séparation réduit le gaspillage de tokens sur des tentatives inutiles.

Astuce 8 : Activez le mode Plan pour les tâches complexes. Avant un refactoring touchant plus de 3 fichiers, passez en mode Plan. Claude Code proposera un plan structuré que vous validez avant exécution. Résultat : une économie significative de tokens par rapport à une approche exploratoire directe.

Astuce 9 : Utilisez le Plan pour explorer un codebase inconnu. Quand vous abordez un nouveau projet, le mode Plan vous permet d'obtenir une cartographie sans que Claude Code lise chaque fichier. Demandez : "Plan : quels fichiers dois-je modifier pour ajouter l'authentification OAuth ?"

# Basculer en mode Plan depuis la session
> # Appuyez sur Shift+Tab pour activer le mode Plan

# Claude Code analyse et propose sans exécuter
# Vous validez ou ajustez avant toute action

Astuce 10 : Combinez Plan et instructions CLAUDE.md. Inscrivez vos contraintes architecturales dans CLAUDE.md pour que le mode Plan les respecte automatiquement. Concrètement, une directive "Ne jamais modifier les fichiers du dossier core/" empêche Claude Code de proposer des plans qui touchent ce répertoire.

Pour apprendre à formuler vos premiers prompts efficacement, consultez les astuces pour vos premières conversations avec Claude Code.

À retenir : le mode Plan est votre meilleur allié pour les tâches multi-fichiers. Planifiez d'abord, exécutez ensuite.

Comment fonctionne la compaction automatique dans Claude Code ?

La compaction automatique est le mécanisme par lequel Claude Code résume les échanges anciens pour libérer de l'espace dans la fenêtre de contexte. Déclenchez-la manuellement avec /compact ou laissez-la s'activer automatiquement à l'approche de la limite de contexte.

Le processus de compaction conserve les décisions clés, les fichiers modifiés et les instructions persistantes, tout en supprimant les détails intermédiaires. Une compaction réduit sensiblement la taille du contexte.

Astuce 11 : Pilotez ce que la compaction conserve. Le seuil de déclenchement de la compaction automatique n'est pas configurable, mais vous pouvez guider précisément ce qui est préservé. Passez des instructions à /compact pour cibler le résumé :

# Indiquer à Claude ce qu'il doit préserver pendant la compaction
> /compact Focus on code samples and API usage

Vous pouvez aussi inscrire ces consignes durablement dans votre CLAUDE.md, dans une section dédiée que Claude Code applique à chaque compaction :

# Compact instructions

When you are using compact, please focus on test output and code changes

Enfin, /clear repart d'un contexte vierge entre deux tâches sans rapport, ce qui évite de traîner des échanges devenus inutiles.

Astuce 12 : Utilisez les hooks PreCompact pour sauvegarder le contexte critique. Les hooks PreCompact exécutent un script avant chaque compaction. Créez un hook qui exporte l'état actuel dans un fichier de résumé.

#!/bin/bash
#.claude/hooks/pre-compact.sh
echo "=== Session compactée $(date) ===" >>.claude/session-log.md
echo "Fichiers modifiés : $(git diff --name-only)" >>.claude/session-log.md

Pour configurer d'autres hooks avancés, explorez les astuces sur le mode headless et CI/CD qui couvrent l'automatisation complète.

Astuce 13 : Ajoutez un message de résumé avant la compaction. Avant de lancer /compact, écrivez un message récapitulatif : "Résumé : j'ai modifié auth.ts et user.ts pour ajouter la validation JWT. Prochaine étape : tests unitaires." Ce message sera préservé et guidera Claude Code après compaction.

Vous pouvez approfondir ces mécanismes dans le tutoriel sur la gestion du contexte avec des exercices pratiques.

À retenir : la compaction est votre filet de sécurité. Guidez ce qu'elle conserve via /compact et CLAUDE.md, et sauvegardez le contexte critique via les hooks PreCompact.

Peut-on utiliser plusieurs sessions Claude Code en parallèle ?

Le multi-sessions est une stratégie de scaling horizontal où vous exécutez plusieurs instances de Claude Code simultanément sur le même projet. Chaque session dispose de sa propre fenêtre de contexte (jusqu'à 1M tokens sur les modèles actuels), ce qui multiplie votre capacité totale.

Astuce 14 : Dédiez une session par domaine fonctionnel. Ouvrez un terminal pour le backend, un autre pour le frontend et un troisième pour les tests. Chaque session maintient un contexte spécialisé sans pollution croisée.

# Terminal 1 - Backend
cd /project && claude "Focus sur src/api/"

# Terminal 2 - Frontend
cd /project && claude "Focus sur src/components/"

# Terminal 3 - Tests
cd /project && claude "Lance et corrige les tests"

Astuce 15 : Partagez le contexte entre sessions via des fichiers. Créez un fichier .claude/shared-context.md que chaque session peut lire. Inscrivez-y les décisions architecturales prises dans une session pour que les autres en bénéficient.

En pratique, plusieurs sessions parallèles permettent de répartir le travail sur un gros codebase sans saturer une seule fenêtre de contexte. le multi-sessions réduit sensiblement le temps de refactoring sur les gros projets.

Astuce 16 : Utilisez le worktree Git pour isoler les sessions. Créez un worktree par branche de travail. Chaque session Claude Code opère sur un répertoire distinct, éliminant les conflits de fichiers.

# Créer des worktrees pour le travail parallèle
git worktree add ../project-feature-auth feature/auth
git worktree add ../project-feature-ui feature/ui

# Lancer Claude Code sur chaque worktree
cd ../project-feature-auth && claude

Pour des workflows avancés avec le MCP (Model Context Protocol), vous pouvez connecter vos sessions à des serveurs de contexte partagés.

À retenir : le multi-sessions transforme Claude Code en équipe parallèle. Isolez chaque domaine et partagez les décisions via des fichiers communs.

Quels pièges faut-il éviter dans la gestion du contexte ?

Certaines pratiques courantes gaspillent votre fenêtre de contexte sans que vous le réalisiez. Identifiez ces anti-patterns pour les éliminer de votre workflow. Vous trouverez des recommandations complémentaires dans les best practices avancées de Claude Code.

Astuce 17 : Ne demandez jamais "tu te souviens de..." en début de message. Claude Code a accès à tout le contexte de la session. Reformuler une information déjà présente gaspille des tokens. Référencez directement : "Continue le refactoring de auth.ts" plutôt que "Tu te souviens que nous avions commencé à refactorer auth.ts avec la nouvelle architecture..."

Astuce 18 : Ne collez pas de logs entiers dans le chat. Un stacktrace de 200 lignes consomme 1 600 tokens. Copiez uniquement le message d'erreur pertinent (5-10 lignes maximum) ou redirigez le log dans un fichier que Claude Code lira de manière ciblée.

Pour aller plus loin sur les commandes personnalisées et skills, vous pouvez créer des raccourcis qui encapsulent vos workflows optimisés.

À retenir : chaque token gaspillé est un échange productif en moins. Éliminez les redondances et faites confiance au contexte déjà chargé.

Comment structurer une session longue pour ne rien perdre ?

Une session longue (plus de 2 heures) nécessite une stratégie de conservation du contexte. Planifiez vos points de compaction et vos transitions entre sessions. Le guide complet de gestion du contexte couvre l'ensemble de ces stratégies en détail.

Astuce : Découpez votre travail en sprints de 30 minutes. Chaque sprint correspond à une fonctionnalité ou un correctif précis. Entre deux sprints, lancez /compact avec un résumé explicite. Cette approche maintient une haute performance sur des sessions de 4 heures.

Astuce : Exportez votre état avant de quitter. En fin de session, demandez à Claude Code de résumer les décisions prises, les fichiers modifiés et les tâches restantes. Sauvegardez ce résumé dans un fichier .claude/session-handoff.md que la prochaine session pourra charger.

<!--.claude/session-handoff.md -->
## État de la session - 20 février 2026

### Décisions prises
- Architecture : JWT avec refresh tokens
- Base de données : PostgreSQL 16 avec Drizzle ORM

### Fichiers modifiés
- src/auth/login.ts (validation ajoutée)
- src/middleware/jwt.ts (nouveau fichier)

### Prochaines étapes
- Écrire les tests pour login.ts
- Implémenter le endpoint /refresh

Selon les formateurs de SFEIR Institute, les développeurs qui utilisent des fichiers de handoff réduisent nettement leur temps de reprise de session. La formation Claude Code d'une journée vous apprend ces techniques de productivité avec des labs pratiques.

Pour approfondir, la formation Développeur Augmenté par l'IA de 2 jours couvre l'intégration complète dans votre workflow de développement, et la formation Développeur Augmenté par l'IA – Avancé d'une journée traite les stratégies multi-agents et le scaling horizontal pour les équipes.

À retenir : une session longue se pilote comme un projet. Découpez en sprints, compactez régulièrement et documentez l'état pour la reprise.

---