Claude · 8 min
La règle des 2 corrections + le template reprompt qui sauve tes sessions Claude
La méthode pour sortir des spirales « fix du fix du fix » qui te bouffent 3 heures pour un bug que t'aurais corrigé en 15 minutes en mode normal. Basée sur les bonnes pratiques de prompt engineering d'Anthropic.
Ce qu’il y a dedans
- Le problème que tu connais déjà
- Pourquoi corriger plus de 2 fois est contre-productif
- Le pattern qui marche : 2 strikes → /clear → reprompt
- La subtilité avancée : éditer le message au lieu de /clear
La méthode pour sortir des spirales « fix du fix du fix » qui te bouffent 3 heures pour un bug que t'aurais corrigé en 15 minutes en mode normal. Basée sur les bonnes pratiques de prompt engineering d'Anthropic. Règle simple : 2 strikes → /clear → reprompt structuré.
Le problème que tu connais déjà
Tu demandes à Claude un truc qui devrait être simple. Il te sort une version qui ne marche pas. Tu lui dis « non, fais-le comme ça ». Il te sort une nouvelle version qui ne marche toujours pas. Tu re-corriges.
Au bout de 5-10 allers-retours, t'es 3 heures plus tard et Claude est complètement perdu. Il propose des solutions de plus en plus bizarres. Il réintroduit des bugs que t'avais déjà corrigés 30 min avant. Il invente des fonctions qui n'existent pas.
T'es entré dans la spirale du fix-du-fix-du-fix. Et c'est pas la faute de Claude. C'est mécanique.
Pourquoi corriger plus de 2 fois est contre-productif
Chaque message dans une session reste dans le contexte de Claude. Quand tu lui dis « non, refais », l'ancien essai ne disparaît pas. Il reste dans la mémoire de la conversation.
Après 2 corrections ratées :
- Strike 1 : Claude propose A. T'expliques que A ne marche pas. Ça part dans le contexte.
- Strike 2 : Claude propose B (en évitant A). T'expliques que B ne marche pas non plus. Ça part aussi dans le contexte.
- Strike 3 et après : Claude essaie de produire C qui n'est ni A ni B, en restant cohérent avec tout le contexte pollué. Le résultat est souvent pire que A ou B.
Tu ne rends pas Claude plus intelligent en lui disant « non, encore ». Tu lui demandes de raisonner sur un contexte qui n'a fait que se dégrader.
C'est ce que les chercheurs appellent le context poisoning : chaque mauvais raisonnement dans le contexte tire les raisonnements suivants vers le bas. La sortie se dégrade exponentiellement.
Le pattern qui marche : 2 strikes → /clear → reprompt
Étape 1 — Limite-toi à 2 corrections
Quand Claude se trompe une fois, tu corriges proprement avec contexte. Si ça marche, parfait.
Quand il se trompe une deuxième fois, tu corriges encore une fois. Si ça marche, parfait.
Mais si t'arrives au troisième essai qui foire : STOP. N'enchaine pas.
Étape 2 — /clear pour reset le contexte
Dans Claude Code : tape /clear. Sur Claude Desktop ou web : ouvre une nouvelle conversation.
Tout le contexte pollué par les 2 essais ratés disparaît. T'as une page blanche.
Étape 3 — Réécris ton prompt avec ce que tu as appris
C'est là que la magie opère. Pendant les 2 essais ratés, t'as appris :
- Ce que Claude a tendance à mal comprendre dans ta demande
- Quelles contraintes étaient implicites et que tu dois maintenant écrire explicitement
- Quelles directions sont mortes et qu'il faut bloquer dès le départ
Tu utilises ces apprentissages pour reformuler le prompt. Une seule fois. Bien.
Étape 4 — Tu relances
Dans la nouvelle session propre, tu colles ton reprompt amélioré. Claude attaque le problème frais, avec un prompt mieux. Le résultat est presque systématiquement meilleur que les 5 essais qui auraient suivi en mode « fix du fix ».
La subtilité avancée : éditer le message au lieu de /clear
Il y a une variante puissante du pattern, dans le cas où t'as déjà accumulé du contexte utile et que tu veux pas tout perdre avec un /clear total.
Le principe : au lieu de tout reset, tu édites le message qui a déclenché le mauvais virage. Claude Code, Claude Desktop et Claude.ai web permettent tous ça nativement.
Quand tu édites un message précédent :
- Tout le contexte AVANT ce message reste intact (toutes les bonnes décisions, le code qui marche déjà, les fichiers analysés)
- Tout ce qui était APRES disparaît (les essais ratés, les corrections, le contexte pollué)
- Claude répond comme si t'avais écrit ton nouveau message dès le premier essai
Comment éditer un message :
- Claude.ai web et Claude Desktop : hover sur ton message, clique le bouton édition (crayon), modifie, valide. Tout ce qui suivait disparaît.
- Claude Code (terminal) : appuie sur Esc puis flèche haut pour remonter aux messages précédents. Tu peux les rééditer directement.
Quand préférer l'edit au /clear total :
- T'as 30+ minutes de bon boulot avant le moment où ça a dérivé
- Tu peux pointer du doigt UN message précis qui a tout cassé (un prompt mal formulé, une mauvaise instruction)
- Le contexte avant ce message est nickel et tu veux le garder
Quand préférer /clear quand même :
- Le contexte est mauvais depuis longtemps (avant même les 2 strikes, t'avais déjà des choses pas géniales)
- Tu sais pas exactement où ça a dérivé
- C'est le tout début de la session, t'as rien à perdre
La règle pratique : si tu peux pointer du doigt UN message précis qui a tout cassé, édite-le. Si tu sais pas où ça a dérapé, /clear total. Dans la majorité des cas, l'edit est plus rentable car tu gardes la moitié utile du contexte.
À savoir aussi : après un edit, tu peux utiliser le même template de reprompt ci-dessous. Il marche exactement pareil, juste que t'as moins de contexte à ré-injecter parce que la partie utile est déjà dans la conversation.
LE template de reprompt (à copier-coller)
Voici le template que j'utilise après chaque /clear. 5 sections, ordre fixe.
## CE QUE JE VEUX (formulation finale)
[Reformule la mission en 3-5 lignes, le plus précis possible. Inclus les contraintes obligatoires dès le début.]
Exemple : « Je veux une fonction TypeScript qui prend un user object et retourne un boolean. La fonction doit retourner true uniquement si user.email est valide ET si user.role est dans ['admin', 'editor'] ET si user.lastLogin date de moins de 30 jours. Pas d'exceptions levées, juste un boolean. »
## CE QUE J'AI DÉJÀ TENTÉ (et qui n'a pas marché)
Approche 1 : [décris brièvement ce qu'on a essayé]
→ Résultat : [pourquoi ça a foiré]
Approche 2 : [décris brièvement ce qu'on a essayé]
→ Résultat : [pourquoi ça a foiré]
## CONTRAINTES À RESPECTER
[Liste explicite des contraintes qui sont sorties des essais ratés, même si elles paraissent évidentes]
- Pas utiliser [pattern X qui n'a pas marché]
- Doit être compatible avec [librairie / contrainte Y]
- Performance attendue : [métrique]
- Style de code : [convention spécifique à ton projet]
## CONTEXTE TECHNIQUE
[Stack, librairies utilisées, conventions du projet, fichiers clés pertinents — maximum 10 lignes]
## CE QUE JE NE VEUX PAS
[Anti-patterns identifiés pendant les essais ratés]
- Pas de [chose qu'il a tendance à ajouter inutilement]
- Pas de [pattern déprécié]
- Pas de [solution trop générique]
## DEMANDE FINALE
Maintenant, produit une solution propre qui respecte toutes les contraintes ci-dessus. Si tu as des doutes sur un point, pose-moi la question avant de coder.
Des sections claires, des contraintes explicites, des anti-patterns nommés. Claude attaque avec une vision complète du problème dès le premier message.
Comment savoir si t'es dans la spirale
Voici les 5 signaux qui montrent que t'es dans la spirale et qu'il faut /clear :
- Tu vois Claude réintroduire un bug que t'avais déjà corrigé dans la session.
- Tu vois Claude inventer des fonctions ou des méthodes qui n'existent pas (signe que le contexte est saturé et qu'il hallucine).
- Les réponses deviennent de plus en plus longues et confuses — il tente de couvrir tous les cas à la fois.
- Tu commences à lui parler comme à un enfant (« non non, JE NE VEUX PAS ça, je te répète que... »). Si t'en es là, le problème c'est plus Claude.
- Ça fait 30+ minutes que vous tournez en rond sur le même point.
Un seul de ces signaux suffit. /clear et reprompt.
Mes 3 conseils
- Garde un fichier prompts-qui-marchent.md dans ton projet. Quand un reprompt te sort un excellent résultat après un /clear, sauvegarde-le immédiatement. Au bout d'un mois, t'as une bibliothèque de prompts ultra-affutés pour les problèmes récurrents de ton domaine.
- Quand tu écris ton reprompt, sois plus explicite que tu ne penses devoir l'être. Ce qui te semble évident ne l'est pas pour Claude. Si tu te dis « pas besoin de préciser, il va comprendre », écris-le quand même. C'est exactement ce « évident pour moi » non écrit qui te fait perdre 3 heures.
- Résiste à la tentation de garder l'historique « au cas où ». Beaucoup ne /clear pas parce qu'ils se disent « si je fais ça, Claude perd tout ce qu'on a fait ». Faux. Tu vas ré-injecter les bons morceaux via le reprompt. Le mauvais (qui te bloque) disparait. C'est exactement ce que tu veux.
Les limites à garder en tête
- Sur les missions très longues avec contexte cumulé important, /clear te fait perdre du temps. Si vous êtes en train de coder une feature complexe et qu'il a déjà produit 200 lignes utiles, /clear obligerait à tout re-uploader. Dans ce cas, plutôt que /clear total : utilise une compaction intelligente (en résumant ce qui marche et en relançant juste sur la partie problématique dans une sous-session).
- La règle est statistique, pas absolue. Parfois la 3e correction marche. Mais sur 100 tentatives au-delà du strike 2, 80 % vont dégénérer en spirale. Tu vas le sentir au feeling après 1-2 semaines de pratique.
- Si tu /clear et reprompt 3 fois sur le même problème, c'est ton plan qui est mauvais. Pas Claude qui déconne. Quand tu /clear pour la 3e fois sur la même mission, prends une pause. Sors marcher. Reviens et reformule le problème à voix haute. Souvent tu réalises qu'il y a une contrainte fondamentale que tu n'avais pas identifiée.
- Sur les vraies missions complexes (architecture, refactor massif), préféré /ultra-plan direct. Plutôt que de partir au feeling et risquer la spirale, lance un /ultra-plan (voir lead magnet STACK). Le plan structuré dès le départ évite 90 % des fix-du-fix-du-fix.
Le mot de la fin
La différence entre un Builder qui finit ses missions en 1 jour et un qui galaire 3 jours sur le même truc, c'est rarement le niveau technique. C'est la discipline de /clear au bon moment.
Une session propre avec un reprompt bien fait bat une session bordélique pleine de corrections, pleine de compactions. À chaque fois.
La prochaine fois que Claude te trompe deux fois de suite, n'enchaine pas avec une troisième correction. /clear. Reprompt avec le template. Tu vas voir la différence en 5 minutes.
