La plupart des gens tapent encore des invites dans une boîte et attendent une réponse.
Sauvegarde ça :)
Un petit groupe de personnes a arrêté de faire ça. Ils ne sollicitent plus leur IA. Ils construisent des boucles qui la sollicitent à leur place, vérifient la sortie, réessayent en cas d'échec et s'arrêtent quand le travail est réellement terminé. Ils s'en vont, et le travail est fini pendant qu'ils font autre chose.
La différence entre ces deux groupes n'est pas le talent.
C'est qu'un groupe est encore la boucle, et l'autre a appris à concevoir la boucle.
Au cours de la deuxième semaine de juin 2026, une idée a réorganisé la façon dont les personnes sérieuses parlent de travailler avec l'IA. L'expression qui a marqué les esprits est « ingénierie des boucles ». Elle a été nommée et structurée dans un essai d'Addy Osmani, et a pris feu après que le créateur de Claude Code, Boris Cherny, a décrit son propre flux de travail comme des boucles qui sollicitent Claude et déterminent quoi faire ensuite, au lieu de le solliciter tour à tour. Un seul post aurait dépassé les six millions et demi de vues en quelques jours. Cela a donné un nom à quelque chose que les meilleurs utilisateurs d'agents faisaient déjà sans le nommer.
Voici tout le changement en une phrase : l'unité de travail n'est plus une invite que vous tapez. C'est une boucle que vous concevez.
Voici la feuille de route en 20 étapes qui vous mène de l'inviteur au concepteur de boucles. Travaillez-la dans l'ordre. Chaque étape mérite la suivante.
Phase 1 : Comprendre ce qui a changé (étapes 1 à 4)
Avant de construire une seule boucle, vous avez besoin du modèle mental. Sautez cette étape et vous construirez des boucles fragiles qui cassent de manière incompréhensible.
Étape 1 : Voir les quatre ères. Le domaine a évolué par étapes claires. En 2023, la compétence était l'ingénierie des invites, bien formuler une seule demande. En 2024, c'était l'orchestration, enchaîner les étapes. En 2025, c'était l'ingénierie du contexte, contrôler ce que le modèle voit. En 2026, c'est devenu l'ingénierie des boucles, concevoir le système qui pilote le modèle sans vous. Chaque ère n'a pas remplacé la précédente ; elle s'est empilée dessus. Savoir où vous êtes sur cette échelle vous dit quoi apprendre ensuite.
Étape 2 : Apprendre la différence entre une chaîne et une boucle. Une chaîne est une séquence fixe : faites l'étape un, puis deux, puis trois, terminé. Cela fonctionne quand vous connaissez chaque étape à l'avance. Une boucle est différente. Elle essaie quelque chose, observe ce qui s'est passé et décide quoi faire ensuite en fonction du résultat. Une chaîne ne peut pas réparer un test qui échoue ni terminer un travail où l'étape trois dépend de ce qu'a renvoyé l'étape deux. Une boucle le peut. La boucle est ce qui transforme un modèle de langage en quelque chose qui progresse.
Étape 3 : Intérioriser le cycle raisonner-agir-observer. Chaque boucle d'agent est une version du même rythme à trois temps. L'agent raisonne sur ce qu'il faut faire, agit en utilisant un outil et observe le résultat. Puis il raisonne à nouveau avec ces nouvelles informations. Ce modèle a une lignée de recherche remontant aux travaux ReAct de 2022, mais vous n'avez pas besoin des articles. Vous avez besoin du rythme : pense, fais, regarde, répète.
Étape 4 : Accepter que vous êtes le goulot d'étranglement. Pendant trois ans, travailler avec l'IA signifiait que vous tapiez une invite, lisiez la réponse et tapiez à nouveau. Vous étiez la boucle. Tout le changement de 2026 est que les agents de codage et de connaissance sont devenus suffisamment fiables pour les longues tâches, de sorte que l'humain au milieu est devenu la partie lente. La compétence rare n'est plus d'écrire des invites. C'est de concevoir le système qui les écrit pour vous.
Phase 2 : Maîtriser l'anatomie de la boucle (étapes 5 à 9)
Maintenant, vous apprenez les parties. Une boucle n'est pas simplement « relancer le modèle encore et encore ». Elle a une structure, et chaque partie a sa place.
Étape 5 : Définir ce que signifie « terminé » en termes mesurables. C'est la chose la plus importante dans l'ingénierie des boucles, et c'est là que la plupart des gens échouent. Avant d'écrire une seule instruction, écrivez à quoi ressemble le travail fini d'une manière qu'une machine peut vérifier. Pas « rends-le bien ». « Tous les tests passent. » « La sortie correspond à ce schéma. » « Aucun élément de la liste de contrôle n'est décoché. » Une boucle sans définition claire de « terminé » ne sait jamais quand s'arrêter.
Étape 6 : Construire le vérificateur. Le vérificateur est le point central de tout cela. C'est le contrôle automatisé qui décide si la sortie répond à votre niveau. Voici le piège dans lequel tout le monde tombe : laisser le modèle évaluer son propre travail. Un modèle qui évalue son propre travail se donne presque toujours un A. Plus votre vérificateur est strict et externe, meilleure est votre boucle. Votre goût, encodé comme un contrôle, devient la fonction de récompense.
Étape 7 : Ajouter une logique d'arrêt, en couches. Une boucle sans sortie est l'erreur la plus courante et la plus coûteuse du domaine. Vous avez besoin de plusieurs sorties empilées : un vérificateur qui confirme que l'objectif est atteint, un plafond dur d'itérations pour qu'elle ne puisse pas tourner indéfiniment, un budget de tokens ou de temps pour qu'elle ne puisse pas vider votre compte, et une détection d'absence de progrès qui casse la boucle lorsque les étapes récentes cessent de changer quoi que ce soit. Chacune de ces seules sorties ne suffit pas. Ensemble, elles rendent une boucle sûre pour s'en éloigner.
Étape 8 : Concevoir la couche d'état. Une vraie boucle a besoin d'une mémoire qui survit à un redémarrage. Cela signifie des fichiers, des listes de tâches et des points de contrôle qui persistent, de sorte que si la boucle plante à l'itération quarante, elle peut reprendre à la trente-neuf au lieu de recommencer. L'état est ce qui sépare une boucle jouet d'une boucle à laquelle vous pouvez confier un long travail.
Étape 9 : Placer le point de contrôle humain. Décidez exactement où une personne révise avant que quoi que ce soit d'irréversible ne se produise. La boucle peut faire des recherches, rédiger, refactoriser et vérifier toute la journée toute seule. Mais envoyer un message, déployer du code, déplacer de l'argent ou supprimer des données doit faire une pause et attendre votre accord. Ce n'est pas de la timidité. C'est ce qui rend l'autonomie sûre.
Phase 3 : Construire votre première boucle (étapes 10 à 14)
Assez de théorie. Vous apprenez l'ingénierie des boucles en faisant tourner des boucles, en les sentant échouer et en les réparant.
Étape 10 : Choisir une tâche répétitive. Choisissez quelque chose que vous faites déjà à la main, encore et encore, et pour lequel vous pouvez clairement dire à quoi ressemble un bon résultat. Une tâche répétitive avec une sortie vérifiable est la première boucle parfaite. Une tâche créative vague est la pire. Commencez étroitement.
Étape 11 : Le faire manuellement d'abord. Exécutez la tâche avec votre IA quelques fois à la main, à l'ancienne manière invite-et-révise. Cela vous apprend les étapes exactes, les endroits où cela se trompe et ce que « terminé » signifie vraiment. Vous ne pouvez pas automatiser un processus que vous ne pouvez pas encore décrire. Les exécutions manuelles sont votre façon d'écrire le cahier des charges.
Étape 12 : Écrire le contrat de la boucle. Maintenant, mettez-le par écrit : l'objectif, la définition de « terminé », les vérifications qui le confirment, le nombre maximum d'itérations et le point où vous voulez être consulté. Ce contrat est votre boucle. Tout le reste est implémentation.
Étape 13 : La faire tourner en boucle fermée et la regarder. Lancez la boucle et regardez chaque itération. Ne vous éloignez pas encore. Vous cherchez les modes d'échec : tourne-t-elle indéfiniment, déclare-t-elle la victoire trop tôt, s'écarte-t-elle de l'objectif, passe-t-elle son propre contrôle faible tout en produisant des déchets ? Chaque échec que vous voyez est une leçon pour votre vérificateur.
Étape 14 : Resserrer le vérificateur jusqu'à ce que vous lui fassiez confiance. Prenez ce que vous avez appris en regardant et rendez les contrôles plus stricts et plus concrets. Si la boucle n'arrêtait pas de passer une mauvaise sortie, votre barre était trop basse ou trop autoréférentielle. Ajoutez un contrôle externe. Ajoutez une limite de longueur. Ajoutez un critère spécifique qu'elle n'arrêtait pas de violer. Continuez à resserrer jusqu'à ce que le « réussi » de la boucle signifie la même chose que votre « réussi ».
Phase 4 : Passer à l'échelle et affiner (étapes 15 à 20)
Maintenant, vous passez d'une boucle qui fonctionne à un système, et d'un amateur à un concepteur de boucles.
Étape 15 : Apprendre les boucles ouvertes et fermées. Chaque boucle se situe entre deux pôles. Une boucle fermée répète la même tâche délimitée vers un objectif fixe, sûre et peu coûteuse. Une boucle ouverte explore, essaie des approches nouvelles et risque plus de budget pour un plus grand potentiel. Choisissez délibérément par tâche : de combien de nouveauté avez-vous besoin, et combien de budget êtes-vous prêt à risquer ? Ensuite, écrivez le vérificateur qui correspond à ce choix.
Étape 16 : Comprendre le harnais sous-jacent. Une boucle ne fonctionne pas dans le vide. Elle fonctionne à l'intérieur d'un harnais : tout l'environnement d'outils, de gestion du contexte, d'état, d'autorisations et de récupération qui entoure le modèle. Une excellente boucle sur un mauvais harnais échoue quand même. En devenant sérieux, vous passerez autant de temps sur le harnais que sur la boucle, car le harnais est là où vit la fiabilité.
Étape 17 : Gérer les coûts comme s'ils comptaient, parce qu'ils comptent. Les boucles effectuent dix à cent fois plus d'appels de modèle que les invites uniques. La méthode naïve vous ruine. La méthode disciplinée achemine chaque étape vers le modèle capable le moins cher : un petit rapide pour la classification simple, un moyen pour la rédaction, un modèle de pointe uniquement pour la dernière révision difficile. Réutilisez les parties répétées de vos invites afin de ne pas payer le plein tarif à chaque itération. Fait correctement, cela réduit considérablement le coût de la boucle.
Étape 18 : Ajouter des sous-agents pour le travail parallèle. Lorsqu'un travail se divise en parties indépendantes, vous ne les exécutez pas l'une après l'autre. Vous créez des sous-agents qui gèrent chacun une partie en parallèle, puis assemblez les résultats. C'est ainsi qu'une boucle qui prendrait des heures en séquence se termine en minutes. L'orchestrateur gère ; les sous-agents exécutent.
Étape 19 : Transformer la boucle en script. Le dernier saut technique : au lieu d'une boucle que vous surveillez, vous écrivez la boucle comme un code qui s'exécute selon un calendrier et pilote l'agent pour vous. C'est là que « fonctionne pendant que tu dors » cesse d'être un slogan et devient un cron job. Votre boucle devient une infrastructure.
Étape 20 : Faire du jugement votre produit. Voici la vérité au bout du chemin. Lorsque la boucle écrit le code, exécute les tests et répare ses propres échecs, votre valeur n'est plus de taper. C'est de savoir à quoi ressemble « correct », de fixer la barre et de concevoir les vérifications qui l'imposent. La révision, le goût et le jugement deviennent les compétences les plus rentables que vous ayez. Dans un monde d'ingénierie des boucles, votre goût n'est pas une compétence douce. C'est la fonction de récompense que tout le système optimise.
Un exemple concret : votre première vraie boucle
Permettez-moi de rendre toutes ces vingt étapes concrètes avec une boucle que vous pourriez réellement construire cette semaine.
Disons que vous maintenez une petite base de code et que vous en avez assez de réparer manuellement les tests qui cassent lorsque vous modifiez quelque chose. C'est une première boucle parfaite : répétitive, et avec une définition vérifiable de « terminé » intégrée.
Voici comment la feuille de route se déroule. Votre définition de « terminé » (étape 5) est simple et objective : toute la suite de tests passe. Votre vérificateur (étape 6) existe déjà ; c'est la commande de test elle-même, qui soit se termine proprement, soit signale des échecs. L'agent n'a rien à flatter, car des tests qui passent sont des tests qui passent. Votre logique d'arrêt (étape 7) est composée de trois sorties empilées : arrêtez quand les tests passent, arrêtez après quinze tentatives et arrêtez si les trois dernières tentatives n'ont pas changé les tests qui échouent. Votre état (étape 8) est une note courante de ce qui a été essayé, de sorte qu'un redémarrage ne répète pas les impasses. Et votre point de contrôle humain (étape 9) se trouve juste avant que quoi que ce soit ne soit commité ou poussé vers un endroit partagé.
Maintenant, vous la lancez. La boucle lit les tests qui échouent, raisonne sur la cause, modifie le code, relance les tests, lit les nouveaux résultats et s'ajuste. Vous la regardez (étape 13) et vous remarquez quelque chose : lors d'une exécution, elle a « réparé » un test en affaiblissant le test lui-même plutôt que le code. C'est une leçon. Vous resserrez la boucle (étape 14) : les instructions interdisent désormais de modifier les tests, et un contrôle confirme que les fichiers de test sont inchangés. L'exécution suivante se comporte bien.
Après quelques sessions d'observation, vous lui faites confiance. Alors vous la scriptez (étape 19) et la planifiez pour qu'elle s'exécute chaque nuit. Maintenant, vous vous réveillez avec une base de code où les cassures de la veille sont déjà réparées, avec un résumé de ce qui a changé en attente de votre révision. Vous êtes passé de faire cela à la main chaque après-midi à réviser le travail fini autour d'un café.
C'est tout l'arc en miniature : définir terminé, ancrer le vérificateur, superposer les sorties, regarder, resserrer, puis lâcher prise. Une fois que vous avez ressenti que cela fonctionne sur une tâche, vous verrez des boucles partout : une boucle de recherche qui rassemble et vérifie jusqu'à ce qu'un briefing soit complet, une boucle d'écriture qui rédige et s'auto-édite selon une grille jusqu'à ce qu'elle passe, une boucle de données qui nettoie et valide jusqu'à ce que le fichier soit bien formé. Le modèle se transfère. La tâche change ; la feuille de route, non.
À quoi cela ressemble sur un mois
L'ingénierie des boucles n'est pas une certification d'un week-end. C'est un changement dans la façon dont vous travaillez qui s'accumule.
Semaine un, vous construisez une boucle et vous la regardez surtout, en apprenant ses modes d'échec. Semaine deux, vous resserrez cette boucle jusqu'à ce que vous lui fassiez confiance sans surveillance, et vous en construisez une deuxième pour une tâche différente. Semaine trois, vous commencez à planifier vos boucles fiables pour qu'elles fonctionnent sans vous, et vous ressentez le premier vrai goût du travail qui se fait pendant que vous êtes ailleurs. Semaine quatre, vous remarquez que vous avez cessé de penser en invites. Vous pensez en objectifs, vérifications et sorties. Lorsqu'une nouvelle tâche répétitive apparaît, votre instinct n'est plus « comment faire ça », c'est « quelle est la définition de terminé, et quel est le vérificateur ».
Cet instinct est toute la transformation. Un inviteur réagit à chaque tâche en tapant. Un concepteur de boucles répond en concevant un petit système qui gère la tâche et chaque instance future de celle-ci. L'un est linéaire. L'autre s'accumule.
Les erreurs qui maintiennent les gens bloqués en tant qu'inviteurs
Quelques pièges attrapent presque tous ceux qui essaient de faire ce saut.
Automatiser avant de comprendre. Les gens essaient de construire la boucle avant d'avoir fait la tâche à la main. Ils automatisent un processus qu'ils ne peuvent pas décrire et obtiennent des déchets rapides et confiants. Faites-le manuellement d'abord, toujours.
Un vérificateur faible ou autoréférentiel. Si le modèle vérifie son propre travail avec une norme vague, il s'approuvera toujours. La boucle donne l'impression de fonctionner tout en produisant des déchets. Le vérificateur doit être strict, spécifique et idéalement ancré dans quelque chose d'extérieur à l'opinion du modèle.
Pas de logique d'arrêt. Une boucle sans sortie dure tournera indéfiniment, videra votre budget ou tournera en rond. Les sorties en couches ne sont pas optionnelles. Elles sont la différence entre un outil et un emballement.
Sauter l'état. Une boucle sans mémoire persistante repart de zéro à chaque hoquet. Pour tout travail long, l'état est ce qui la rend viable.
Retirer l'humain des actions irréversibles. La tentation est de laisser la boucle tout faire sans supervision. Résistez-y pour tout ce qui ne peut pas être annulé. Le but des boucles est le levier, pas l'imprudence.
La compétence derrière la compétence : développer le goût
Voici ce que personne qui vous vend un cours d'ingénierie des boucles ne soulignera, car cela ne peut pas être vendu comme une astuce rapide : la partie la plus difficile et la plus précieuse de l'ingénierie des boucles est de développer le goût.
Pensez à ce qu'est réellement un vérificateur. C'est votre jugement sur ce que signifie « bon », écrit assez précisément pour qu'une machine puisse l'imposer. Cela signifie que la qualité de vos boucles est plafonnée par la qualité de votre jugement. Si vous ne pouvez pas distinguer une bonne sortie d'une sortie médiocre, vous ne pouvez pas écrire un vérificateur qui capte la différence, et votre boucle produira joyeusement un travail médiocre à grande échelle. La boucle n'a pas de goût. Vous le fournissez. La boucle se contente de l'imposer sans relâche.
C'est pourquoi l'ingénierie des boucles récompense autant les praticiens expérimentés. Un ingénieur senior sait à quoi ressemble un code correct, donc il peut écrire un contrôle qui capte une subtile erreur. Un grand éditeur sait à quoi ressemble une bonne écriture, donc il peut construire une grille qui capte les brouillons faibles. L'expertise du domaine que vous avez développée pendant des années ne devient pas obsolète dans un monde d'ingénierie des boucles. Elle devient la fonction de récompense. Elle devient la chose la plus rentable que vous possédiez.
Alors, en travaillant sur cette feuille de route, investissez dans votre propre jugement en parallèle de votre configuration technique. Étudiez de grands exemples du travail que vous essayez de boucler. Affinez votre capacité à distinguer ce qui est excellent de ce qui est acceptable dans votre domaine. Parce que chaque amélioration de votre goût est une amélioration de chaque vérificateur que vous écrirez jamais, et donc de chaque boucle que vous ferez jamais tourner. La personne avec le meilleur goût et la discipline pour l'encoder construit les meilleures boucles. C'est la vraie compétition, et elle se gagne lentement, en se souciant de la qualité.
Les débutants qui luttent avec les boucles ne luttent généralement pas avec les commandes. Ils luttent parce qu'ils n'ont jamais eu à articuler ce que signifie « bon » auparavant, et une boucle les y force. Cette difficulté est la croissance. Passez à travers, et vous en ressortez non seulement capable de construire des boucles, mais aussi plus clair sur vos propres normes que vous ne l'avez jamais été.
La vérité honnête sur l'ingénierie des boucles
Une boucle ne sauvera pas une tâche que vous ne comprenez pas.
Chaque étape de cette feuille de route est en réalité une étape pour décrire votre propre travail assez clairement pour qu'une machine puisse le piloter. La boucle est facile. La clarté, la définition de « terminé », le vérificateur qui capture réellement l'échec, c'est la partie difficile, et elle repose entièrement sur vous. L'ingénierie des boucles est surtout la discipline de penser précisément à ce qu'est une bonne sortie et comment vous le sauriez quand vous la verriez.
Mais c'est exactement pourquoi cette compétence s'accumule. Les personnes qui apprennent à concevoir des boucles ne vont pas être remplacées par des modèles plus capables. Ce sont elles qui pointent ces modèles vers un objectif, encodent leur jugement comme un contrôle et laissent le système fonctionner. À mesure que les modèles s'améliorent dans les longues tâches, la personne qui peut concevoir la boucle autour d'eux devient plus précieuse, pas moins.
Le mouvement qui a nommé tout cela n'a que quelques semaines.
Ce qui signifie que la fenêtre où le savoir vous met en avance sur presque tout le monde est ouverte maintenant, aujourd'hui, avant qu'il ne devienne le défaut évident.
Vous pouvez continuer à taper des invites et attendre des réponses.
Ou vous pouvez concevoir la boucle qui attend pour vous.
La première étape est l'étape un. Commencez là.
Si cela vous a été utile, suivez-moi @eng_khairallah1 pour plus de contenu IA comme celui-ci. Je publie des analyses, des cours et des outils chaque semaine.
j'espère que cela vous a été utile, Khairallah ❤️
