12 KiB
Utiliser Claude Code : gestion des sessions & contexte de 1M — Thariq
Un guide sur la gestion des sessions, des fenêtres de contexte et de la compaction dans Claude Code, partagé par Thariq (@trq212) le 16 avril 2026.
| ← Retour à Claude Code Best Practice |  |
Contexte
Avec la fenêtre de contexte de 1M de tokens, Claude Code peut gérer des tâches plus longues de façon plus fiable — mais cela ouvre aussi la porte à la pollution de contexte si tu ne gères pas tes sessions avec intention. La gestion des sessions compte plus que jamais : quand repartir de zéro, quand compacter, quand revenir en arrière, et quand déléguer à des sous-agents.
Petit rappel sur le contexte, la compaction & le context rot
La fenêtre de contexte est tout ce que le modèle peut « voir » d'un coup au moment de générer sa prochaine réponse. Elle inclut ton system prompt, la conversation jusqu'ici, chaque appel d'outil et sa sortie, et chaque fichier lu. Claude Code a une fenêtre de contexte d'un million de tokens.
Malheureusement, utiliser du contexte a un léger coût — le context rot (dégradation du contexte). Les performances du modèle se dégradent à mesure que le contexte grossit, car l'attention se répartit sur davantage de tokens, et le contenu ancien et non pertinent commence à détourner de la tâche en cours. Pour le modèle à 1M de contexte, un certain niveau de context rot survient autour de ~300-400k tokens, mais cela dépend fortement de la tâche — ce n'est pas une règle stricte.
Les fenêtres de contexte sont une limite franche. Quand tu approches de la fin, tu dois résumer la tâche et continuer dans une nouvelle fenêtre de contexte — c'est la compaction. Tu peux aussi déclencher la compaction toi-même.
Chaque tour est un point de branchement
Une fois que Claude termine un tour, tu disposes d'un nombre étonnant d'options pour la suite :
- Continuer — envoyer un autre message dans la même session
- /rewind (esc esc) — revenir à un message précédent et réessayer à partir de là
- /clear — démarrer une nouvelle session, généralement avec un brief distillé de ce que tu viens d'apprendre
- Compacter — résumer la session jusqu'ici et continuer par-dessus le résumé
- Sous-agents — déléguer le prochain bloc de travail à un agent doté de son propre contexte propre, et n'en récupérer que le résultat
Si la voie la plus naturelle est simplement de continuer, les quatre autres options existent pour t'aider à gérer ton contexte.
Chaque option reporte une quantité différente de contexte existant :
| Nouvelle session | Compacter | Sous-agent | Rewind | Continuer |
|---|---|---|---|---|
| ton brief seul | résumé avec perte | tout + résultat | préfixe gardé, fin coupée | tout reste |
| rien | tout |
Quand démarrer une nouvelle session
Les nouvelles fenêtres de contexte de 1M signifient que tu peux désormais faire des tâches plus longues de façon plus fiable — par exemple, construire une app full-stack de zéro. Mais ce n'est pas parce que ton modèle n'est pas à court de contexte que tu ne devrais pas démarrer une nouvelle session.
Règle générale : quand tu commences une nouvelle tâche, tu devrais aussi démarrer une nouvelle session.
Une zone grise apparaît quand tu veux faire des tâches connexes où une partie du contexte reste nécessaire, mais pas tout. Par exemple, écrire la documentation d'une fonctionnalité que tu viens d'implémenter. Tu pourrais démarrer une nouvelle session, mais Claude devrait relire les fichiers, ce qui serait plus lent et plus coûteux. Comme la documentation n'est peut-être pas une tâche très sensible à l'intelligence, le contexte supplémentaire vaut probablement le gain d'efficacité.
Revenir en arrière (rewind) plutôt que corriger
Si Thariq devait choisir une seule habitude qui signale une bonne gestion du contexte, ce serait le rewind.
Dans Claude Code, double-taper Échap (ou lancer /rewind) te permet de revenir à n'importe quel message précédent et de re-prompter à partir de là. Les messages postérieurs à ce point sont retirés du contexte.
Corriger (dire « non, essaie B » après une tentative A ratée) laisse la tentative ratée dans le contexte :
contexte = lectures + 2 tentatives ratées + 2 corrections + le correctif
Revenir en arrière (remonter avant la tentative ratée et re-prompter avec ce que tu as appris) est plus propre :
contexte = lectures + un prompt informé + le correctif
Le rewind est souvent la meilleure approche. Par exemple, Claude lit cinq fichiers, tente une approche, et ça ne marche pas. Ton instinct pourrait être de taper « ça n'a pas marché, essaie X à la place ». Mais le meilleur geste est de revenir juste après les lectures de fichiers, et de re-prompter avec ce que tu as appris : « N'utilise pas l'approche A, le module foo ne l'expose pas — va directement vers B. »
Tu peux aussi utiliser « summarize from here » (résumer à partir d'ici) pour que Claude résume ses apprentissages et crée un message de passation, un peu comme un message à l'itération précédente de Claude de la part de son futur lui qui a essayé quelque chose qui n'a pas marché.
Compacter vs. nouvelles sessions
Une fois qu'une session s'allonge, tu as deux façons de t'alléger : /compact ou /clear (et repartir de zéro). Elles semblent similaires mais se comportent très différemment.
Compacter demande au modèle de résumer la conversation jusqu'ici, puis remplace l'historique par ce résumé. C'est avec perte — tu fais confiance à Claude pour décider de ce qui comptait, mais tu n'as rien eu à écrire toi-même. Claude pourrait être plus exhaustif en incluant des apprentissages ou fichiers importants. Tu peux aussi l'orienter en passant des instructions (/compact concentre-toi sur le refactor d'auth, laisse tomber le débogage des tests).
- En cours de tâche, garde l'élan — les détails peuvent rester flous
- Pas cher, continue
Nouvelle session + brief (/clear) signifie que toi tu notes ce qui compte (« on refactore le middleware d'auth, la contrainte est X, les fichiers qui comptent sont A et B, on a écarté l'approche Y ») et tu repars propre. C'est plus de travail, mais le contexte obtenu est ce que toi tu as jugé pertinent.
- Étape suivante à fort enjeu — un seul fait trouvé dans 100K d'exploration
- Plus de travail, plus exact
Qu'est-ce qui cause une mauvaise compaction ?
Si tu lances beaucoup de sessions de longue haleine, tu as peut-être remarqué des moments où la compaction peut être particulièrement mauvaise. Les mauvaises compactions surviennent quand le modèle ne peut pas prédire la direction que prend ton travail.
Par exemple, l'autocompaction se déclenche après une longue session de débogage et résume l'investigation. Ton message suivant est « maintenant corrige cet autre avertissement qu'on a vu dans bar.ts ». Mais comme la session était centrée sur le débogage, l'autre avertissement a peut-être été retiré du résumé.
C'est particulièrement délicat, car à cause du context rot, le modèle est à son point le moins intelligent au moment de compacter. Avec un million de contexte, tu as plus de temps pour /compact de façon proactive avec une description de ce que tu veux faire.
Sous-agents & fenêtres de contexte neuves
Les sous-agents sont une forme de gestion du contexte, utiles quand tu sais à l'avance qu'un bloc de travail produira beaucoup de sortie intermédiaire dont tu n'auras plus besoin.
Quand Claude crée un sous-agent via l'outil Agent, ce sous-agent obtient sa propre fenêtre de contexte neuve. Il peut faire autant de travail que nécessaire, puis synthétiser ses résultats pour que seul le rapport final revienne au parent.
Le test mental : aurai-je encore besoin de cette sortie d'outil, ou seulement de la conclusion ?
Le bruit d'exploration est nettoyé (garbage-collected) à la sortie du sous-agent — 20 lectures de fichiers, 12 greps, 3 impasses — seul le rapport final revient au contexte parent.
Bien que Claude Code appelle automatiquement des sous-agents, tu voudras peut-être le lui demander explicitement. Par exemple :
- « Crée un sous-agent pour vérifier le résultat de ce travail selon le fichier de spec suivant »
- « Crée un sous-agent pour parcourir cet autre codebase et résumer comment il a implémenté le flux d'auth, puis implémente-le toi-même de la même façon »
- « Crée un sous-agent pour écrire la doc de cette fonctionnalité à partir de mes changements git »
Synthèse
Quand Claude a terminé un tour et que tu t'apprêtes à envoyer un nouveau message, tu es à un point de décision. Avec le temps, Claude gérera cela tout seul, mais pour l'instant c'est l'un des moyens dont tu disposes pour guider la sortie de Claude.
| Situation | Recours | Pourquoi |
|---|---|---|
| Même tâche, le contexte est encore pertinent | Continuer | Tout dans la fenêtre est encore porteur — ne paie pas pour le reconstruire |
| Claude a pris une mauvaise voie | Rewind (double-Échap) | Garde les lectures de fichiers utiles, jette la tentative ratée, re-prompte avec ce que tu as appris |
| En cours de tâche mais session encombrée de débogage/exploration périmés | /compact <indice> | Peu d'effort ; Claude décide de ce qui comptait. Oriente-le avec un indice si besoin |
| Démarrage d'une tâche véritablement nouvelle | /clear | Zéro rot ; tu contrôles exactement ce qui est reporté |
| L'étape suivante générera beaucoup de sortie dont tu ne veux que la conclusion | Sous-agent | Le bruit d'outil intermédiaire reste dans le contexte de l'enfant ; seul le résultat revient |
