Sommaire

Le /compact de Claude Code n'est pas une commande qu'on déclenche au chronomètre. Le moment où il faut appuyer, c'est une rupture dans le travail — une tâche terminée, la suivante sur le point de commencer. La documentation officielle le dit en toutes lettres : lancez /compact à une frontière naturelle du travail, par exemple entre deux tâches, plutôt que d'attendre que la compaction automatique se déclenche au milieu d'une tâche (documentation Claude Code, « Prompt caching »).

Des règles du type « appuyer toutes les 30 minutes » ou « appuyer dès que le contexte dépasse 70 % » visent la mauvaise cible. La suite de cet article explique pourquoi, mais la version courte tient en une phrase : le coût et la perte d'une compaction se décident non pas au moment où vous avez appuyé, mais à ce que vous avez jeté et à la chaleur du cache.

📌 D'où viennent ces informations : chaque spécification, numéro de version et nom de réglage cité ci-dessous a été vérifié le 8 août 2026 dans la documentation Claude Code et les notes de version (la plus récente à cette date : v2.1.226, 8 août 2026). Claude Code évolue vite et le domaine de la compaction a gagné des comportements jusque dans les dernières versions (/autocompact exige la v2.1.221 ou une version ultérieure). Vérifiez votre propre build avec claude --version.

1. La réponse courte — on appuie à une frontière, pas au chronomètre

Commençons par le tableau de décision. Il existe pour vous permettre de trancher selon la situation plutôt que selon l'horloge.

✅ Quand appuyer

Vous venez de terminer une tâche et vous êtes sur le point d'en commencer une longue. Peu importe qu'il vous reste du contexte disponible. L'objectif est d'avancer l'exécution automatique à un instant que vous choisissez, pour que rien ne vous interrompe en pleine tâche.

🟡 Quand /clear vaut mieux

Le travail suivant n'a rien à voir avec le précédent. Si vous n'avez même pas besoin du résumé, il n'y a aucune raison d'en payer la production. La documentation le formule sans détour : si vous voulez repartir de zéro plutôt que continuer, /clear est gratuit.

🔵 Quand /rewind vaut mieux

Vous voulez jeter toute la direction que vous avez prise. Le retour en arrière tronque jusqu'à un point déjà mis en cache, il revient donc moins cher qu'une compaction, laquelle doit fabriquer un préfixe entièrement neuf.

❌ Quand ne pas appuyer

En plein milieu d'une tâche. Des détails dont vous alliez encore vous servir sont écrasés dans un résumé. Chaque compaction « au cas où » vous achète le travail de relire les mêmes fichiers juste après.

Une seule question sépare ces quatre cas. Allez-vous encore avoir besoin de ce que vous vous apprêtez à jeter ? Pour reprendre la formulation de la documentation, la compaction est avantageuse lorsque le contexte que vous abandonnez n'est réellement plus nécessaire. Une exécution périodique est une manière de refuser ce jugement : parfois elle tombe juste, parfois non — et les fois où elle se trompe coûtent plus cher que les fois où elle tombe juste.

2. La compaction se joue en trois étages — ce que dit vraiment la documentation

Avant de se demander s'il faut appuyer soi-même, il faut connaître la mécanique qui tourne que vous appuyiez ou non. Quand le contexte commence à se remplir, Claude Code ne saute pas directement au résumé de la conversation. Voici comment la documentation le décrit.

« Claude Code gère le contexte automatiquement à mesure que vous approchez de la limite : il abandonne d'abord les anciennes sorties d'outils, puis résume la conversation si nécessaire. Vos demandes et les extraits de code importants sont conservés, mais les instructions détaillées données au début de la conversation peuvent être perdues. Placez les règles permanentes dans CLAUDE.md plutôt que de vous appuyer sur l'historique de la conversation. » (How Claude Code works)

Il y a donc des étages : (1) les anciennes sorties d'outils sont abandonnées, (2) la conversation est résumée automatiquement, (3) vous appuyez sur /compact.

1. Abandon des sorties d'outils

