Comment débloquer votre agent de code IA lorsqu'il répète sans cesse la même erreur

Vous demandez à votre agent de code IA de cesser d'utiliser une fonction obsolète. Il s'excuse, réécrit le code — et réutilise la même fonction obsolète. Vous le corrigez une troisième fois. Même résultat. C'est la « boucle infernale » (doom loop), et tous ceux qui construisent finissent par la rencontrer. La bonne nouvelle : une fois que vous comprenez pourquoi elle se produit, la solution est rapide et reproductible.

Pourquoi les agents se retrouvent bloqués

Un agent de code IA ne se souvient pas de votre dernière correction comme le ferait une personne. Il travaille à partir de son contexte — la transcription courante de votre conversation, à laquelle s'ajoutent les fichiers qu'il a lus. Deux problèmes surviennent lors d'une longue session :

• Les erreurs s'accumulent. Si une hypothèse erronée entre tôt dans le contexte, chaque réponse ultérieure vient s'appuyer dessus. Votre correction n'est qu'un message de plus, en concurrence avec tout le texte antérieur qui continue d'affirmer la mauvaise chose.
• La dégradation du contexte (context rot). À mesure que la fenêtre se remplit au cours d'une longue session, la qualité des réponses se dégrade progressivement. L'agent commence à perdre le fil des instructions que vous lui avez données vingt messages plus tôt.

Ainsi, quand un agent répète une erreur, ce n'est généralement pas par entêtement — il se noie dans un contexte pollué. Corrigez le contexte, pas l'attitude de l'agent.

Étape 1 : réinitialiser plutôt que réexpliquer

Votre réflexe est d'expliquer la correction avec plus d'insistance. Résistez-y. Chaque message supplémentaire s'ajoute au contexte pollué. À la place, éliminez le mauvais contexte :

• Dans Claude Code, /rewind fait revenir la conversation et les modifications de fichiers à un point de contrôle antérieur — utilisez-le lorsque les dernières étapes ont mal tourné mais que le travail précédent mérite d'être conservé (double-appui sur Esc pour le même menu). /clear efface entièrement la conversation et repart de zéro tout en laissant votre code intact — utilisez-le quand toute la session a déraillé. /compact résume l'historique sous une forme plus courte lorsque vous voulez poursuivre avec une empreinte plus légère. (Voir les bonnes pratiques de Claude Code.)
• Dans Cursor ou un outil basé sur le chat, ouvrez une nouvelle conversation pour la tâche bloquée plutôt que de poursuivre celle qui est empoisonnée.

Un contexte propre avec une seule instruction claire vaut mieux qu'un long contexte avec cinq instructions de plus en plus exaspérées.

Étape 2 : donner à la correction un foyer permanent

Une correction que vous tapez dans le chat disparaît à la fin de la session. À la session suivante, l'agent commet la même erreur — parce que vous avez retiré le correctif de sa mémoire en fermant la fenêtre. Placez les règles durables là où l'agent les lit à chaque fois :

• Claude Code : un fichier CLAUDE.md à la racine de votre dépôt.
• Cursor : un fichier de règles (par ex. .cursor/rules/).
• N'importe quel agent : un fichier AGENTS.md, désormais largement pris en charge.

Rédigez la règle sous la forme d'un énoncé simple et vérifiable. Non pas « essaie d'écrire du code propre », mais : « Utilise fetch, jamais axios. Ce projet n'a aucune dépendance à axios. »

Étape 3 : rendre la contrainte impossible à manquer

Voici un exemple concret. Disons que votre agent continue d'importer une bibliothèque de dates que vous avez supprimée :

// Agent keeps writing this:
import moment from 'moment'
const now = moment().format('YYYY-MM-DD')

Vous lui avez dit trois fois d'utiliser plutôt l'API intégrée Intl. Au lieu d'une quatrième correction, ajoutez une ligne à CLAUDE.md :

## Dates
Never import `moment` or `dayjs` — they are not installed.
Format dates with the built-in `Intl.DateTimeFormat`. Example:
`new Intl.DateTimeFormat('en-CA').format(new Date())` → "2026-07-04"

La différence : vous avez donné une règle assortie d'un exemple fonctionnel. Les agents suivent un exemple copiable bien plus fidèlement qu'une instruction abstraite, et la règle se charge désormais automatiquement au début de chaque session.

Étape 4 : donner à l'agent un moyen de se contrôler lui-même

Les agents répètent les erreurs qu'ils ne peuvent pas voir. Bouclez la boucle en donnant à l'agent un signal qu'il peut lire :

• Une règle de linter ou un test qui échoue précisément sur l'erreur en question. Si moment est interdit par votre linter, l'agent lance le linter, voit l'erreur et la corrige — sans que vous ayez à intervenir.
• Une « définition du terminé » rapide sous forme de liste dans votre prompt : « Avant de terminer, exécute npm run lint et npm test et confirme que les deux passent. »

C'est de loin la plus grande amélioration. Une erreur que l'agent peut détecter par lui-même cesse d'être une erreur que vous devez attraper.

Étape 5 : réduire la tâche

Si un agent tourne en boucle sur une demande vaste et vague (« refactorise le système d'authentification »), il est souvent perdu dans l'ampleur de la tâche, pas dans le détail. Découpez le travail en une seule petite étape vérifiable à la fois — « extrais la logique de rafraîchissement du token dans sa propre fonction, sans changer le comportement » — et validez chacune avant de passer à la suivante. Les petites tâches laissent moins de place à l'errance.

Le schéma récurrent

Quand votre agent ne cesse de répéter une erreur, déroulez la liste : réinitialisez le contexte, consignez la règle par écrit là où elle persiste, montrez un exemple, donnez-lui un contrôle qu'il peut exécuter lui-même, et restreignez la tâche. Vous remarquerez le fil conducteur — vous n'êtes pas en train d'argumenter avec l'agent, vous corrigez ce qu'il peut voir. Faites cela et la boucle infernale se transforme en un détour de deux minutes plutôt qu'en un après-midi perdu.