Pourquoi les agents IA ignorent vos règles .md — et comment faire en sorte que CLAUDE.md, les Cursor Rules et AGENTS.md tiennent vraiment

Vous demandez à Claude Code : « Tu as bien lu CLAUDE.md ? » Il vous répond joyeusement : « Oui, je l'ai lu. » Quelques échanges plus tard, aucune des règles de ce fichier n'est réellement appliquée — vos commandes spécifiques au projet, vos conventions de messages de commit, vos étapes de déploiement. Tout s'est silencieusement évaporé.

Ce problème n'est pas exclusif à Claude Code. La même dérive apparaît dans .cursor/rules de Cursor, dans .github/copilot-instructions.md de GitHub Copilot et dans AGENTS.md de Codex CLI dès que vous les utilisez assez longtemps.

Cet article expose les cinq causes profondes qui poussent les agents IA à ignorer vos fichiers de règles .md, puis présente des techniques de réécriture rapides et une systématisation à plus long terme avec les Hooks et les sub-agents, le tout illustré par des exemples concrets.

1. Pourquoi l'IA ignore vos règles — 5 causes profondes

1. Limites structurelles de la fenêtre de contexte

Un LLM ne prête pas la même attention à chaque token de son entrée. Les instructions enfouies au milieu d'un long document se perdent — c'est l'effet « lost in the middle » bien documenté. Dès que votre CLAUDE.md dépasse environ 200 lignes, tout ce qui se trouve au milieu disparaît de fait.

2. L'auto-compact dans les sessions longues

Claude Code dispose d'une fonctionnalité /compact qui compresse l'historique de la conversation. Lorsqu'elle se déclenche automatiquement, les instructions du niveau system prompt survivent, mais les détails opérationnels de CLAUDE.md sont résumés à la perte ou complètement supprimés. C'est pour cela que les violations de règles se concentrent dans la seconde moitié des sessions longues.

3. Les instructions directes de l'utilisateur passent en priorité

Pour une IA, « ce que l'utilisateur vient de dire » pèse plus lourd que « une règle qu'elle a lue il y a 300 tours ». Dès qu'un utilisateur dit « fais-le » ou « vas-y, commit », votre règle « toujours confirmer avant de commiter » dans CLAUDE.md est piétinée.

4. Règles vagues ou contradictoires

Des directives subjectives comme « écris poliment » ou « gère ça correctement » laissent l'IA interpréter à sa guise, ce qui correspond rarement à ce que vous vouliez. Réécrivez-les sous forme de contraintes vérifiables : « limite les réponses à 3 lignes », « utilise chat.postMessage pour l'API Slack », etc.

5. Fichiers de règles surchargés et éparpillés

CLAUDE.md plus SPEC.md plus README.md plus tout un tas d'autres fichiers .md — une fois qu'ils sont dispersés et chacun très long, l'IA ne les lit pas avec un poids égal. Quand la même règle apparaît dans plusieurs fichiers avec de subtiles différences, l'IA tend à choisir la version qui semble la plus sûre.

2. Comment diagnostiquer si vos règles sont vraiment suivies

Commencez par vérifier l'état actuel. Posez les questions suivantes à l'IA et observez la réponse :

Quand l'IA dit « je l'ai lu » ou « j'ai compris », cela ne vous apprend rien. Savoir si elle applique réellement les règles est une autre question — jugez d'après le comportement après exécution, pas d'après ce qu'elle prétend.

3. Correctifs rapides applicables en 5 minutes

1. Compressez votre fichier de règles à moins de 150 lignes

En pratique, Claude Code suit de manière fiable un CLAUDE.md d'environ 100 à 150 lignes. Au-delà, divisez-le :

• Règles non négociables (10 à 20 lignes) — en haut de CLAUDE.md
• Spécifications par service — extrayez-les dans des SPEC-xxx.md
• Historique et contexte — déplacez-les dans un dossier docs/

Réservez CLAUDE.md aux « choses catastrophiques en cas d'oubli ». Le détail peut vivre dans des fichiers liés.

2. Ajoutez des marqueurs de priorité explicites

Utilisez des mots-clés de priorité bien visibles pour forcer l'attention de l'IA :

• CRITICAL — une violation provoque un incident en production
• MUST — toujours suivre
• SHOULD — suivre par défaut
• NICE TO HAVE — uniquement s'il reste de la place

Une ligne comme « CRITICAL : les requêtes destructives sur la base de production exigent une approbation explicite » est bien plus difficile à manquer, même enfouie dans un long fichier.

3. Réinsistez dans le chat lui-même

Au début d'une session, glissez une consigne comme « Avant de commencer, déclare les trois règles les plus importantes de CLAUDE.md. » Cela ramène ces règles dans le contexte récent et les ancre pour le reste de la session.

4. Tracez les opérations dangereuses dans TodoWrite

Utilisez l'outil TodoWrite d'un agent IA (ou la fonction de suivi de tâches équivalente dans votre outil) pour inscrire « vérification des règles » comme étape explicite. La visibilité rend les « j'ai oublié » beaucoup plus rares.

4. Systématisation à long terme — Hooks, sub-agents, slash commands

On ne peut faire reposer indéfiniment les règles sur de la prose. Passer de « demander à l'IA de suivre les règles » à « faire en sorte que l'environnement les impose » est bien plus fiable.