La conversation reste intacte et seuls les anciens résultats d'outils tombent. Vous ne faites rien. Cet étage travaille avant même qu'on arrive au résumé.

2. Compaction automatique

Quand l'étage 1 ne suffit pas, la conversation elle-même est remplacée par un résumé. C'est exactement le même traitement qu'un /compact manuel ; la seule différence tient au moment où il tourne.

3. /compact manuel

Son unique véritable rôle est d'avancer l'étage 2 à un instant qui vous arrange. À quoi s'ajoute une chose : vous pouvez lui dire quoi garder — l'autre différence avec l'étage 2.

C'est là que se trouve le cœur de la réponse. Un /compact manuel avance quelque chose qui serait arrivé de toute façon. Ce n'est pas un levier qui économise du contexte supplémentaire à mesure qu'on tire dessus. Il vaut la peine d'appuyer uniquement quand choisir soi-même le moment a de la valeur.

⚠️ Une remarque de vocabulaire. Plusieurs articles appellent l'étage 1 « micro-compaction », mais au 8 août 2026, la documentation officielle n'emploie pas ce nom. Ce qu'elle donne, c'est une description du comportement — les anciennes sorties d'outils sont abandonnées en premier. Si vous cherchez le terme et ne trouvez rien d'officiel, voilà pourquoi.

3. Ce qui survit et ce qui disparaît

Ce qui arrive à vos règles pendant une compaction dépend entièrement de la manière dont elles ont été chargées. La documentation publie une liste mécanisme par mécanisme ; la voici, mise en ordre.

Mécanisme Après la compaction Ce que cela signifie en pratique
System prompt et style de sortie Inchangés Ils ne font pas partie de l'historique de la conversation
CLAUDE.md à la racine du projet et règles sans portée Réinjectés depuis le disque L'endroit le plus sûr où poser vos règles. C'est aussi là que vos modifications finissent par prendre effet (voir la section 8)
Mémoire automatique Réinjectée depuis le disque Elle est conçue pour persister d'une session à l'autre ; survivre à une compaction est le minimum
Règles portant paths: Perdues (jusqu'à ce qu'un fichier correspondant soit relu) Pour les garder, retirez la clé paths: ou déplacez la règle dans le CLAUDE.md racine
CLAUDE.md imbriqué dans un sous-répertoire Perdu (jusqu'à ce qu'un fichier de ce répertoire soit relu) Comme ci-dessus, et c'est l'oubli le plus facile à ne pas voir
Corps des skills que vous avez invoqués Réinjectés, mais plafonnés 5 000 tokens par skill et 25 000 au total, les plus anciens étant abandonnés en premier
Hooks Non concernés Ils s'exécutent comme du code, pas comme du contexte

Trois conclusions pratiques découlent de ce tableau.

Premièrement, si vous vous attendez à être compacté, mettez les règles que vous ne pouvez pas vous permettre de perdre dans le CLAUDE.md à la racine du projet. C'est le point que la documentation répète sans se lasser. Les règles avec paths: et les CLAUDE.md imbriqués achètent du confort au prix d'une disparition à chaque compaction — et rien à l'écran ne vous prévient qu'ils sont partis.

Deuxièmement, c'est le haut d'un fichier de skill qui compte. La troncature à la réinjection conserve le début du fichier : les instructions importantes d'un SKILL.md ont donc leur place tout en haut. À cela s'ajoute que, selon les notes de la documentation sur le contexte, la liste des skills chargée au démarrage de la session n'est pas réinjectée après un /compact ; seuls les skills que vous avez réellement invoqués sont conservés.

Troisièmement, rien n'annonce ce qui a été perdu. C'est exactement pour cela que le principe tient : si perdre quelque chose vous ferait mal, gardez-le dans un fichier plutôt que dans la conversation.

4. Le coût ne dépend pas de la taille de votre contexte

Supposer qu'« un contexte plus gros rend /compact plus cher » est naturel, et à moitié vrai seulement. Ce qui fait réellement le prix, c'est la chaleur du cache de prompt. Voici l'explication de la documentation.

