Tutoriel d’ingénierie de boucle adapté aux débutants : lancez votre première boucle d’agent IA avec une seule commande

Introduction

Si vous entendez parler d’« ingénierie de boucle » sans vraiment savoir par où commencer, ce guide vous propose un point d’entrée pratique.

Au lieu d’écrire des prompts à répétition et de vérifier chaque étape manuellement, une boucle permet à un agent IA de travailler vers un petit objectif selon un calendrier. Le système peut attribuer la tâche, lire l’état actuel, exécuter l’agent, vérifier le résultat et faire intervenir de nouveau un humain lorsqu’un jugement est nécessaire.

Le rapport original présentait un framework open source d’ingénierie de boucle créé par Cobus Greyling. Au moment de la publication du rapport, le projet comptait environ 4,5 k étoiles sur GitHub. Le dépôt peut désormais afficher un nombre d’étoiles différent, car il a continué à se développer.

En bref : l’objectif n’est plus seulement d’écrire de meilleurs prompts. Il s’agit de concevoir une boucle fiable, capable de générer des prompts, de vérifier et d’itérer avec des limites claires.

Qu’est-ce que l’ingénierie de boucle ?

L’ingénierie de boucle est une manière de concevoir des flux de travail répétables pour des agents IA. Une boucle n’est pas simplement un prompt unique. C’est un petit système d’exploitation autour d’un agent : elle définit quand l’agent s’exécute, quel contexte il lit, ce qu’il est autorisé à modifier, comment le résultat est vérifié et quand un humain doit examiner l’issue.

Une boucle typique peut être utilisée pour des tâches telles que :

• le tri quotidien de projets ;
• la surveillance des pull requests ;
• le nettoyage des échecs de CI ;
• l’analyse des dépendances ;
• le tri des issues ;
• le nettoyage après des fusions ;
• la rédaction de journaux de modifications.

Ces tâches ne sont pas toujours difficiles, mais elles sont répétitives. Elles exigent de l’attention, du contexte et une norme cohérente. C’est précisément le type de travail pour lequel une boucle bien conçue peut être utile.

Pourquoi ce framework attire l’attention

Le framework open source décrit dans l’article original réunit des modèles de boucle pratiques, des modèles de démarrage et des outils en ligne de commande. Il est conçu pour les agents IA de codage et prend en charge des flux de travail autour d’outils tels que Claude Code, Codex, Grok et OpenCode.

Le framework comprend :

• sept modèles de boucle prêts à l’emploi ;
• des modèles de démarrage pour des scénarios courants ;
• loop-init pour générer la structure d’une boucle ;
• loop-cost pour estimer le coût en tokens ;
• loop-audit pour vérifier l’état de préparation d’une boucle ;
• des fichiers d’état et de budget pour les flux de travail de longue durée ;
• une prise en charge d’une revue humaine plus sûre et d’un déploiement progressif.

Le message central est simple :

Arrêtez de prompter. Concevez la boucle.

Cela ne signifie pas que les prompts disparaissent. Cela signifie que les prompts deviennent une partie d’un système plus large, capable de répéter le travail, de suivre l’état et de vérifier les résultats.

Démarrer rapidement : une seule commande

Le moyen le plus rapide de commencer consiste à exécuter loop-init dans un projet Git.

Remarque : certaines versions republiées de l’article original affichent les options de ligne de commande avec un tiret long. Dans un vrai terminal, utilisez le double tiret standard -- indiqué ci-dessous.

npx @cobusgreyling/loop-init . --pattern daily-triage --tool claude

Cette commande génère la structure de la boucle dans votre projet actuel. Vous pouvez remplacer claude par un autre outil pris en charge, comme grok, codex ou opencode, selon le flux de travail que vous souhaitez tester.

Le modèle daily-triage constitue un bon point de départ pour les débutants, car il présente moins de risques qu’une automatisation à haute fréquence. Il se concentre sur l’analyse de l’état actuel du projet et la production d’un rapport avant d’autoriser toute modification automatique.