1. Imposer mécaniquement avec les Hooks de Claude Code

La fonctionnalité Hooks de Claude Code permet d'exécuter des scripts arbitraires avant ou après certains appels d'outils. Vous pouvez ainsi construire un dispositif où le système arrête l'IA même quand elle oublie elle-même la règle.

Par exemple, avec un hook PreToolUse :

• Détecter les commandes dangereuses (rm -rf, git push --force) avant l'exécution de Bash et les bloquer
• Vérifier les permissions ou l'état de verrouillage d'un fichier avant qu'Edit ne le touche
• Lancer les tests propres au projet avant un commit et l'avorter en cas d'échec

Demander gentiment dans la prose ne fait pas le poids face à une application mécanique via Hooks.

2. Séparer les responsabilités avec les sub-agents

Utilisez les capacités de sub-agent du Claude Agent SDK ou de Cursor pour bâtir un « agent d'audit des règles » dédié. Un flux en deux étapes où l'agent principal écrit le code et l'agent d'audit le passe en revue détecte les violations même quand l'agent principal oublie.

Le sub-agent n'a besoin que d'un prompt court centré sur l'audit, donc son taux de reconnaissance des règles reste élevé. C'est là toute la clé.

3. Codifier les routines en slash commands personnalisées

Les workflows répétitifs comme « lance ces 3 vérifications avant chaque commit » sont parfaits pour une slash command (/precommit, etc.). Lorsque l'utilisateur tape /precommit, l'IA exécute une séquence figée. Plus besoin de relire le fichier de règles à chaque fois.

4. Détecter les violations avec des scripts automatisés

Lancez une détection à base de grep des motifs interdits dans la CI ou comme pre-commit hook. Exemples :

• console.log oublié dans le code de production
• Clés d'API codées en dur
• En-têtes de copyright manquants

Ne comptez pas sur l'IA — laissez les machines trouver. C'est votre dernière ligne de défense.

5. Bonnes pratiques par outil

La règle universelle est « court, spécifique, priorisé. » Les noms de fichiers et les emplacements varient d'un outil à l'autre, mais les principes d'écriture restent les mêmes.

6. Trois anti-patterns dans la conception des règles

1. « Suis les bonnes pratiques. »

Les bonnes pratiques de qui ? L'IA part par défaut sur la moyenne de ses données d'entraînement, ce qui vous donne le plus petit dénominateur commun. Les particularités propres à votre projet n'y entrent jamais. Écrivez plutôt des do's et don'ts concrets.

2. La même règle dupliquée dans plusieurs fichiers

Si vos « conventions de commit » vivent à la fois dans CLAUDE.md, SPEC.md et README.md, les trois copies divergeront subtilement et embrouilleront l'IA. Choisissez une seule source de vérité et faites-y pointer tout le reste.

3. Tamponner « ABSOLUMENT OBLIGATOIRE » sur tout

Si tout est « absolu », l'IA perd la capacité de hiérarchiser. Réservez « CRITICAL » au véritablement catastrophique ; laissez le reste en prose normale. L'emphase souffre d'inflation — gardez-la rare.

Conclusion

Quand les agents IA ignorent vos règles .md, c'est presque toujours dû à des contraintes structurelles et à des problèmes de conception des règles, pas à de la paresse de l'IA. La plupart des cas se résolvent par des correctifs rapides — compresser à moins de 150 lignes, ajouter des marqueurs de priorité, réinsister dans le chat. Pour les règles vraiment critiques qui restent, passez à l'application mécanique : Hooks, sub-agents, slash commands et scripts de détection automatisés.

« Si les règles ne sont pas suivies, construisez un système qui les impose » — voilà le nouveau bon sens dans l'exploitation des agents IA.

FAQ

Q1. Quelle est la longueur idéale pour CLAUDE.md ?

En pratique, 100 à 150 lignes. Au-delà de 200, divisez en SPEC-xxx.md ou similaire. Placer un résumé « top 5 des règles critiques » tout en haut est une bonne assurance contre l'oubli.

Q2. Faut-il utiliser .cursorrules de Cursor ou .cursor/rules/*.mdc ?

Pour les nouvelles configurations, .cursor/rules/*.mdc. Une règle par fichier, avec des motifs glob pour délimiter où chaque règle s'applique. L'ancien fichier unique .cursorrules a tendance à enfler avec le temps.

Q3. Des règles plus longues rendent-elles l'IA plus stricte ?

L'inverse. Plus le fichier est long, plus le milieu se dilue. Des règles courtes et essentielles placées en évidence (en haut) sont suivies à des taux plus élevés.

Q4. Et si j'utilise plusieurs outils IA (Claude Code + Cursor) sur le même projet ?

La réponse pragmatique consiste à placer le même résumé dans le fichier de configuration de chaque outil et à centraliser les détails dans un SPEC.md partagé. Il n'existe pas encore de solution totalement unifiée (à mai 2026).

Q5. Quand l'IA dit « je l'ai lu », elle ne le lit vraiment pas ?

L'affirmation « je l'ai lu » et le comportement réel à l'exécution sont deux choses différentes. Utilisez les méthodes de diagnostic de la section 2 pour vérifier la reconnaissance au niveau de l'exécution.