« Pour produire le résumé, Claude Code envoie une requête distincte avec le même system prompt, les mêmes outils et le même historique, plus une instruction de résumé à la fin. Tant que le cache est chaud, cette requête lit votre préfixe depuis le cache, ce qui coûte bien moins cher que la taille du contexte ne le laisserait croire, et l'essentiel du temps part dans la génération du résumé. [...] Après une pause plus longue que la durée de vie du cache, il ne reste plus rien à lire en cache : la requête de résumé retraite donc l'historique entier comme entrée non mise en cache. C'est pour cela que /compact atteint son coût maximal quand vous reprenez une ancienne session. » (Prompt caching)

Ce seul paragraphe constitue l'argument le plus fort contre une compaction programmée.

Appuyé en pleine session (cache chaud)

Le préfixe est lu depuis le cache. Ce que vous ressentez, c'est seulement le temps d'écriture du résumé. Une compaction ici ne coûte pas cher.

Appuyé après une pause (cache froid)

L'historique entier est retraité avant que quoi que ce soit soit résumé. Le moment le plus cher pour la même commande. « Je vais faire un peu de rangement en arrivant le matin » peut être le pire choix possible.

Le tour juste après l'appui

Le cache est reconstruit à partir d'un court résumé : cette partie n'est pas lourde. L'impression que « tout ralentit après une compaction » vient le plus souvent des deux cas ci-dessus, pas d'ici.

La durée de vie du cache dépend de votre mode d'authentification. Sur un abonnement Claude, un TTL d'une heure est demandé automatiquement ; via une clé d'API ou un fournisseur cloud, la valeur par défaut est de cinq minutes (ENABLE_PROMPT_CACHING_1H=1 la porte à une heure). Autrement dit, « de retour du déjeuner, je lance d'abord /compact » est presque à coup sûr une exécution à froid avec une clé d'API.

Le fait que /compact soit lui-même une grosse requête est également souligné dans la documentation sur les coûts : « /compact lit la conversation qu'il résume, donc compacter un gros contexte est en soi une grosse requête. Si vous voulez repartir de zéro plutôt que continuer, /clear est gratuit. » (Manage costs effectively). Vu aussi sous l'angle de l'économie de tokens, les moments où /clear l'emporte sur un /compact appuyé par habitude ne manquent pas.

5. /compact, /clear, /rewind et /recap — lequel choisir

/compact n'est pas la seule manière d'alléger votre contexte. Confondez des commandes qui existent pour des raisons différentes et vous finirez par payer la plus chère.