Tutoriel d’ingénierie de boucle adapté aux débutants

L’ingénierie de boucle peut sembler abstraite au premier abord, mais le framework la décompose en quelques blocs de construction concrets.

Les cinq blocs de construction plus la mémoire

À un niveau de base, une boucle est construite à partir de cinq parties principales, auxquelles s’ajoutent la mémoire et l’état.

Bloc de construction	Ce qu’il fait dans la boucle
Automatisation / Planification	Exécute la boucle selon une cadence, par exemple chaque jour, chaque heure ou toutes les quelques minutes.
Arbres de travail	Crée des environnements de travail isolés afin que plusieurs agents ne s’écrasent pas mutuellement.
Compétences	Stocke les connaissances réutilisables du projet, les règles et les instructions de tâche.
Plugins et connecteurs	Connecte la boucle à de vrais outils via des systèmes tels que MCP, GitHub, Linear ou Slack.
Sous-agents	Sépare le rôle de producteur du rôle de vérificateur afin que le même agent n’approuve pas son propre travail.
Mémoire / État	Conserve un contexte durable en dehors de la boucle.

chat, généralement via des fichiers tels que STATE.md. |

Cette structure rend la boucle plus facile à comprendre. Vous ne demandez pas au modèle de « tout gérer simplement ». Vous lui fournissez un environnement défini, une planification, un fichier d’état, un chemin de vérification et une règle de transfert vers un humain.

Sept modèles de production prêts à l’emploi

Le framework comprend également sept modèles orientés production. Chaque modèle possède une cadence, un niveau de risque et un cas d’utilisation optimal différents.

Modèle	Cas d’utilisation typique	Mode de départ suggéré
Daily Triage	Analyser l’état du projet, les tickets, la CI et les commits.	L1 report-only
PR Babysitter	Surveiller les pull requests tout au long de la revue, de la CI, du rebase et de la fusion.	L1 watch
CI Sweeper	Surveiller les checks en échec et proposer ou appliquer de petites corrections.	L2 cautious
Dependency Sweeper	Vérifier les dépendances obsolètes et les mises à jour de sécurité.	L2 patch-only
Issue Triage	Dédupliquer, évaluer et étiqueter les nouveaux tickets.	L1 propose-only
Post-Merge Cleanup	Nettoyer les TODO, la dette mineure et les travaux de suivi après les fusions.	L1 off-peak
Changelog Drafter	Rédiger les notes de version à partir des commits et des changements fusionnés.	L1 draft

Le conseil pratique est de commencer par une boucle à faible risque. Le triage quotidien est généralement plus facile à adopter en toute confiance, car il n’a pas besoin de modifier le code immédiatement.

Sélecteur interactif de modèles

Le projet fournit également un sélecteur interactif. Au lieu de choisir un modèle manuellement, vous pouvez partir d’un point de douleur comme « les PR restent bloquées », « la CI échoue sans cesse » ou « les tickets sont trop bruyants ».

Le sélecteur recommande ensuite un modèle de boucle et vous fournit une commande de départ. C’est utile lorsque vous connaissez le problème, mais que vous ne savez pas quelle boucle doit s’en charger.

Exécuter votre première boucle

Voici une manière adaptée aux débutants d’exécuter la première boucle tout en gardant le risque sous contrôle.

Étape 1 : Choisir un modèle

Commencez par daily-triage si c’est votre première fois. C’est un modèle à faible risque et un bon moyen de comprendre comment la boucle lit l’état du projet, écrit des notes et prépare le travail pour un humain.

Étape 2 : Générer la structure de la boucle

Exécutez la commande d’initialisation dans le répertoire racine de votre projet Git.

npx @cobusgreyling/loop-init . --pattern daily-triage --tool claude

Vous pouvez remplacer le nom de l’outil si vous utilisez un autre agent de codage IA.

