Toutes les ressources

Claude · 9 min

Le prompt qui fait bosser l'IA toute seule, en boucle, sans toi

Aujourd'hui tu utilises l'IA en aller-retour : tu demandes, tu regardes, tu corriges, tu redemandes. Ce petit ballet, tu le fais à la main des dizaines de fois par jour.

Ce qu’il y a dedans

  • Pourquoi personne le fait (alors que c'est le vrai unlock)
  • Le schéma complet : la boucle en 4 rouages
  • D'où ça vient (pour situer)
  • Monter ta première boucle

Aujourd'hui tu utilises l'IA en aller-retour : tu demandes, tu regardes, tu corriges, tu redemandes. Ce petit ballet, tu le fais à la main des dizaines de fois par jour. Ce guide te montre comment déléguer la boucle elle-même à l'IA : elle produit, elle relit ce qu'elle vient de faire, elle corrige, elle recommence. Toi tu lances, tu reviens quand c'est fini. Voilà le schéma complet et des exemples que tu peux copier ce soir.


Pourquoi personne le fait (alors que c'est le vrai unlock)

Regarde comment tu bosses avec l'IA en ce moment. Tu écris un prompt. Elle répond. Tu lis, tu dis « non, plutôt comme ça », elle recorrige. Tu répètes cinq, dix, vingt fois jusqu'à ce que ce soit bon.

Ce travail de va-et-vient, c'est TOI la boucle. C'est toi qui relis, qui juges, qui relances. L'IA ne fait qu'un maillon sur trois. Elle produit. C'est toi qui vérifies et qui décides de recommencer.

Le déclic, c'est de sortir de cette place. Tu n'es plus dans la boucle, tu la construis. Tu écris une fois les règles du jeu (« fais ça, vérifie que c'est bon comme ça, si c'est pas bon recommence »), et l'IA tourne dessus toute seule. C'est contre-intuitif, parce qu'on nous a appris à « bien parler à l'IA ». Le vrai skill maintenant, c'est d'écrire le prompt qui la fait travailler sans toi.

Boris Cherny, le créateur de Claude Code chez Anthropic, l'a dit en juin 2026 : il ne prompte quasiment plus l'IA directement. Il écrit des boucles qui, elles, promptent l'IA et décident quoi faire. Son boulot, c'est d'écrire les boucles. Pas les prompts.


Le schéma complet : la boucle en 4 rouages

Une boucle agentique, c'est quatre étapes qui s'enchaînent en rond. Retiens ce schéma, tout le reste en découle.

code
     ┌─────────────────────────────────────────┐
     │                                         │
     ▼                                         │
[1] PRODUIRE  ──►  [2] RELIRE  ──►  [3] JUGER  ┘
l'IA fait un      elle relit ce     "c'est bon ?"
premier jet       qu'elle vient      OUI ──► [4] STOP, livrer
                  de produire        NON ──► retour à [1]

Décortiqué :

  1. Produire. L'IA fait un premier jet. Un bout de code, un texte, une analyse, peu importe.
  2. Relire. Elle repasse sur ce qu'elle vient de sortir avec un regard neuf. Pas « est-ce que ça a l'air bien », mais un vrai test : est-ce que ça compile, est-ce que les tests passent, est-ce que ça répond au cahier des charges.
  3. Juger. Le rouage clé, celui que 90 % des gens oublient. Il faut un juge qui tranche : bon ou pas bon. Dans le jargon on appelle ça le CHECKER (le vérificateur), par opposition au DOER (celui qui fait). Une boucle sans juge, c'est une IA qui produit dans le vide.
  4. Boucler ou s'arrêter. Si le juge dit « pas bon », on repart au rouage 1 avec ce qui cloche en tête. Si le juge dit « bon », on s'arrête et on livre.

Le truc à comprendre : ce n'est pas de la magie, c'est deux rôles. Un ouvrier (DOER) et un contrôleur qualité (CHECKER). Dans une boucle bien montée, l'IA joue les deux, à tour de rôle, sans toi au milieu. Comme si tu avais un junior qui bosse et un senior qui relit, dans la même personne, en boucle.


D'où ça vient (pour situer)

L'idée a été popularisée en juillet 2025 par Geoffrey Huntley, un ingénieur australien, sous un nom volontairement ridicule : la « Ralph loop » (du nom du gamin le plus bête des Simpson). Sa version la plus brute tient en une ligne de terminal :

code
while :; do cat PROMPT.md | claude-code ; done

Traduction : « relance l'IA sur le même fichier de consignes, en boucle, à l'infini ». Chaque tour repart d'une page blanche, mais la mémoire survit dans les fichiers du projet (le code écrit, une liste de tâches, l'historique). L'IA avance, tour après tour, sur un projet réel pendant que tu dors.

Des développeurs racontent sur X avoir bouclé des projets entiers pour quelques centaines de dollars d'API pendant la nuit. Ce sont des témoignages, pas une garantie (et on verra plus bas pourquoi la facture peut vite grimper). Mais le principe, lui, est solide et repris partout aujourd'hui sous le nom de « loop engineering ».


Monter ta première boucle

Tu n'as pas besoin d'un terminal ni de savoir coder pour commencer. Il y a deux niveaux.

Niveau 1 — La boucle « dans un seul prompt » (accessible à tous)

Le plus simple : tu écris toi-même les 4 rouages dans un seul message, et l'IA les exécute en interne avant de te répondre. Ça marche dans n'importe quel chat (Claude, ChatGPT). Copie ce squelette :

code
Objectif : [ce que tu veux obtenir].

Procède en boucle, tout seul, sans me redemander :
1. Produis une première version.
2. Relis-la de façon critique et liste ce qui ne va pas.
3. Corrige les points listés.
4. Recommence les étapes 2 et 3 jusqu'à ce qu'il ne reste plus rien à corriger
   (maximum 4 tours).
Ne me montre que la version finale + un résumé de ce que tu as corrigé à chaque tour.

C'est ça, une boucle. Tu ne fais plus le va-et-vient : tu le décris une fois, l'IA le fait à ta place. Rien qu'avec ça, la qualité de sortie fait un bond, parce que l'IA critique son propre travail avant de te le donner.

Niveau 2 — La boucle autonome qui tourne en arrière-plan

Là on passe au « tu lances le soir, tu récupères le matin ». Ça demande un outil qui peut relancer l'IA tout seul et lui donner accès à tes fichiers. Concrètement, dans Claude Code tu combines une commande d'objectif long (type /goal) avec une planification (Routines / cron) qui la déclenche et la relance sans toi. L'IA génère, teste, se relance sur ses propres erreurs, et s'arrête quand l'objectif est atteint.

Ce niveau vaut le coup quand la tâche est bien cadrée et isolée (un refacto de nuit, une migration, une série de tests à écrire). Si tu n'es pas à l'aise avec le terminal, c'est exactement le genre de système que je déploie clé en main pour mes clients. On y revient à la fin.

Prérequis pour le niveau 2 :

  • Claude Code installé et configuré (voir mon lead magnet START pour les 5 réglages de base).
  • Un objectif clair et délimité. Une boucle floue tourne dans le vide.
  • Un environnement isolé (une branche git, un dossier de test) pour que l'IA ne casse rien pendant que tu dors.

5 boucles concrètes à lancer

Ne reste pas dans la théorie. Voici cinq boucles que tu peux copier aujourd'hui, du quick win au truc plus ambitieux.

1. La boucle « relis-toi » sur n'importe quel livrable

Le quick win. Colle ton texte, ton offre, ton mail, et lance la boucle de niveau 1 dessus. L'IA critique et réécrit jusqu'à ce que ce soit propre.

code
Voici mon [mail de prospection]. Boucle dessus :
produis une version, critique-la comme si tu étais le prospect qui la reçoit,
corrige, recommence jusqu'à ce qu'il n'y ait plus d'objection évidente.
Montre-moi la version finale.

2. La boucle « code + tests qui passent »

Pour un petit outil interne ou un script. L'IA écrit le code, lance les tests, lit les erreurs, corrige, relance. Tu ne touches à rien tant que ce n'est pas vert.

code
Écris [le script]. Puis boucle : lance les tests, si un test échoue,
lis l'erreur, corrige le code, relance les tests. Continue jusqu'à ce que
tout passe. Ne t'arrête pas au premier échec.

3. La boucle « objectif de nuit »

La boucle autonome (niveau 2) sur une tâche bien cadrée. Tu lances le soir un objectif isolé (« ajoute cette fonctionnalité, avec ses tests et sa doc »), et tu retrouves le résultat au réveil. C'est la promesse : un prompt, un résultat fini.

4. La boucle « 10 variantes puis garde la meilleure »

Pour du créatif ou du marketing. Au lieu d'une réponse, tu demandes à l'IA de générer plusieurs pistes, de les noter elle-même sur un critère précis, et de ne garder que la gagnante.

code
Génère 10 accroches pour [ce post]. Note chacune sur 10 selon
"est-ce que ça arrête le scroll dans les 2 premières secondes".
Garde les 2 meilleures, réécris-les une dernière fois, donne-moi le résultat.

5. La boucle « qualification client » en arrière-plan

Le combo stratégique. Une boucle qui tourne sur ta boîte mail ou tes leads entrants, qui qualifie chaque prospect selon ton ICP, se corrige au fil des cas, et te sort une short-list le matin. C'est là que la boucle devient un vrai employé silencieux. (Voir mon lead magnet QUOTIDIEN sur les 3 piliers de l'IA qui bosse en arrière-plan.)


