Le véritable obstacle d'une boucle ne réside pas dans le fait de laisser l'IA tourner en continu, mais dans sa capacité à savoir freiner d'elle-même.
« Arrêtez d'écrire des prompts » — cette phrase fait actuellement fureur dans le milieu de l'IA.
Du père d'OpenClaw, Peter Steinberger, qui travaille désormais chez OpenAI sur la prochaine génération d'assistants personnels intelligents, au créateur de Claude Code, Boris Cherny, ces grands noms de la Silicon Valley se tournent collectivement vers les « boucles » (loops).
L'ingénieur de Google Addy Osmani, qui a baptisé cette tendance « l'ingénierie des boucles » (loop engineering), en fait également partie.
Cherny dit qu'il n'écrit presque plus de prompts lui-même.
Il y a un agent qui les écrit pour lui, destinés à Claude. Il ne dialogue plus qu'avec ce nouveau Claude qui « orchestre tout ».
Et il a lancé une déclaration fracassante : dans dix ans, les boucles et des fonctionnalités similaires figureront parmi ses réalisations les plus fières.
Steinberger est encore plus catégorique : Arrêtez d'écrire des prompts pour les agents de programmation, vous devriez concevoir des boucles qui leur fournissent des prompts.
Il a même démontré sa boucle sur X : Codex se réveille toutes les 5 minutes, entretient automatiquement le dépôt de code, répartit les tâches, certaines réalisations se concrétisant de manière totalement autonome.
Mais qu'est-ce donc exactement, cette « boucle » dont les experts parlent sans cesse ?
Récemment, l'équipe Claude Code lui a donné une définition claire dans son blog officiel, distinguant même quatre types de boucles, établissant ainsi une discipline d'ingénierie pour le « travail automatisé des agents ».
L'équipe Claude Code publie un article définissant formellement la « boucle », et détaillant quatre types typiques : au tour par tour, par objectif, par temps, et proactive. (Source : Blog officiel de Claude)
En clair : la programmation par IA évolue de « l'écriture d'une phrase » vers « la conception d'un système qui fonctionne tout seul ».
Un prompt échange une réponse, une boucle échange un système qui continue à travailler pour vous une fois votre ordinateur fermé.
Et le programmeur passe de celui qui écrit du contenu à celui qui conçoit un système.
Quatre boucles, quatre « conditions d'arrêt »
Qu'est-ce qu'une boucle, au juste ?
Sur X, cela fait longtemps qu'on en discute, avec des réponses diverses. L'équipe Claude Code donne une définition très claire :
Une boucle, c'est un agent qui exécute de manière répétée un cycle de travail, encore et encore, jusqu'à ce qu'une condition d'arrêt soit déclenchée.
Quatre boucles, ce sont quatre « conditions d'arrêt ». Cette phrase est la clé pour comprendre ce blog technique de Claude Code sur les boucles.
En suivant les dimensions « comment déclencher, comment arrêter, quels primitifs utiliser, à quelles tâches convient-elle », Claude Code décompose la boucle en quatre types.
Le premier type : la boucle au tour par tour (turn-based).
La boucle au tour par tour : l'humain contrôle tour par tour, chaque prompt envoyé lance un cycle. (Source : Blog officiel de Claude)
Contrôle humain tour par tour. Vous écrivez une instruction, l'IA exécute un cycle, après vérification vous écrivez la suivante. Vous tenez le volant du début à la fin. C'est adapté aux petites tâches ponctuelles, qui n'entrent pas dans un processus ou un calendrier.
Pour réduire le nombre d'allers-retours, écrivez les étapes que vous vérifiez habituellement manuellement dans un fichier SKILL.md, et laissez l'IA les valider elle-même.
Plus la vérification peut être quantifiée, plus elle peut juger par elle-même si c'est bien fait, et moins vous aurez à surveiller.
Le deuxième type : la boucle par objectif (/goal).
La boucle par objectif : un modèle évaluateur juge en fonction des critères, et renvoie refaire le travail si l'objectif n'est pas atteint. (Source : Blog officiel de Claude)
Fixez d'abord un objectif, par exemple « obtenir un score Lighthouse de 90 ou plus sur la page d'accueil, et s'arrêter après 5 tentatives ».
Chaque fois que Claude veut s'arrêter, un modèle évaluateur arrive et compare avec vos critères. Si l'objectif n'est pas atteint, il le renvoie continuer, jusqu'à ce que l'objectif soit atteint, ou que le nombre de cycles que vous avez fixé soit épuisé.
Les critères quantifiables comme le nombre de tests réussis ou un seuil de score sont pratiques car Claude n'a pas à se demander « est-ce assez bon ? », l'évaluateur juge à sa place. Il n'a pas à deviner « c'est probablement bon » et s'arrêter prématurément, et la boucle peut se terminer proprement.
Le troisième type : la boucle temporelle (/loop et /schedule).
Déclenchée à intervalle de temps régulier, comme un réveil. Certains travaux sont répétitifs, la tâche ne change pas, seules les entrées varient, comme résumer les messages Slack chaque matin.
D'autres travaux nécessitent de surveiller des systèmes externes. La méthode la plus simple est de vérifier à intervalle régulier, voir ce qui a changé et réagir, comme pour une PR qui pourrait recevoir des commentaires ou voir son CI échouer.
Utilisez /loop pour réexécuter un prompt à intervalle régulier. Pour qu'il continue à tourner après que vous ayez éteint votre ordinateur, utilisez /schedule pour déplacer la boucle sur le cloud.
Cette logique est presque identique à celle des tâches planifiées (cron) bien connues des programmeurs.
Le quatrième type : la boucle proactive (proactive).
La boucle proactive : déclenchée par un événement ou le temps, fonctionne sans surveillance humaine, jusqu'à ce que vous l'arrêtiez manuellement. (Source : Blog officiel de Claude)
Déclenchée par un événement ou le temps, fonctionne sans surveillance humaine.
En combinaison avec le mode auto et des workflows dynamiques, elle automatise entièrement les longues tâches enchaînées : scanner les canaux de feedback toutes les heures, et dès réception d'un rapport de bug, trier, corriger, répondre automatiquement, le tout en une seule séquence, sans jamais s'arrêter pour vous demander une autorisation.
Chaque tâche se termine lorsqu'elle atteint son objectif, tandis que la tâche de routine générale tourne jusqu'à ce que vous l'arrêtiez manuellement. Elle convient aux tâches continues et aux limites claires : signalement de bugs, catégorisation de problèmes, mise à jour de dépendances.
Quatre boucles, en réalité, c'est quatre réponses à la question « quand faut-il s'arrêter ? » : l'humain décide, l'évaluateur décide, le temps décide, l'événement décide.
Regardons encore une couche plus bas.
D'après la documentation officielle de l'Agent SDK, le cœur de ce mécanisme est également très simple :
Claude évalue votre prompt, appelle un outil pour agir, récupère le résultat, puis répète, jusqu'à ce qu'à un certain cycle il n'appelle plus aucun outil, et c'est alors que la boucle se termine.
La boucle de l'agent selon la documentation officielle de l'Agent SDK de Claude Code : après entrée du prompt, Claude évalue, appelle un outil, réinjecte le résultat et réévalue, jusqu'à ce qu'à un certain cycle il n'appelle plus aucun outil, et produit alors la réponse finale. (Source : Documentation officielle de Claude Code)
Un agent autonome, en essence, n'est qu'un cercle comme celui-ci.
Ce qui a vraiment changé, ce n'est pas la boucle elle-même
Bien sûr, on ne peut pas non plus présenter « la conception de boucles » comme une révolution de zéro à un.
Les tâches planifiées, l'orchestration, les boucles de rétroaction, ces pratiques existaient déjà. Ce que fait Claude cette fois, c'est surtout de les nommer de manière unifiée et de les regrouper en une taxonomie standard.
Alors, qu'est-ce qui a changé ? L'accent est mis sur la « condition d'arrêt ».
Parmi tous les conseils pratiques résumés officiellement par Claude Code, celui qui est isolé et marqué comme « le plus précieux » est la vérification (verification) :
Donner à Claude un moyen de vérifier lui-même ses productions.
Le principe n'est pas difficile à comprendre.
Par exemple, demander à un ingénieur de faire une page web sans lui donner de navigateur, la page sera-t-elle belle ? Avec un navigateur, il voit immédiatement l'effet de chaque modification, ajuste jusqu'à satisfaction avant de livrer.
Et la puissance de la boucle de modèles provient précisément de cette capacité à « boucler par elle-même ».
Dans ce processus, le prompt n'est pas mort, il est simplement devenu un composant à l'intérieur de la boucle.
Le véritable noyau devient la conception de la condition d'arrêt, la conception du vérificateur (verifier), le contrôle du budget en tokens, la stratégie d'exécution multi-tours.
Une boucle sans barrière est puissante et dangereuse
Une boucle, cela signifie-t-il que vous pouvez laisser l'IA travailler seule toute la journée ?
Bien sûr que non.
Le premier obstacle est l'argent. Une boucle sans limite peut brûler le coût en tokens.
Selon des rapports, Steinberger se décrit comme « l'homme aux tokens illimités », car les tokens gratuits font partie des avantages de travailler chez OpenAI. Les gens ordinaires n'ont pas ce privilège.
Le second est plus insidieux. L'agent intelligent peut tomber dans une boucle infinie « semblant progresser, mais tournant en réalité en rond » : modifier sans cesse le même fichier, sans jamais réussir un nouveau test.
Il peut même, avec confiance, rendre une mauvaise solution de plus en plus « complète ».
Le consensus de la communauté ingénierie sur ce point est direct : une boucle est puissante, mais sans barrière (gating condition), elle est dangereuse.
Dans les discussions d'ingénierie sur Reddit, quelqu'un a résumé les trois barrières indispensables, à concevoir avant même d'écrire la boucle.
Condition terminée (done condition) : et elle doit être déterminable par la machine, par exemple tous les tests au vert, ou une spec fermée ;
Limite stricte (hard limit) : incluant le nombre maximum de tours et le coût maximum, pour prévenir spécifiquement les coûts incontrôlés et les boucles infinies ;
Détection d'absence de progrès : dès qu'on détecte qu'il touche à plusieurs reprises le même ensemble de fichiers sans nouveau test réussi, forcer l'arrêt.
L'officiel donne aussi toute une série de disciplines pour économiser :
Ne pas forcer l'utilisation de plusieurs agents pour de petites tâches ;
Utiliser des modèles petits, rapides et bon marché quand c'est possible, plutôt que de tout faire avec le plus puissant ;
Tester d'abord sur un petit échantillon avant de lancer à grande échelle ;
Confier les tâches déterministes à des scripts, exécuter un script est bien moins cher que de laisser le modèle raisonner étape par étape ;
Ne pas exécuter les tâches de routine plus souvent que nécessaire.
Ainsi, une boucle est tout un ensemble de conception sur « comment maîtriser l'IA », et non « laisser l'IA courir librement ».
Cela détermine aussi qu'actuellement, elle convient le mieux aux tâches structurées aux limites claires, et non aux créations libres et imaginatives.
Avant, on rivalisait sur qui savait parler, maintenant, sur qui sait construire un système
Dans ce tournant, ce qui change vraiment, c'est le centre de gravité de la programmation : il passe de la « conception de contenu » à la « conception d'un système de comportements ».
Avant, vous conceviez le contenu d'une instruction unique, maintenant vous concevez un ensemble complet de comportements : comment il se déclenche, comment il se vérifie, comment il s'arrête.
L'équipe officielle de Claude Code laisse un point de départ simple à ceux qui veulent concevoir des boucles :
Regardez le travail que vous faites vous-même tous les jours, choisissez un des goulots d'étranglement, puis posez-vous 3 questions :
Vérification : cette étape de vérification, puis-je l'écrire à sa place ?
Objectif : la description de l'objectif est-elle suffisamment claire ?
Rythme : la tâche apparaît-elle à un rythme fixe ?
Si la réponse à l'une d'entre elles est oui, vous avez trouvé la première boucle que vous pouvez déléguer.
La programmation par IA : avant, on rivalisait sur l'art du prompt, maintenant, on rivalise sur qui sait construire un système : qui peut concevoir une boucle qui sait se vérifier elle-même et sait quand s'arrêter.
L'ère de l'écriture de prompts ne disparaîtra pas du jour au lendemain, mais son aura se déplace vers les boucles.
Et les véritables concepteurs de boucles viennent tout juste d'entrer en scène.
Références :
https://claude.com/blog/getting-started-with-loops
https://code.claude.com/docs/en/agent-sdk/agent-loop
https://support.claude.com/en/articles/14554000-claude-code-power-user-tips?utm_source=chatgpt.com https://www.reddit.com/r/ClaudeWorkflows/comments/1ujy4wq/workflow_designing_robust_claude_agent_loops/
Cet article provient du compte public WeChat « 新智元 », auteur : 元宇