npx @cobusgreyling/loop-init . --pattern daily-triage --tool grok
npx @cobusgreyling/loop-init . --pattern daily-triage --tool codex
npx @cobusgreyling/loop-init . --pattern daily-triage --tool opencode

Vous pouvez également remplacer daily-triage par un autre modèle pris en charge une fois que vous comprenez le flux de base.

Étape 3 : Estimer le coût en tokens

Les boucles à haute fréquence peuvent consommer beaucoup de tokens, surtout si elles utilisent des sous-agents, un long contexte ou des vérifications répétées. Estimez le coût avant d’exécuter une boucle trop souvent.

npx @cobusgreyling/loop-cost --pattern daily-triage --level L1

Pour les premiers tests, gardez la boucle au niveau L1 et évitez les planifications agressives.

Étape 4 : Auditer l’état de préparation de la boucle

Avant de faire confiance à la boucle, lancez un audit. L’audit attribue au projet un score de préparation de 0 à 100 et suggère des améliorations.

npx @cobusgreyling/loop-audit . --suggest

Si votre projet n’est pas prêt, corrigez d’abord les éléments manquants. Les lacunes courantes incluent l’absence de fichier d’état, l’absence d’étape de vérification, un périmètre flou, des limites budgétaires manquantes ou des règles faibles de transfert vers un humain.

Si le projet atteint un bon niveau de préparation, vous pouvez également générer un badge Loop Ready pour votre README.

npx @cobusgreyling/loop-audit . --badge

Étape 5 : Commencer en mode rapport uniquement

Ne laissez pas la boucle modifier le code de production dès le premier jour. Commencez en mode rapport uniquement, puis examinez manuellement la sortie.

Pour une commande de boucle de style Grok, la première exécution peut ressembler à ceci :

/loop 1d Run loop-triage. Update STATE.md. No auto-fix in week one.

Cela indique à la boucle d’effectuer le triage, d’écrire l’état et d’éviter les corrections automatiques pendant la première semaine.

Étape 6 : Lire la sortie

Ouvrez STATE.md et vérifiez ce que la boucle a trouvé. Ce fichier sert de mémoire en dehors de la conversation. Il doit montrer ce que la boucle a vu, ce qu’elle a fait, ce qu’elle a ignoré et ce qui nécessite l’attention d’un humain.

Si la sortie est bruyante ou incorrecte, ajustez la boucle avant d’augmenter son autonomie. Une boucle utile doit devenir ennuyeuse, prévisible et inspectable.

Maturité des boucles : de L1 à L3

Le Loop Engineering doit être déployé progressivement. Les niveaux de maturité vous aident à éviter d’accorder trop de liberté trop tôt.

Niveau	Signification	Utilisation recommandée
L1	La boucle signale les constats et met à jour l’état, mais ne modifie pas le code.	Idéal pour les premières exécutions et une adoption à faible risque.
L2	La boucle peut effectuer de petites modifications avec un vérificateur et une revue humaine.	Utile une fois que l’équipe fait confiance à la sortie de la boucle.
L3	La boucle peut s’exécuter sur de plus longues périodes avec une exécution limitée sans surveillance.	Convient uniquement lorsque le périmètre, la sécurité, le coût et la vérification sont matures.

Un bon premier objectif n’est pas l’autonomie complète. Un bon premier objectif est une boucle L1 fiable qui vous fournit des informations utiles sans

créant un travail de nettoyage supplémentaire.

Le processus standard d’une boucle

Une boucle complète suit une séquence claire. L’article original la décrivait comme un processus en huit étapes :

1. déclencheur planifié ;
2. tri des tâches ;
3. lecture de l’état actuel ;
4. création d’un espace de travail isolé ;
5. laisser l’agent exécuter la tâche ;
6. exécuter les contrôles de vérification ;
7. se connecter à Git ou aux systèmes de tickets ;
8. demander une confirmation humaine si nécessaire.