Commande Historique de la conversation Cache Quand la choisir
/compact [instruction] Remplacé par un résumé La couche conversation est invalidée Vous continuez, mais les détails de l'historique ne vous servent plus
/clear [nom] Vidé Reconstruit (aucun coût de résumé) Le travail suivant est sans rapport. Donnez-lui un nom et /resume vous y ramène
/rewind Tronqué jusqu'à un point antérieur Touche l'ancien cache Vous voulez faire disparaître toute la direction prise. Le code peut revenir avec
/recap Intact (il ne fait qu'afficher un résumé) Conservé tel quel Vous voulez seulement lire « où nous en sommes »
/context [all] Intact Conservé Mesurez avant d'appuyer sur quoi que ce soit. Une vue en couleurs de ce qui prend de la place

/recap mérite qu'on s'en souvienne. Beaucoup de gens appuient sur /compact parce que « cette conversation devient longue, j'aimerais un résumé » — et pour cet objectif, il n'y a aucune raison de détruire l'historique. D'après la documentation, /recap se contente d'ajouter un résumé en sortie de commande : le préfixe mis en cache reste donc intact.

La nature de /rewind compte tout autant. La documentation explique que le retour en arrière vous ramène au contenu exact qui avait été mis en cache à ce moment-là, si bien que la requête suivante touche l'ancien cache. Quand vous êtes parti dans la mauvaise direction, la bonne réponse est /rewind, pas /compact — la compaction fabrique un nouveau préfixe, tandis que le retour en arrière se contente de rejoindre un préfixe qui existe déjà. Les points de contrôle et le retour en arrière ont leur propre article.

6. Vous pouvez déplacer vous-même la fenêtre de compaction automatique

Avant de vous torturer sur la question d'appuyer à la main, sachez que vous pouvez déplacer le point où l'exécution automatique se déclenche. Depuis la v2.1.221, la commande /autocompact permet d'indiquer à quel niveau de remplissage du contexte la compaction automatique doit intervenir.

Régler la fenêtre à 500K tokens (enregistré dans les réglages utilisateur, donc valable aussi pour les sessions suivantes)

/autocompact 500k

Revenir à la valeur par défaut adaptée au modèle

/autocompact auto

La plage acceptée va de 100K à 1M tokens. Vous pouvez écrire un nombre brut comme 200000, une valeur suffixée comme 500k ou 1M, ou un nombre nu entre 100 et 1000 comme 200 (lu en milliers). Le réglage peut venir de quatre endroits, et l'ordre de priorité est fixe.

1. Variable d'environnement (priorité maximale)

CLAUDE_CODE_AUTO_COMPACT_WINDOW. Tant qu'elle est définie, elle l'emporte sur la commande, le drapeau et le fichier de réglages

2. Drapeau de lancement

claude --autocompact 500k. Vaut pour ce lancement uniquement et ne modifie pas vos réglages enregistrés

3. La commande

/autocompact. Écrit dans autoCompactWindow au sein de vos réglages utilisateur

4. Fichier de réglages

autoCompactWindow. Si votre organisation impose un réglage géré au-dessus, c'est lui qui gagne

⚠️ C'est la variable d'environnement qui a un format différent. La documentation précise explicitement que CLAUDE_CODE_AUTO_COMPACT_WINDOW n'accepte qu'un entier brut, et qu'une valeur comme 500k est lue comme 500 puis ramenée au minimum de 100K. Écrivez-la comme vous écrivez la commande et vous avez demandé le millième de ce que vous vouliez, avant d'être remonté de force vers des compactions bien plus fréquentes.

Il y a un second avertissement au même endroit. Le used_percentage de la ligne d'état se mesure toujours par rapport à la fenêtre de contexte complète du modèle : dès que vous définissez cette variable, ce pourcentage ne vous dit plus quand la compaction se déclenchera. C'est précisément là qu'une méthode du type « je surveille le pourcentage et j'appuie à la main » s'effondre.

La valeur par défaut, quand vous ne réglez aucune fenêtre, est documentée elle aussi. Sans configuration, la compaction se produit quand la limite de contexte du modèle est atteinte, avec des exceptions : les sessions cloud compactent tôt à l'approche de la limite, Sonnet 4.6 et Opus 4.6 sans contexte étendu compactent à la frontière des 200K, Opus 4.8 et Opus 5 tournant avec 200K de contexte sur Amazon Bedrock, sur l'Agent Platform de Google Cloud ou sur Microsoft Foundry se comportent de la même façon, et Sonnet 5 se déclenche au seuil par défaut de ce modèle.

Vous pouvez aussi désactiver complètement la compaction automatique, via le réglage autoCompactEnabled (par défaut true, affiché « Auto-compact » dans /config) ou la variable d'environnement DISABLE_AUTO_COMPACT. Ce n'est pas recommandé. La désactiver ne réduit rien : le contexte va simplement heurter le plafond et vous échangez la compaction contre l'erreur « Prompt is too long ». La compaction automatique est une fonctionnalité qui vous protège, pas une qui vous gêne.

7. Trois situations où une exécution périodique se retourne contre vous

Une fois ces détails en main, on voit clairement où « il suffit d'appuyer régulièrement » fait perdre de l'argent.

1. Appuyer en pleine tâche

Des détails dont vous alliez encore vous servir sont écrasés dans le résumé. En plus de cela, les règles paths: et les CLAUDE.md imbriqués tombent, si bien que le travail qui suit se met discrètement à manquer vos règles. C'est le genre de dégradation dont la cause est difficile à voir.

2. Appuyer en premier après une pause

Le cache a expiré, donc l'historique entier est retraité avant d'être résumé. C'est le moment le plus cher pour le même /compact — et la bonne intention « je range un peu avant de commencer » y fonce droit.

3. Appuyer dans une session courte

Sans historique digne d'être résumé, vous récoltez seulement Not enough messages to compact. Cela arrive aussi quand un seul collage énorme a rempli le contexte — et là, la bonne réponse est /clear, pas un résumé.

Retournez la chose et vous obtenez la règle : la compaction manuelle qui rapporte le plus est celle qu'on lance juste avant d'entamer un long travail. Appuyer à cet endroit réduit le risque qu'une compaction automatique vous interrompe à mi-parcours. La valeur est dans le moment, pas dans le nombre.

8. En pratique — ce que vous faites avant d'appuyer compte davantage

Ce qui change vraiment les choses avec /compact, ce n'est pas la façon d'appuyer, mais ce que vous avez confié à des fichiers avant de le faire. Comme le montre le tableau de la section 3, le CLAUDE.md à la racine du projet et votre mémoire automatique sont réinjectés depuis le disque. Tout ce qui y est écrit survit à n'importe quel nombre de compactions.

Il y a une autre propriété qu'on oublie souvent. Modifier CLAUDE.md pendant une session ne prend pas effet sur le moment. La documentation le formule ainsi : « les modifications n'invalident pas le cache, mais elles ne prennent pas effet non plus. Le nouveau contenu est chargé au prochain /clear, /compact ou redémarrage. » Lu à l'envers, cela signifie que /compact est aussi l'opération qui rend enfin applicables les règles décidées en cours de session.

Une liste de contrôle avant d'appuyer

  • Avez-vous écrit dans un fichier les règles et les décisions prises pendant cette session ? (Tout ce qui n'existe que dans la conversation se dilue dans le résumé)
  • Avez-vous indiqué quoi garder ? Vous pouvez transmettre un point de focalisation, comme dans /compact keep the auth fix plan and the test results
  • Le travail suivant est-il vraiment une continuation ? S'il est sans rapport, /clear revient moins cher
  • Le cache est-il chaud en ce moment ? (Évitez l'instant qui suit une longue pause)
  • En cas de doute, lancez /context et mesurez ce qui prend réellement de la place

Et voici le point que les partisans de la compaction manuelle manquent le plus souvent. L'habitude qui consiste à « appuyer soi-même, préventivement, parce qu'on a peur d'être compacté à son insu et de perdre le fil » est assez répandue. Mais la documentation écrit ceci juste après avoir expliqué la compaction automatique : pour contrôler ce qui est conservé à travers une compaction, ajoutez une section « Compact Instructions » à votre CLAUDE.md, ou lancez /compact avec un point de focalisation (How Claude Code works).

Autrement dit, préciser un point de focalisation n'est pas un privilège réservé à celui qui appuie lui-même. Mettez-le dans CLAUDE.md et il s'applique aussi à la compaction qui tourne pendant que vous êtes loin de votre bureau. Si le but de votre routine manuelle préventive est de décider comment le contexte sera taillé, c'est cette version-là qui fonctionne vraiment — la routine manuelle ne vous aide jamais que sous vos yeux.

L'écrire n'a rien de difficile. L'exemple donné par la documentation ressemble à ceci.

Instructions de compaction par défaut placées dans CLAUDE.md (exemple tiré de la documentation officielle)

# Compact instructions

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

Pour ce que cela vaut, voici comment ce site s'y prend. Le CLAUDE.md du dépôt de ce blog porte deux règles depuis longtemps : « proposer /compact à l'utilisateur dès que le contexte devient long » et « avant de lancer /compact, enregistrer en mémoire tout ce qui doit devenir une règle — retours, décisions d'approche ». Cet article a précisément été écrit dans une session qui a traversé une compaction. À l'usage, ce n'est pas la première règle qui paie, c'est la seconde. Faire passer dans des fichiers, en amont, ce qui mérite d'être gardé fonctionne bien plus sûrement que s'acharner à modeler le résumé.

Une dernière chose mérite d'être ajoutée : /compact n'est pas la seule manière de réduire le contexte. Les recommandations officielles sur les coûts conseillent de déléguer à des subagents les travaux à sortie volumineuse — lancer des tests, récupérer de la documentation, traiter des journaux. Un subagent dispose de sa propre fenêtre de contexte et ne renvoie qu'un résumé : le contexte principal ne gonfle donc jamais. S'arranger pour ne pas avoir besoin de compaction vaut mieux que bien compacter.

9. Deux messages sur lesquels vous pouvez tomber

Deux messages que vous pouvez rencontrer en pratique ne se comprennent pas d'eux-mêmes.

Message Ce qu'il signifie Que faire
Not enough messages to compact. Il n'y a pas de conversation digne d'être résumée. Cela arrive aussi quand un seul collage énorme a rempli le contexte Repartir de zéro avec /clear
Autocompact is thrashing: the context refilled to the limit... La compaction a réussi, mais un fichier ou une sortie d'outil énorme a rempli à nouveau le contexte juste après, plusieurs fois de suite. Le système s'est arrêté pour éviter une boucle sans fin Les quatre étapes à droite (l'ordre recommandé par la documentation)

La procédure de récupération du second cas est détaillée dans l'ordre par la documentation. (1) Lisez les fichiers énormes par morceaux, par plage de lignes ou par fonction. (2) Compactez avec une instruction nommant la sortie dont vous voulez vous débarrasser (par exemple /compact keep only the plan and the diff). (3) Déplacez ce travail vers un subagent pour qu'il tourne dans une fenêtre de contexte séparée. (4) Si la conversation précédente ne sert plus, /clear. Le point révélateur, c'est que l'étape 1 vienne en premier : la documentation dit en substance que ce n'est pas un problème de compaction, c'est un problème de lecture.

Résumé

Vous n'avez pas besoin de lancer /compact manuellement à intervalles réguliers. La compaction automatique tourne que vous le fassiez ou non, et c'est le même traitement. Appuyer soi-même vous achète exactement deux choses — choisir le moment et préciser ce qu'il faut garder — et ces deux choses paient à un seul endroit : entre deux tâches.

Côté coût, une exécution périodique est perdante elle aussi. Le prix d'une compaction se fixe selon la chaleur du cache : le « je range un peu avant de commencer » d'après-pause en est donc la version la plus chère. Si repartir de zéro suffit, /clear est gratuit ; si vous changez de direction, /rewind revient moins cher parce qu'il rejoint un cache existant ; et si vous voulez seulement lire un résumé, /recap laisse l'historique tranquille. Choisir la bonne des quatre vaut mieux qu'appuyer plus souvent sur la même.

La conclusion la plus utile, pourtant, se situe en dehors de la question de la manière d'appuyer. Ce que vous ne pouvez pas vous permettre de perdre a sa place dans un fichier, pas dans la conversation. Le CLAUDE.md à la racine du projet et votre mémoire automatique sont réinjectés depuis le disque, tandis que les règles paths: et les CLAUDE.md imbriqués tombent en silence. Connaître cette asymétrie, c'est ce qui sépare une longue session qui tient d'une session qui se dégrade sans bruit.

FAQ

Q1. Alors, tous les combien de minutes faut-il appuyer sur /compact ?

Cela ne devrait pas se décider au temps. Le seul moment recommandé est juste après la fin d'une tâche et avant d'en commencer une longue. La documentation parle d'« une frontière naturelle du travail, par exemple entre deux tâches » et ne donne aucun seuil de temps ni de pourcentage.

Q2. Peut-on tout laisser à la compaction automatique ?

L'automatique et le manuel sont le même traitement ; seul le moment diffère. Le hic, c'est que l'automatique peut vous interrompre en pleine tâche. Appuyer une fois à la main avant une longue séquence de travail réduit le risque de cette interruption. Et vous pouvez donner des instructions à l'automatique aussi — écrivez-les dans CLAUDE.md sous un titre # Compact instructions et elles s'appliqueront à une compaction qui tourne pendant que vous êtes loin de votre bureau (voir la section 8).

Q2-2. Depuis qu'il a compacté tout seul, mes instructions semblent ne plus passer

Vous ne l'imaginez pas. La documentation indique que « les instructions détaillées données au début de la conversation peuvent être perdues ». À cela s'ajoute que les règles paths: et les CLAUDE.md imbriqués tombent jusqu'à ce que le fichier correspondant soit relu, et que les skills invoqués sont abandonnés du plus ancien au plus récent dès qu'ils dépassent 25 000 tokens au total. Il s'agit moins d'un contenu qui disparaît que de règles suivies qui s'amenuisent en silence : le travail continue, mais la précision baisse. Trois parades : (1) déplacez vers le CLAUDE.md racine les règles que vous voulez rendre permanentes, elles y sont réinjectées ; (2) nommez ce qu'il faut garder avec # Compact instructions ; (3) utilisez /autocompact pour déclencher plus tôt, afin que la compaction ne se produise pas au ras du plafond.

Q3. Faut-il utiliser /compact ou /clear ?

/compact si le travail suivant prolonge le précédent, /clear sinon. La documentation sur les coûts dit sans détour que « si vous voulez repartir de zéro plutôt que continuer, /clear est gratuit ». Passez un nom à /clear et vous pourrez revenir à la session depuis la liste de /resume : il n'y a donc rien à craindre de perdre.

Q4. La compaction efface-t-elle mes règles CLAUDE.md ?

Le CLAUDE.md à la racine du projet n'est pas effacé — il est réinjecté depuis le disque. Ce qui part, ce sont les règles portant un front matter paths: et les CLAUDE.md imbriqués dans des sous-répertoires ; ils ne reviennent pas tant qu'un fichier correspondant n'est pas relu. Pour les règles que vous voulez rendre permanentes, retirez la clé paths: ou déplacez-les dans le CLAUDE.md racine.

Q5. Peut-on désactiver la compaction automatique ?

Oui (le réglage autoCompactEnabled à false, « Auto-compact » dans /config, ou la variable d'environnement DISABLE_AUTO_COMPACT). Ce n'est pas recommandé. La désactiver ne réduit pas votre contexte : vous heurtez simplement le plafond et vous obtenez une erreur. Si ce que vous voulez, c'est qu'elle tourne plus tôt, la bonne manœuvre n'est pas de la couper mais de resserrer la fenêtre avec /autocompact.

Q6. Combien de tokens /compact consomme-t-il ?

Cela varie énormément selon la chaleur du cache. Appuyez en pleine session et le préfixe est lu depuis le cache, pour un coût qui, selon les mots de la documentation, reste bien inférieur à ce que la taille du contexte laisserait croire. Appuyez après une pause plus longue que la durée de vie du cache et l'historique entier est retraité sans cache, ce qui rend la même commande aussi chère qu'elle puisse l'être. La durée de vie du cache est d'une heure sur un abonnement et de cinq minutes par défaut via une clé d'API ou un fournisseur cloud.

Q7. Peut-on préciser ce qui doit être gardé ?

Oui. Écrivez une instruction à la suite de /compact et le résumé sera produit avec ce point de focalisation (par exemple /compact keep the auth fix plan and the test results). Si la même instruction convient à chaque fois, créez un titre # Compact instructions dans CLAUDE.md et elle s'appliquera par défaut.

Q8. Pourquoi les réponses semblent-elles lentes juste après une compaction ?

Le tour qui suit immédiatement une compaction n'est pas lourd. D'après la documentation, ce tour reconstruit le cache à partir d'un court résumé : ce n'est donc pas la partie lente. Ce que vous ressentez, c'est le plus souvent l'exécution de la compaction elle-même, pendant que le résumé se génère, ou un cas où vous avez appuyé avec le cache déjà froid.

Q9. Existe-t-il une fonctionnalité appelée « micro-compaction » ?

Le comportement existe — la documentation explique que les anciennes sorties d'outils sont abandonnées d'abord et que la conversation n'est résumée qu'en cas de besoin, ce qui affirme explicitement qu'il se passe quelque chose avant le résumé. Mais au 8 août 2026, la documentation officielle n'emploie pas le nom « micro-compaction ». Le terme vient d'articles tiers, pas d'Anthropic : traitez-le en conséquence.

Articles liés