Mes 3 conseils

  1. Le juge fait 80 % du résultat, pas le prompt de départ. Une boucle ne vaut que par son rouage 3 : le critère qui décide « bon ou pas bon ». « Vérifie que c'est bien » ne veut rien dire. « Vérifie que tous les tests passent » ou « vérifie qu'un prospect qui reçoit ça n'a plus d'objection » donne un juge qui mord. Passe 80 % de ton énergie à écrire le critère de sortie, pas la tâche.
  2. Toujours un plafond de tours. Une boucle sans « maximum 4 tours » peut tourner dans le vide, se corriger en rond, et cramer ta facture. Mets un plafond explicite à chaque fois. Si en 4 tours c'est pas réglé, c'est ton objectif qui est mal posé, pas la boucle qui manque de temps.
  3. Isole avant de lâcher la boucle en autonomie. Pour le niveau 2, ne lance jamais une boucle de nuit sur ton vrai projet directement. Une branche git, un dossier de test, un environnement à part. L'IA qui se relance toute seule est puissante et un peu aveugle : donne-lui un bac à sable, pas ton salon. (Sur la spirale du « fix qui casse autre chose », voir mon lead magnet FIX et la règle des 2 corrections.)

Les limites à garder en tête (le vrai twist)

C'est la partie que les vendeurs de rêve zappent. Une boucle autonome, c'est puissant, mais ce n'est pas magique.

  1. Un objectif ne dit jamais tout. Il reste toujours des choix cachés : le goût, les arbitrages, les priorités, ce que tu aurais tranché en 2 secondes et que tu n'as pas écrit. Livrée à elle-même, l'IA comble ces trous. Parfois juste, parfois à côté. Plus la tâche touche au goût et au jugement, moins la boucle est fiable.
  2. Plus la boucle tourne, plus la facture monte. Chaque tour consomme des tokens (l'unité que tu paies à l'IA). Une boucle qui tourne 30 fois coûte 30 fois. C'est là que ça peut déraper si tu n'as pas de plafond. (Pour faire baisser cette facture de 60 à 90 % sur les sessions longues, voir mon lead magnet RTK.)
  3. Le juge peut se tromper aussi. Le CHECKER, c'est la même IA. Si son critère est mal écrit, elle validera une sortie médiocre en toute confiance et te la livrera comme un cadeau. Une boucle amplifie un bon critère, mais elle amplifie aussi un mauvais.
  4. Ce n'est pas « zéro humain ». Le rôle change, il ne disparaît pas. Tu passes de « celui qui fait le va-et-vient » à « celui qui cadre l'objectif et vérifie le résultat final ». Ça reste ton jugement au début et à la fin. Ce qui disparaît, c'est le milieu répétitif.

Le mot de la fin

Le vrai skill en ce moment, ce n'est plus de savoir parler à l'IA. C'est d'écrire le prompt qui la fait travailler seule, en boucle, avec un juge qui tranche. Produire, relire, juger, recommencer. Quatre rouages, et ton rôle passe d'exécutant à architecte.

Commence petit ce soir. Prends ton prochain livrable, colle-le dans un chat, et lance la boucle de niveau 1 (le squelette est plus haut). Tu vas sentir la différence dès le premier tour. Une fois que tu as le réflexe, tu ne travailleras plus jamais l'IA en aller-retour à la main.

S’inscrire à la newsletter

Pas le temps de tout monter toi-même ?

Je structure ta boîte : systèmes, process et un OS qui fait tourner l’opérationnel sans que tout repasse par toi. On commence par un diagnostic de 45 minutes : on regarde comment ta boîte tourne, ce qui te coûte le plus, et tu repars avec un récap écrit.

ou écris-moi :@capitain.aimaxence@corelabs.studio