C’est la principale différence entre un prompt occasionnel et une véritable boucle. L’agent ne se contente pas de « faire des choses ». Il travaille dans un processus contrôlé, avec état, isolation, contrôles et transfert.

Andrew Ng : le développement produit a besoin de trois boucles

L’article original reliait également le Loop Engineering à la réflexion d’Andrew Ng sur le développement produit. L’idée essentielle est que construire un logiciel avec l’IA ne repose pas sur une seule boucle. Pour un vrai produit, plusieurs boucles avancent à des vitesses différentes.

1. Boucle de codage agentique

La boucle la plus interne est la boucle de codage. Un humain fournit à l’agent une spécification produit et des critères d’évaluation. L’agent écrit du code, le teste, corrige les problèmes et continue d’itérer.

Cette boucle peut être rapide. Dans certains cas, elle peut produire une nouvelle version toutes les quelques minutes.

2. Boucle de retour développeur

La couche suivante est la boucle de retour développeur. L’agent peut tester et réviser, mais le développeur vérifie toujours si le résultat semble juste, s’il correspond à l’orientation du produit et s’il résout le véritable problème de l’utilisateur.

Cette boucle est plus lente. Elle peut s’exécuter toutes les quelques dizaines de minutes ou toutes les quelques heures, selon le produit et la complexité des changements.

3. Boucle de retour externe

La couche externe est la boucle de retour utilisateur. Une fois que le produit atteint des amis, des testeurs alpha ou de vrais utilisateurs, l’équipe commence à apprendre à partir des retours, des données d’utilisation et des expérimentations.

Cette boucle est encore plus lente. Elle peut prendre des heures, des jours ou des semaines.

Ensemble, les trois boucles créent une chaîne pratique de construction produit : l’agent aide à produire rapidement des versions, le développeur décide ce que le produit doit devenir, et les utilisateurs prouvent si la direction mérite d’être poursuivie.

Pourquoi le goût humain compte toujours

Le Loop Engineering ne retire pas les humains du développement logiciel. Il transforme leur rôle.

L’agent peut gérer l’exécution répétée, mais il a toujours besoin de limites claires, d’une vérification solide et d’un jugement produit. L’humain comprend toujours le contexte : ce dont les utilisateurs ont besoin, quels compromis comptent, ce qui ne devrait pas être automatisé et ce que signifie réellement « suffisamment bon ».

C’est pourquoi une boucle peut être installée avec une seule commande, mais la définition de « terminé » appartient toujours aux personnes qui construisent le produit.

Note sur la source

Source originale : article de BAAI Hub, syndiqué depuis QbitAI / WeChat. L’article faisait également référence au dépôt GitHub Loop Engineering et à la publication publique d’Andrew Ng sur X.

Note sur les images : l’image mème d’ouverture et la bannière promotionnelle finale avec QR code/contact de la page source ont été exclues, car elles ne sont pas nécessaires à la compréhension du tutoriel. Les images restantes ne sont incluses que lorsqu’elles appuient l’explication technique.

FAQ

Qu’est-ce que le Loop Engineering ?

Le Loop Engineering est une manière de concevoir des workflows répétables pour les agents d’IA. Au lieu de solliciter manuellement l’agent pour chaque petite tâche, vous définissez une boucle avec planification, état, outils, vérification et transfert vers un humain.

Comment démarrer un projet de Loop Engineering ?

Le point de départ le plus rapide consiste à exécuter npx @cobusgreyling/loop-init . --pattern daily-triage --tool claude dans un projet Git. Pour les débutants, daily-triage est généralement plus sûr que les boucles à haute fréquence, car il peut commencer en mode rapport uniquement.

Pourquoi le Loop Engineering utilise-t-il STATE.md ?

STATE.md fournit à la boucle une mémoire durable en dehors de la session de chat. Il aide la boucle à se souvenir des constats précédents, des dernières actions, des éléments non résolus et des décisions humaines qui prévalent.

