Pourquoi votre agent de code ignore vos instructions
Votre fichier d’instructions dit d’arrêter, mais l’agent continue. Apprenez à distinguer contexte absent, règle vague, conflit et oubli après compaction.
Pourquoi les agents de programmation ignorent vos instructions
Les agents de programmation ignorent vos instructions pour quatre raisons, et aucune ne tient au fait que vous auriez été trop poli. La règle n’a jamais été chargée dans la fenêtre de contexte. Elle était trop vague pour permettre de vérifier une action par rapport à celle-ci. Un autre élément du contexte la contredisait, généralement le code que l’agent venait de lire. Ou bien la règle est toujours chargée, mais elle se trouve très loin avant le tour actuel, et l’agent travaille à partir des éléments qui se trouvent à proximité.
Chaque cause a sa propre correction. La première étape consiste donc à les distinguer. Les majuscules et le mot IMPORTANT ne permettent pas d’établir un diagnostic. Les mécanismes décrits ci-dessous prennent Claude Code comme exemple concret, car son comportement de chargement et de compaction est documenté en détail en octobre 2026. Les autres outils diffèrent sur certains détails, mais leur fonctionnement général est similaire.
Commençons par deux termes. La fenêtre de contexte est le bloc de texte que le modèle voit lors d’un tour donné : le prompt système, vos fichiers d’instructions, la conversation et chaque fichier que l’agent a lu. Le harness est le programme qui entoure le modèle, celui qui lit les fichiers sur le disque et assemble ce bloc. Presque toutes les plaintes formulées dans cet article concernent en réalité le harness, et non le modèle.
Votre fichier d’instructions est un message, pas un paramètre
Un fichier d’instructions n’est pas une configuration. Rien, dans le runtime, ne lit CLAUDE.md et ne l’applique. Le harness lit le fichier sur le disque, puis colle son contenu dans la conversation. Dans Claude Code, ce contenu est transmis sous la forme d’un message utilisateur placé après le system prompt. Le modèle voit donc vos règles de la même manière que le reste de votre texte.
Cela entraîne une conséquence gênante. Vos règles sont en concurrence avec tous les autres textes présents dans la fenêtre, sur un pied d’égalité. Une règle est une affirmation. Le fichier que l’agent vient d’ouvrir est un élément de preuve. Lorsque les deux sont en désaccord, les éléments de preuve l’emportent souvent. Aucune erreur n’est alors signalée, car, du point de vue du modèle, rien ne s’est mal passé.
La documentation officielle l’indique clairement : les fichiers d’instructions sont traités comme du contexte, et non comme une configuration appliquée. Pour bloquer une action quelle que soit la décision du modèle, vous avez besoin d’un hook, pas d’une phrase. Retenez cette distinction. La plupart des corrections présentées à la fin de cet article consistent à appliquer cette distinction à un cas précis.
Quels fichiers d’instructions sont chargés, et à quel moment
Claude Code remonte l’arborescence depuis le répertoire dans lequel vous l’avez lancé. Tous les fichiers CLAUDE.md et CLAUDE.local.md situés entre la racine du système de fichiers et votre répertoire de travail sont entièrement chargés au démarrage. Ils sont concaténés dans cet ordre. Le fichier le plus proche du répertoire depuis lequel vous avez lancé Claude Code est donc lu en dernier. Dans un même répertoire, le fichier .local est ajouté après le fichier principal.
Les fichiers situés dans les sous-répertoires en dessous de votre répertoire de travail se comportent différemment. Ils ne sont pas chargés au démarrage. Ils le sont lorsque l’agent lit un fichier dans ce répertoire. Il en va de même pour les règles limitées à un chemin dans .claude/rules/ qui comportent un champ frontmatter paths: : elles sont ajoutées au contexte lorsqu’un fichier correspondant est lu, et non à chaque tour. Depuis la version v2.1.309, les fichiers chargés de cette manière sont également soumis à une limite de taille par fichier (40,000 caractères avec une fenêtre de contexte de 200K). L’agent ne reçoit donc que le début d’un fichier plus long, et les règles situées vers la fin d’un fichier imbriqué volumineux peuvent ne jamais parvenir au contexte.
Cette différence explique une grande partie des échecs signalés. Vous placez une règle dans packages/api/CLAUDE.md, vous posez une question sur l’API et l’agent répond sans jamais ouvrir de fichier sous packages/api/. La règle n’a pas été ignorée. Elle n’a jamais été présente. Si votre dépôt répartit les consignes dans des fichiers d’instructions par package dans un monorepo, c’est la première chose à vérifier, à chaque fois.
Un autre piège de chargement concerne les dépôts qui ont standardisé leurs instructions sur AGENTS.md. Depuis la version v2.1.277, Claude Code lit AGENTS.md comme instructions du projet par défaut, mais uniquement s’il n’existe aucun fichier CLAUDE.md, .claude/CLAUDE.md ou CLAUDE.local.md dans votre répertoire de travail ou dans un répertoire parent (votre fichier personnel ~/.claude/CLAUDE.md ne compte pas). Ajoutez l’un de ces fichiers, même un CLAUDE.local.md destiné à vos notes personnelles, et Claude Code lit à la place vos fichiers CLAUDE.md et ignore entièrement AGENTS.md. Pour charger les deux, définissez Project instructions sur claude-md-and-agents-md dans /config. Avec les versions antérieures à v2.1.277, ou si vous souhaitez conserver un CLAUDE.md, utilisez un CLAUDE.md dont la première ligne est @AGENTS.md. Cette ligne importe le fichier au démarrage ; vous pouvez ajouter dessous des notes spécifiques à Claude. Un lien symbolique fonctionne également si vous n’avez rien d’autre à ajouter. Déterminer ce qui doit figurer dans ce fichier est une question distincte, traitée dans la séparation des instructions de l’agent et de la documentation destinée aux humains.
Confirmez que le fichier est chargé avant de le réécrire
Ne modifiez pas le texte avant d’avoir vérifié que l’agent peut voir le fichier. Deux contrôles sont nécessaires. Commencez par le plus simple.
Exécutez /context dans la session. Cette commande affiche la fenêtre actuelle par catégorie. La liste Memory files contient le nom de chaque fichier d’instructions chargé au démarrage. Si un fichier n’apparaît pas dans cette liste, il n’a pas été chargé au démarrage. Rien de ce que vous écrivez dedans ne peut donc être pris en compte tant qu’un mécanisme ne le charge pas. Un fichier imbriqué dans un sous-répertoire n’apparaît jamais dans cette liste, car il est chargé à la demande. Lorsqu’il est chargé, une ligne Loaded avec son chemin apparaît dans le terminal. /memory répertorie les emplacements des fichiers et les ouvre pour modification, y compris ceux qui n’existent pas encore.
Pour obtenir une confirmation plus détaillée, journalisez les chargements. L’événement hook InstructionsLoaded se déclenche chaque fois qu’un CLAUDE.md ou qu’un fichier de règles est ajouté au contexte. Son matcher indique la raison du chargement : session_start, nested_traversal, path_glob_match, include ou compact. Ajoutez ceci dans .claude/settings.json :
{
"hooks": {
"InstructionsLoaded": [
{
"matcher": "nested_traversal",
"hooks": [
{
"type": "command",
"command": "cat >> /tmp/instructions-loaded.log"
}
]
}
]
}
}Le hook reçoit ses données au format JSON sur l’entrée standard. cat ajoute donc l’enregistrement complet. Surveillez ce fichier avec tail -f /tmp/instructions-loaded.log pendant vos vérifications. Le code de sortie de cet événement est ignoré. Le hook peut donc uniquement observer, jamais bloquer. Si votre fichier imbriqué n’apparaît jamais dans ce journal au cours d’une session où vous vous attendiez à ce qu’il soit chargé, arrêtez de reformuler son contenu. Le problème vient de son emplacement. Une exception existe : un AGENTS.md lu directement par Claude Code ne déclenche pas cet événement. Recherchez plutôt son chemin dans /memory. Un AGENTS.md importé depuis un CLAUDE.md déclenche l’événement normalement.
Ce qu’une longue session fait à vos règles
Deux effets distincts s’appliquent ici et nécessitent des réponses différentes.
Distance. Tant qu’une compaction n’a pas eu lieu, une règle formulée au tour 1 se trouve encore dans la fenêtre au tour 90. Elle est alors en concurrence avec 90 tours de texte plus récent et plus spécifique à ce que vous faites actuellement. Après une compaction, une règle que vous avez uniquement saisie dans le chat peut ne plus se trouver du tout dans la fenêtre. La documentation de Claude Code avertit que les instructions du début de la conversation peuvent être perdues. C’est le deuxième effet décrit ci-dessous. Vous ne pouvez pas supprimer l’effet de la distance par la configuration, mais vous pouvez le mesurer. Exécutez la même tâche dans une nouvelle session. Si la règle est respectée dans cette session et cesse de l’être après un long échange, la distance ou la compaction est probablement en cause.
Compaction. Lorsque la fenêtre est pleine, le harness résume la conversation jusque-là, puis continue à partir de ce résumé. Ce qui subsiste correspond à ce que le système de résumé a jugé important. Ce n’est pas nécessairement ce que vous considérez comme important. Claude Code documente le comportement de chaque mécanisme, et les différences sont importantes. Le fichier à la racine du projet CLAUDE.md et les règles sans portée sont réinjectés depuis le disque après une compaction. La mémoire automatique est réinjectée depuis le disque. Les règles dont le frontmatter contient paths: sont perdues jusqu’à la nouvelle lecture d’un fichier correspondant. Les fichiers CLAUDE.md imbriqués dans des sous-répertoires sont perdus jusqu’à la lecture d’un fichier situé dans ce sous-répertoire.
Classez vos instructions selon ce tableau et l’ordre de fragilité apparaît clairement. Une règle que vous avez uniquement saisie dans le chat est l’élément le plus fragile de la session. Elle ne persiste que si le résumé l’a conservée. Une règle dans packages/api/CLAUDE.md vient ensuite, car elle a été chargée une fois, supprimée par le résumé, puis ne revient qu’à la prochaine lecture dans ce répertoire. Une règle dans le fichier à la racine du projet est la plus durable, car elle est relue depuis le disque à chaque fois.
Ainsi, si une instruction doit rester valable pendant toute une session, placez-la dans le fichier à la racine du projet, sans frontmatter paths:. Pour le reste, choisissez volontairement le compromis approprié. Gérer ce qui reste dans la fenêtre de contexte présente /compact avec un argument de focus et /clear entre des tâches sans rapport, deux éléments qui modifient la fréquence à laquelle le système de résumé peut décider ce qu’il advient de vos règles.
Pourquoi le code environnant l’emporte sur la règle
C’est l’échec le plus souvent décrit et le moins souvent diagnostiqué. Votre fichier indique que l’accès à la base de données doit passer par la couche repository. L’agent écrit un handler qui appelle directement l’ORM (object relational mapper). Il n’a pas ignoré votre consigne pour des raisons de style. Les éléments concrets l’ont emporté.
Une règle décrit une préférence. Le code en démontre une. Lorsque l’agent ouvre trois fichiers du module qu’il va modifier et que les trois appellent directement l’ORM, le contexte contient d’un côté une phrase abstraite et, de l’autre, trois exemples concrets, récents et adaptés à la tâche. Reproduire le pattern local est généralement le bon comportement. C’est incorrect ici uniquement parce que vous savez quelque chose que le contexte ignore : ces fichiers sont du code legacy.
Indiquez-le donc dans la règle. Les règles qui mentionnent leur propre contre-évidence résistent mieux à l’utilisation dans un repository réel. Celles qui énoncent une simple préférence ne le font pas.
Tout nouvel accès à la base de données passe parapp/repositories/. Les fichiers sousapp/legacy/appellent encore directement l’ORM. Il s’agit d’ancien code, pas du pattern à suivre. Ne le copiez pas.
La deuxième phrase fait le travail. Elle indique à l’agent ce qu’il va trouver et comment l’interpréter, avant qu’il ne le trouve. La même correction s’applique à toute règle que votre repository contredit manifestement : un style de commit que votre historique ne suit pas, une organisation des tests ignorée par la moitié de votre suite, une convention d’import appliquée uniquement au nouveau code. Lorsque le code contredit le fichier, indiquez cette contradiction dans le fichier.
Une règle vague ne peut pas être vérifiée et ne peut donc pas être appliquée
« Écrivez du code propre. » « N’en faites pas trop. » « Restez simple. » « Soyez prudent avec les migrations. » Aucune de ces règles ne peut être vérifiée à partir d’une action précise, ni par l’agent ni par vous. Un agent qui reçoit une règle qu’il ne peut pas vérifier sur sa propre sortie devine, et vous évaluez cette supposition au ressenti.
Voici le test à appliquer à chaque ligne de votre fichier. Écrivez la commande shell qui se terminerait avec un code différent de zéro si la règle était enfreinte. Si vous ne pouvez pas écrire cette commande, la règle n’est pas vérifiable. Comparez ces paires :
- Non vérifiable : « Gardez les fonctions courtes. » Vérifiable : « Toute fonction de plus de 60 lignes doit être précédée d’un commentaire expliquant pourquoi. »
- Non vérifiable : « Testez vos modifications. » Vérifiable : « Exécutez
npm testet indiquez le nombre d’échecs avant de considérer la tâche comme terminée. » - Non vérifiable : « Gardez les fichiers organisés. » Vérifiable : « Les gestionnaires HTTP se trouvent dans
src/api/handlers/. Aucun autre élément ne doit se trouver dans ce répertoire. » - Non vérifiable : « Formatez correctement le code. » Vérifiable : « Utilisez une indentation de 2 espaces dans les fichiers
.ts. »
« N’en faites pas trop » est la règle à laquelle les utilisateurs renoncent en premier, car sa correction ne consiste pas à raccourcir la phrase, mais à la rendre plus longue : préciser ce que signifie concrètement la plus petite modification fonctionnelle donne à l’agent des critères auxquels il peut comparer son propre diff.
La taille pose le même problème sous une autre forme. Les recommandations de Claude Code ciblent moins de 200 lignes par fichier d’instructions et indiquent directement que les fichiers plus longs réduisent le respect des consignes. Un fichier de 700 lignes ne contient pas des instructions plus fermes. Il contient 700 affirmations qui risquent davantage de se contredire, et il est comptabilisé dans votre fenêtre à chaque tour, ce qui se reflète directement dans votre utilisation des tokens. Structurer le fichier afin que chaque règle figure sous un titre qu’un lecteur peut parcourir rapidement est traité dans la rédaction d’un fichier d’instructions que l’agent peut appliquer. Mieux encore, supprimez les parties qui décrivent au lieu de donner des instructions : une présentation des répertoires indiquant où se trouvent les gestionnaires et les modèles est une structure que l’agent peut consulter à la demande dans une carte analysée du dépôt au lieu de la conserver dans la fenêtre à chaque tour.
Comment diagnostiquer le problème en dix minutes
Exécutez ces étapes dans l’ordre. Passer directement à la dernière étape explique pourquoi on finit avec un long fichier rempli de règles formulées de manière impérative qui ne fonctionnent toujours pas.
- Vérifiez que le fichier a été chargé. Exécutez
/contextet consultez la liste Memory files, ou, pour un fichier imbriqué, recherchez sa ligneLoadeddans le terminal. Si le fichier n’y figure pas, corrigez son emplacement et arrêtez-vous là. Le reste de cette liste ne s’applique pas encore. - Reproduisez le problème dans une nouvelle session. Démarrez une nouvelle session et donnez la tâche la plus simple qui devrait déclencher la règle. Si la règle fonctionne ici mais échoue dans une longue session, le problème vient probablement de la distance ou de la compaction. Si elle échoue aussi ici, le problème vient de la règle elle-même.
- Supprimez la concurrence. Demandez la même modification dans un répertoire dont le code existant respecte déjà la règle. Si la conformité revient, le code environnant prenait le dessus sur votre phrase.
- Recherchez un conflit. Deux fichiers qui donnent des consignes différentes pour le même comportement constituent un échec documenté : le modèle peut en choisir un arbitrairement et ne vous indiquera pas qu’il l’a fait.
- Rendez la règle vérifiable et testez-la de nouveau. Réécrivez-la avec un chemin concret et une condition. Une forte hausse de la conformité signifie que la formulation était à l’origine du problème.
L’étape 4 tient en une commande. Recherchez le sujet dans toutes les sources d’instructions, pas uniquement dans le fichier que vous étiez en train de modifier :
grep -rni "migration" --include="CLAUDE.md" --include="CLAUDE.local.md" --include="AGENTS.md" .
grep -rni "migration" .claude/rules/ ~/.claude/CLAUDE.md ~/.claude/rules/ 2>/dev/nullUn résultat dans deux fichiers qui donnent des consignes différentes est la cause du problème. Supprimez-en un. N’essayez pas de les départager avec une formulation plus impérative : aucun moteur de classement ne permet de le faire. Avec Claude Code v2.1.283 ou une version ultérieure, /doctor prompt-audit exécute une version plus large de cette recherche dans vos fichiers d’instructions, règles et skills, et signale les contradictions avec des modifications proposées, sans rien changer tant que vous ne le lui demandez pas.
Les correctifs, par ordre d’efficacité
Chaque étape ci-dessous a plus d’effet que la précédente et demande davantage de configuration. Commencez par le haut lorsqu’une règle est facile à reformuler. Descendez dès qu’une règle devient suffisamment importante pour que des oublis occasionnels ne soient plus acceptables.
- Rendez la règle concrète. Indiquez un chemin, une commande ou une condition. Ajoutez les éléments contradictoires que l’agent trouvera dans le dépôt, comme indiqué plus haut. Cette mesure ne coûte rien et corrige un nombre étonnamment élevé de cas.
- Rapprochez-la de ce qu’elle régit. Utilisez un
CLAUDE.mdimbriqué, une règle limitée à un chemin dans.claude/rules/ou un commentaire en haut du fichier lui-même. La règle est alors lue en même temps que le code auquel elle s’applique. Acceptez le compromis : tout ce qui est chargé de cette manière est supprimé lors de la prochaine compaction et revient à la prochaine lecture correspondante. - Déplacez l’application de la règle dans un hook. La prose demande. Un hook décide. Les hooks s’exécutent comme du code à des événements fixes du cycle de vie et s’appliquent indépendamment de la conclusion du modèle.
- Confiez la règle à un outil déterministe et supprimez la prose. Formatage, ordre des imports, longueur des lignes, imports interdits, format des messages de commit.
ruff format,prettier --write,eslint, un hookpre-commit. Le formatter a toujours raison et ne coûte aucun token. La phrase est généralement correcte et coûte des tokens à chaque tour.
Étape 3 en détail. Supposons que les fichiers de migration ne doivent jamais être modifiés par l’agent. Placez ceci dans .claude/settings.json :
{
"hooks": {
"PreToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{
"type": "command",
"command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/guard-migrations.sh"
}
]
}
]
}
}Et ceci dans .claude/hooks/guard-migrations.sh :
#!/usr/bin/env bash
set -euo pipefail
path=$(jq -r '.tool_input.file_path // empty')
case "$path" in
*/migrations/*)
echo "Files under migrations/ are written by hand. Stop and ask first." >&2
exit 2
;;
esac
exit 0Exécutez chmod +x .claude/hooks/guard-migrations.sh, puis démarrez une nouvelle session et demandez à l’agent de modifier un fichier sous migrations/. La modification est refusée et votre message revient comme motif. Le code de sortie 2 dans PreToolUse bloque l’appel de l’outil avant son exécution, et votre texte stderr est transmis au modèle comme message de blocage. ${CLAUDE_PROJECT_DIR} correspond à la racine du projet ; le hook fonctionne donc quel que soit le répertoire courant de l’agent. L’agent n’a pas besoin d’accepter la règle, de s’en souvenir ni de l’avoir encore dans son contexte. La modification n’a pas lieu.
Pour une interdiction simple, sans logique, permissions.deny dans vos paramètres fait le même travail sans script à maintenir, et les modes d’autorisation déterminent ce qui s’exécute sans vous le demander. Si une instruction doit réellement se trouver au niveau du system prompt plutôt que dans un message utilisateur, --append-system-prompt l’y place. Il s’agit toutefois d’un flag de lancement qui doit être transmis à chaque nouvelle session, ce qui convient mieux aux scripts qu’au travail interactif.
Ce que vous ne pouvez pas imposer par des instructions
Soyez clair sur la partie qui vous revient. L’emplacement, la formulation, les conflits entre fichiers et la taille du fichier relèvent de l’auteur, qui doit les corriger. Le reste relève du comportement du modèle, et une meilleure formulation ne le supprimera pas.
L’accord n’est pas l’obéissance. Un agent peut reconnaître une règle, vous la reformuler correctement, puis l’enfreindre deux appels d’outil plus tard. Cette reconnaissance ne coûte rien et ne permet aucune prédiction. Ne la considérez pas comme une correction et ne la comptez pas comme un test.
Certaines habitudes persistent. Ajouter des commentaires, ajouter une gestion défensive des erreurs, rédiger un récapitulatif final, exécuter la commande évidente suivante. Ces comportements réapparaissent lorsqu’une règle les interdit, mais moins souvent, et non jamais. Vous pouvez mesurer votre propre taux : exécutez la même tâche dix fois dans de nouvelles sessions et comptez les infractions. Lorsque ce nombre doit être égal à zéro, la règle doit sortir du prompt. Déclarer une tâche terminée alors qu’une partie reste inachevée relève de la même habitude. La correction doit être structurelle et non verbale : la compétence unlazy remplace la phrase par un arbre de profondeur et des fichiers de contrôle que l’agent doit valider avant de pouvoir déclarer la tâche terminée.
Votre session devient elle-même un exemple. Si l’agent a enfreint la règle au tour 12 et que vous avez laissé passer cette infraction, elle figure désormais dans le contexte comme démonstration, et elle est bien plus récente que la règle. Corrigez une infraction dès que vous la voyez. Une infraction non corrigée influence le reste de la session.
Un fichier d’instructions n’est pas une frontière de sécurité. Il oriente le comportement, mais ne l’impose pas. Tout ce dont l’échec coûte cher, comme les identifiants ou les commandes destructrices, doit relever des permissions ou d’un hook. Garder les secrets hors de portée d’un agent applique le même principe aux données : ne demandez pas à un agent de ne pas lire un fichier ; faites en sorte que le fichier ne soit pas lisible.
En bref : vérifiez que le fichier a été chargé, rendez la règle vérifiable, placez-la à côté de l’élément qu’elle régit et, lorsque le taux d’échec reste important, sortez-la de la prose. Une règle qu’un agent ne peut pas ignorer est une règle qui ne lui a jamais été demandée.
FAQ
Pourquoi Claude Code ignore-t-il mon fichier CLAUDE.md ?
Vérifiez d’abord qu’il a bien été chargé avant de conclure qu’il a été ignoré. Exécutez /context et consultez la liste Memory files ; un fichier qui n’y figure pas n’a pas été chargé au démarrage. Les fichiers d’instructions sont transmis sous la forme d’un message utilisateur après le prompt système. Ils sont donc traités comme du contexte et non comme une configuration appliquée de manière stricte. Il n’existe aucune garantie de respect systématique. Dans la plupart des cas, l’une des quatre situations suivantes se présente : le fichier se trouve dans un sous-répertoire que l’agent n’a jamais lu, deux fichiers se contredisent et le modèle en a choisi un arbitrairement, la règle est trop vague pour permettre de vérifier une action, ou le code environnant montre l’inverse de ce qu’indique la règle.
La modification du fichier d’instructions pendant la session change-t-elle quelque chose ?
Pas pour la copie déjà présente dans la conversation. Les fichiers situés au-dessus de votre répertoire de travail sont chargés intégralement au démarrage. Le texte que le modèle conserve est donc celui qui existait au lancement. Pour prendre en compte une modification, démarrez une nouvelle session ou demandez à l’agent de lire le fichier avec ses outils de lecture de fichiers habituels. La version actuelle est alors ajoutée à la conversation dans un nouveau message. Après une compaction, le fichier racine du projet est relu depuis le disque. La nouvelle version est donc également chargée à ce moment-là.
Quel fichier prévaut lorsqu’un CLAUDE.md racine et un fichier imbriqué sont en désaccord ?
Aucun des deux, de manière fiable. Les fichiers découverts sont concaténés dans le contexte au lieu de se remplacer. Ils sont ordonnés de la racine du système de fichiers jusqu’à votre répertoire de travail. Le fichier le plus proche est donc simplement lu en dernier. Il n’existe aucun moteur de précédence pour résoudre les contradictions, et la documentation de Claude Code précise que les règles contradictoires peuvent être résolues arbitrairement. Rédigez les fichiers imbriqués comme des ajouts en indiquant le chemin auquel ils s’appliquent, et supprimez la contradiction au lieu d’essayer de lui donner la priorité.
Mes instructions survivent-elles à /compact ?
Cela dépend de la manière dont elles ont été chargées. Le fichier racine du projet CLAUDE.md, les règles sans périmètre et la mémoire automatique sont réinjectés depuis le disque après une compaction. Les règles dotées d’un frontmatter paths: et les fichiers CLAUDE.md imbriqués dans des sous-répertoires sont perdus jusqu’à ce qu’un fichier correspondant soit lu de nouveau. Tout ce que vous avez uniquement saisi dans le chat ne survit que si le résumeur l’a conservé. Si une règle doit s’appliquer pendant toute la session, placez-la dans le fichier racine du projet, sans frontmatter paths:.
Quand une règle doit-elle devenir un hook plutôt que rester en prose ?
Lorsqu’un contrôle est déterministe et que le coût d’un oubli est supérieur à celui de l’écriture d’un petit script. Les restrictions sur les chemins de fichiers, les commandes obligatoires avant un commit et les appels d’outils interdits répondent à ce critère. Un hook PreToolUse qui se termine avec le code de sortie 2 bloque directement l’appel à l’outil et transmet au modèle le texte de stderr comme motif du blocage. La règle s’applique donc même si elle n’est plus présente dans le contexte. Tout ce qu’un formatter ou un linter peut décider doit être confié à cet outil, puis supprimé entièrement du fichier d’instructions.