Qu’est-ce que le score Loop Ready ?

Le score Loop Ready est un résultat d’audit produit par loop-audit. Il vérifie si le projet dispose d’une structure, d’un état, d’une vérification, de limites de coûts et de contrôles de sécurité suffisants pour exécuter une boucle de manière responsable.

Une boucle d’agent IA peut-elle s’exécuter sans surveillance ?

Il

c’est possible, mais il ne faut pas commencer ainsi. Une approche plus sûre consiste à passer d’abord par le niveau L1 en mode rapport uniquement, puis par le niveau L2 avec des corrections assistées et vérification, et seulement plus tard par le niveau L3 avec des exécutions sans supervision, lorsque le périmètre, la sécurité et les contrôles de coûts sont suffisamment matures.

Pourquoi devrais-je estimer le coût en tokens avant d’exécuter une boucle ?

Les boucles peuvent devenir coûteuses si elles s’exécutent souvent, utilisent un contexte long ou lancent plusieurs sous-agents. loop-cost vous aide à estimer l’utilisation avant qu’un workflow à haute fréquence ne consomme votre budget.

Quel est le lien avec l’idée des trois boucles d’Andrew Ng ?

La boucle d’ingénierie aide les agents à construire et réviser rapidement des logiciels. Les retours des développeurs et des utilisateurs constituent des boucles plus lentes qui déterminent si le produit est utile, utilisable et mérite d’être poursuivi.

Outils associés

• Loop Engineering : modèles open source, starters et outils CLI pour concevoir des boucles d’agents IA.
• Loop Engineering Showcase : aperçu interactif avec des modèles, des primitives et un simulateur de préparation.
• Node.js : environnement d’exécution nécessaire pour utiliser les outils CLI basés sur npx.
• npm : écosystème de packages utilisé pour exécuter les commandes CLI de Loop Engineering via npx.
• Git : système de contrôle de version utilisé pour les dépôts et l’exécution isolée basée sur les worktrees.
• GitHub Actions : plateforme d’automatisation pouvant prendre en charge les vérifications planifiées et les workflows de validation de boucles.
• Model Context Protocol : protocole permettant de connecter des systèmes d’IA à des outils et sources de données externes.

Liens associés

• Article original du BAAI Hub : article source présentant le tutoriel Loop Engineering adapté aux débutants.
• Dépôt GitHub de Loop Engineering : dépôt principal pour les modèles, starters, documents et outils CLI.
• Loop Engineering Showcase : page interactive officielle pour explorer le framework.
• Five Primitives + Memory : explication officielle des éléments de base des boucles.
• Loop Design Checklist : liste de contrôle pour décider si une boucle est prête pour une utilisation en production.
• Loop Safety Guide : notes de sécurité concernant l’automatisation, les chemins en liste de refus, la revue humaine et la gestion des risques.
• Operating Loops : notes sur les coûts, la journalisation, l’historique des exécutions et la discipline opérationnelle.
• Loop Patterns README : aperçu des modèles de boucles de production disponibles.

Résumé

Ce guide explique comment Loop Engineering transforme des prompts d’IA ponctuels en workflows d’agents reproductibles. L’idée de base consiste à définir la planification, l’état, les outils, la vérification et le processus de revue humaine avant de faire confiance à un agent pour agir de manière répétée.

Pour une première exécution, daily-triage est le point de départ le plus sûr. Créez la structure de la boucle, estimez le coût en tokens, auditez son niveau de préparation et gardez la première semaine en mode rapport uniquement.

La leçon plus générale n’est pas que les humains disparaissent du développement. Les agents peuvent avancer plus vite au sein de boucles, mais le jugement produit, les limites de sécurité et la définition de ce qui est « terminé » dépendent toujours des personnes.

La meilleure première boucle n’est pas la plus autonome. C’est celle que vous pouvez inspecter, à laquelle vous pouvez faire confiance et que vous pouvez améliorer.