Ingénierie des boucles

Loop Engineering est un nouveau concept qui s'est rapidement répandu dans la communauté de la programmation en IA en juin 2026. Il a été systématiquement organisé par l'ingénieur Google Addy Osmani, et le responsable d'Anthropic Claude Code Boris Cherny ainsi que le développeur Peter Steinberger ont tous deux publiquement avancé le même point de vue.

Cet article vous guidera de zéro pour comprendre ce qu'est le Loop Engineering, ses différences essentielles avec le Prompt Engineering, les six éléments clés qui constituent un Agent Loop complet, et comment concevoir votre première Loop exécutable.

L'évolution de l'ingénierie de l'IA

Au cours des deux dernières années, le centre d'intérêt du développement de l'IA n'a cessé de se déplacer : de la recherche sur la manière d'écrire de bons prompts, en évoluant progressivement vers l'organisation du contexte et l'orchestration des outils et des workflows (Harness), puis vers la construction de systèmes de boucle (Loop) capables de fonctionner de manière autonome et de produire des résultats en continu.

Prompt:怎么问 AI
↓
Context:给 AI 什么信息
↓
Harness:如何组织 AI 的能力
↓
Loop:如何让 AI 持续创造结果

Étape d'ingénierie Idée centrale Focus Contenu d'entrée Capacité de l'IA Rôle humain Scénario typique
Ingénierie de prompt Obtenir de meilleurs résultats en concevant des prompts Comment poser des questions Prompt / Instruction Génération à tour unique Questionneur Chat, rédaction, génération de code
Ingénierie du contexte Organiser et fournir des informations contextuelles complètes Quelles informations donner à l'IA Base de connaissances, historique, contraintes, contexte Compréhension du contexte Organisateur d'informations RAG, recherche IA, assistant de code
Ingénierie de harnais (Ingénierie d'orchestration) Connecter les modèles, les outils et les données pour former des flux de travail Comment invoquer des capacités Contexte + API + chaîne d'outils Exécuter des tâches Concepteur de système Agent, processus automatisés, collaboration multi-outils
Ingénierie des boucles Construire des systèmes autonomes en boucle fermée pilotés par objectifs Comment accomplir des objectifs en continu Objectifs, état, mémoire, mécanismes de vérification Planifier → Exécuter → Vérifier → Corriger → Exécuter en continu Créateur de règles Claude Code, programmation IA, opérations automatisées, employés IA

Les origines de l'ingénierie des boucles

Le Loop Engineering a émergé à un moment précis : juin 2026.

Le point de bascule : deux phrases, des millions de partages

Début juin 2026, le responsable de Claude Code chez AnthropicBoris Chernya déclaré dans un discours public :

« Je ne prompte plus Claude. J’ai des boucles qui tournent. Ce sont elles qui promptent Claude et déterminent quoi faire. Mon travail consiste à écrire des boucles. »
(Je ne prompte plus Claude directement. J’ai un ensemble de Loops qui tournent, qui promptent Claude et décident quoi faire ensuite. Mon travail consiste à écrire des Loops.)

Quelques jours plus tard, le 7 juin 2026, le développeurPeter Steinberger—créateur du projet open source d’Agent IA OpenClaw (le nouveau dépôt le plus rapidement étoilé de l’histoire de GitHub)—a publié un tweet de douze caractères :

« Vous ne devriez plus prompter les agents de codage. Vous devriez concevoir des boucles qui promptent vos agents. »
(Vous ne devriez plus prompter manuellement les assistants de codage IA. Vous devriez concevoir des Loops qui permettent aux Agents de se prompter eux-mêmes.)

  • Le Prompt Engineeringconsiste à « apprendre à l’IA comment faire les choses »
  • Le Loop Engineeringconsiste à « concevoir un système où l’IA fait continuellement les choses elle-même »

Ces deux phrases ont déclenché d’énormes discussions dans la communauté des développeurs IA parce qu’elles décrivaient précisément une tendance que beaucoup avaient ressentie mais pas encore nommée :La qualité de rédaction des prompts n’est plus le goulot d’étranglement ; le goulot d’étranglement réside dans l’ensemble du système d’exécution que vous concevez pour l’Agent.。

Par la suite, Addy Osmani a publié un long article sur Substack, nommant et systématisant formellement cette pratique sous le nom deLoop Engineering, ce qui en fait une discipline d’ingénierie indépendante.

Contexte : trois générations d'outils de programmation IA

Loop Engineering ne vient pas de nulle part ; c'est le résultat naturel de l'évolution des capacités des outils de programmation IA.

ÉtapeOutil représentatifMéthode de travailGoulot d'étranglement
Première génération : auto-complétionPremières versions de GitHub CopilotComplète la ligne ou la fonction en cours ; les humains prennent toutes les décisionsNe peut qu'assister, ne peut pas agir de manière autonome
Deuxième génération : conversationnelleChatGPT、Claude.aiPoser une question, obtenir une réponse ; les humains font avancer chaque étape manuellementLes humains deviennent le goulot d'étranglement ; la vitesse est limitée par la vitesse de frappe
Troisième génération : boucle autonome d'AgentClaude Code、OpenAI Codex AgentL'Agent planifie, exécute, vérifie et itère de manière autonome en boucle jusqu'à l'achèvementComment concevoir un système qui permet aux Loops de fonctionner de manière fiable

L'émergence des outils de troisième génération signifie que la compétence fondamentale d'un ingénieur est passée de l'écriture de prompts à la conception de Loops.


Qu'est-ce que le Loop Engineering

Le Loop Engineering est la pratique d'ingénierie consistant à concevoir, exploiter et améliorer en continu des boucles de rétroaction qui permettent aux Agents de codage IA de planifier, d'exécuter des modifications de code, d'observer les résultats et d'accomplir des tâches de manière autonome sur plusieurs itérations.

En une phrase :

Le Loop Engineering vous transforme de « la personne qui prompte l'Agent » en « l'ingénieur qui conçoit le système qui prompte l'Agent ».

Qu'est-ce qu'une Loop

Une Loop est un système d'objectif récursif : vous définissez un but, et l'Agent itère jusqu'à ce que le travail soit véritablement terminé.

Chaque Agent possède déjà une "boucle interne" intégrée lorsqu'il exécute des tâches : Percevoir → Raisonner → Agir → Observer, puis boucler à nouveau.

L'ingénierie des boucles opère auniveau juste au-dessus:

coucheQui piloteCe qui est fait
Boucle interne (intégrée à l'Agent)L'Agent lui-mêmeLire le fichier → modifier le code → exécuter les tests → lire les erreurs → modifier à nouveau
Boucle externe (conçue par vous)Le système que vous concevezDécouvrir les tâches selon le plan → répartir les Agents → vérifier les résultats → enregistrer l'état → démarrer le tour suivant

Vous ne restez plus assis à côté de l'Agent à taper une commande à chaque étape. Vous concevez un système externe qui pilote la boucle interne à votre place, pendant que vous faites les choses qui demandent plus de jugement.

La différence entre l'ingénierie de boucle et l'ingénierie de prompt

DimensionIngénierie de promptIngénierie des boucles
Objectif d'optimisationUne seule instruction que vous écrivez à la mainL'ensemble du système qui décide automatiquement « quoi demander, quand le demander, et si le résultat est acceptable »
Unité de travailUn tour de conversation que vous saisissez manuellementUn flux de travail complet qui s'étend sur plusieurs tours et s'exécute automatiquement
Mesure du succèsQualité de la première réponseQualité de la sortie finale
Mode d'échecLe modèle donne une mauvaise réponseLa boucle du système est mal conçue : la boucle s'arrête trop tôt, ignore les signaux d'erreur, ou ne peut pas vérifier l'achèvement
Perspective sur l'AgentUn outil que vous tenezUn processus de longue durée que vous planifiez

L'ingénierie des prompts n'est pas morte. Une boucle est composée de plusieurs prompts, et des prompts mal écrits placés dans une boucle ne produisent qu'un mauvais travail plus rapidement. L'ingénierie des boucles est une couche au-dessus de l'ingénierie des prompts, et non un remplacement.

La pile technique complète à trois couches :

CoucheCe qui est optimiséUnité de travail
Ingénierie de promptComment formuler une seule instructionUne seule conversation que vous tapez manuellement
Ingénierie du contexteQuel contenu entre dans la fenêtre de contexte : documents, historique, définitions d'outilsLes conditions environnementales entourant une seule réponse
Ingénierie des bouclesUn système autonome qui décide ce qu'il faut prompter, quand le prompter, et si les résultats sont acceptablesDes flux de travail automatisés couvrant plusieurs boucles internes

La boucle principale

La structure fondamentale d'une boucle d'Agent se compose de cinq étapes connectées de bout en bout, itérant en continu.

ÉtapeNom anglaisCe qu’il faitSources de signaux typiques
IntentionIntentionDéfinir le résultat cible : à quoi ressemble le succès, quelles sont les contraintesDéveloppeur ou système externe (Issue, rapport CI)
ContexteContexteRassembler le code, la documentation, les logs d'erreur et les conventions pertinentsBase de code, sortie de test, historique de conversation
ActionActionModifier des fichiers, exécuter des commandes, appeler des outils, rédiger des plansL'agent exécute de manière autonome
ObservationObservationObtenir les résultats des tests, les erreurs de compilation, la sortie d'exécution, les diffs de codeFramework de test, vérificateur de types, CI, revue humaine
AjustementAjustementMettre à jour le plan en fonction des observations, répéter la boucle jusqu'à ce que la tâche soit terminée ou bloquéeProchain tour de la boucle interne

Le pouvoir d'une boucle ne réside pas dans une étape unique, mais dans laboucle fermée. Un échec de test n'est pas seulement un message d'erreur ; c'est un nouveau contexte. Une erreur de type n'est pas seulement un blocage ; c'est un signal concernant une hypothèse erronée. Un commentaire de revue de code n'est pas seulement un retour ; c'est une nouvelle observation qui guide l'action suivante.


Six composants essentiels

Une boucle qui peut vraiment fonctionner de manière indépendante nécessite cinq composants essentiels, plus un système de mémoire qui fonctionne en continu. Aucun ne doit manquer.

Composant 1 : Automatisations

Les automatisations sont le battement de cœur d'une boucle. Sans déclenchement automatique, une boucle n'est qu'« une opération que vous avez effectuée une fois », et non un véritable cycle.

Les déclencheurs définissent :Quand ? Faire quoi ?

Dans Claude Code, utilisez/loopla commande pour créer une boucle planifiée :

Exemple

# Exécuter chaque jour ouvré à 9 AM : lire les échecs CI et les Issues d'hier,
# Écrire les conclusions dans TODO.md, et rédiger des correctifs pour les problèmes marqués comme quick-win
/loop "Lire les échecs CI et les issues ouvertes d'hier, écrire les conclusions \
      dans TODO.md, et rédiger des correctifs pour tout ce qui est étiqueté quick-win"
\
       --schedule "0 9 * * 1-5"

# /goal: exécuter jusqu'à ce qu'une condition vérifiable soit remplie
# La commande suivante continuera de s'exécuter jusqu'à ce que tous les tests du module auth réussissent et que le lint soit propre
/goal "Tous les tests dans test/auth réussissent et le lint est propre"

Dans OpenAI Codex, Automations dispose d'un panneau UI dédié où vous pouvez définir le projet, le prompt, la cadence, et choisir d'exécuter dans un checkout local ou dans un Worktree en arrière-plan. Les exécutions qui trouvent du contenu vont dans une boîte de réception Triage ; celles qui ne trouvent rien sont archivées automatiquement.

Avertissement sur le coût en tokens :Les Loops planifiées avec des sous-agents de vérification consomment des tokens à chaque déclenchement, et la consommation varie considérablement selon la complexité de la tâche. Il est recommandé de commencer avec une cadence plus lente (par ex., une fois par jour), d'observer les coûts pendant quelques jours, puis d'augmenter la fréquence.

Composant 2 : Isolation parallèle (Worktrees)

Lorsque vous exécutez plusieurs agents en même temps, les conflits de fichiers sont la source de problèmes la plus probable. Deux agents écrivant simultanément dans le même fichier, c'est comme deux ingénieurs qui committent sur la même ligne de code — le résultat est catastrophique.

Git Worktreeest la solution : donnez à chaque Agent son propre répertoire de travail, travaillez sur des branches séparées, partagez le même historique Git, mais gardez les modifications de fichiers complètement isolées.

Exemple

# Créer manuellement un worktree (Claude Code et Codex prennent tous deux en charge la gestion automatique)
git worktree add ../agent-fix-auth feature/fix-auth-tests
git worktree add ../agent-upgrade-deps feature/upgrade-axios

# Dans Claude Code, configurez l'isolation worktree pour les sous-agents
# Ajoutez au frontmatter de .claude/agents/reviewer.md :
# isolation: worktree → chaque Agent obtient un checkout indépendant, nettoyé automatiquement une fois terminé

Les Worktrees éliminent les conflits mécaniques de fichiers, mais ils ne peuvent pas éliminerle goulot d'étranglement de la revue. La vitesse à laquelle vous traitez et approuvez les modifications de code est le véritable plafond du nombre d'Agents que vous pouvez exécuter en parallèle, et non le nombre de Worktrees que l'outil peut ouvrir.

Composant 3 : Fichiers de compétences

Les compétences (fichiers de compétences) répondent à un coût gaspillé à chaque fois :À chaque nouvelle conversation, l'Agent doit déduire les conventions de votre projet à partir de zéro。

Une compétence est un paquet contenantSKILL.mdLe dossier de fichiers, qui documente les conventions du projet, les étapes de build et des connaissances comme « on ne fait pas ça de cette façon à cause de cet incident ». L'Agent charge la compétence au début de chaque session au lieu de deviner à nouveau à chaque fois.

Exemple

<!-- Chemin du fichier : .claude/skills/project-conventions/SKILL.md -->
---
name
: project-conventions
description
: Normes de codage du projet et étapes de build. Toute tâche impliquant des modifications de code doit charger cette compétence.
---

## Stack technique
- Back-end : Node.js20 + TypeScript 5.4 + Fastify
- Base de données : PostgreSQL16, l'ORM utilise Drizzle
- Tests : Vitest, les fichiers de test placés sous __tests__/ au même niveau que src/

## Commandes de build
- Installer les dépendances : pnpm install
- Lancer les tests : pnpm test
- Vérification des types : pnpm typecheck
- Générer les artefacts : pnpm build

## Conventions de base
- Toutes les requêtes de base de données doivent passer par des fonctions d'encapsulation dans src/db/queries/ ; écrire directement du SQL brut dans la couche métier est interdit
- Utiliser uniformément la classe AppError pour les erreurs (src/errors/AppError.ts) ; il est interdit de lever des chaînes nues
- Nommage des fichiers de route API :{resource}.routes.ts, placé dans src/routes/
- Les nouvelles API doivent également mettre à jour docs/api.md

## Interdictions
- Ne pas modifier directement les fichiers de migration historiques dans le répertoire migrations/
- Ne pas committer de vrais secrets dans le fichier .env ; utiliser .env.example comme espace réservé

Composant 4 : Connecteurs / MCP

Une Boucle qui ne peut voir que le système de fichiers local peut faire très peu de choses. Les connecteurs (basés sur MCP—Model Context Protocol) permettent à l'Agent de lire des gestionnaires de tickets, d'interroger des bases de données, d'appeler des API et d'envoyer des messages dans Slack.

C'est la différence fondamentale entre « l'Agent disant 'voici le correctif' » et « la Boucle ouvrant automatiquement une PR, liant le ticket et notifiant le canal après la réussite de la CI ».

Claude Code et OpenAI Codex prennent tous deux en charge nativement le protocole MCP, et les connecteurs écrits pour un outil peuvent généralement être utilisés dans les deux.

Exemple : Configuration des connecteurs MCP dans Claude Code

// Chemin du fichier : .claude/mcp.json
// Configurez les connecteurs MCP afin que l'Agent puisse utiliser GitHub et envoyer des notifications Slack
{
  "connectors": [
    {
      "name": "github",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    {
      "name": "slack",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}"
      }
    }
  ]
}

Connecter des connecteurs à l'Agent signifie qu'il peut effectuer de véritables actions dans des environnements réels. Chaque connecteur doit être configuré avec le moindre privilège, et les opérations à haut risque (pousser du code, fusionner des PR, envoyer des notifications externes) doivent exiger une approbation humaine ; elles ne peuvent pas être exécutées de manière entièrement automatique.

Composant 5 : Sous-agents

L'une des décisions architecturales les plus importantes de la Boucle :Séparer l'Agent qui écrit le code de l'Agent qui vérifie le code。

Le modèle qui a écrit le code est trop indulgent lorsqu'il évalue son propre travail. Un vérificateur indépendant avec des instructions différentes—parfois en utilisant un modèle différent—peut détecter des problèmes que le premier Agent a rationalisés.

Ce modèle "Maker-Checker" est également appliqué à la condition d'arrêt de la Boucle : de Claude Code/goalla commande utilise un modèle séparé après chaque itération pour juger si elle est "terminée", plutôt que de laisser le modèle qui a fait le travail prendre cette décision.

Exemple : Définition d'un sous-agent réviseur

<!-- Chemin du fichier : .claude/agents/spec-reviewer.md -->
---
name
: spec-reviewer
description
: Réviser de manière adversariale les modifications de code terminées pour vérifier qu'elles répondent aux spécifications et aux exigences de test.
model
: opus            # Utiliser un modèle plus puissant comme vérificateur
isolation
: worktree    # Extraire indépendamment pour éviter de polluer l'espace de travail du créateur
---

Vous êtes un relecteur de code adversarial. Votre travail n'est pas d'approuver, mais de remettre en question.

Après avoir reçu un diff, vous devez :
1. Exécuter la suite de tests complète (pnpm test), consigner les échecs
2. Exécuter la vérification de types (pnpm typecheck)
3. Vérifier le diff par rapport aux spécifications du projet dans SKILL.md
4. Vérifier que les changements de comportement visibles par l'utilisateur répondent aux exigences d'origine

N'affichez APPROVED que lorsque tous les tests passent, que la vérification de types est propre et qu'il n'y a aucune violation des spécifications.
Sinon, indiquez des raisons de rejet précises ; ne donnez pas de retour vague.

Composant 6 : Mémoire persistante

La mémoire est le pilier central de toute Loop capable de fonctionner de manière persistante d'une conversation à l'autre.

Le modèle oublie complètement entre les conversations. Sans mémoire externe, chaque fois que la Loop se déclenche, l'Agent repart de zéro, sans savoir ce qui a été fait hier, quels correctifs ont été fusionnés et quelles tâches sont encore ouvertes.

La solution est extrêmement simple :Écrivez l'état dans des fichiers, et conservez les fichiers dans le dépôt.. Le dépôt se souvient même si le modèle ne le fait pas.

Exemple : Fichier d'état de Loop

<!-- Chemin du fichier : TODO.md (fichier d'état de Loop, commité avec le code) -->
# Statut de la tâche Loop

Dernière mise à jour :2026-06-1409:03 UTC (mise à jour par Loop automatique)

## En cours
- [ ]Test instable dans test/auth/login.spec.ts (Exécution CI#4821, a échoué 3 fois)
- Hypothèse : fuite d'état de session entre tests concurrents
- Essayé : isoler la connexion à la base de données de test → inefficace
- Étape suivante : vérifier la logique de nettoyage dans beforeEach

## En attente
- [ ]Mettre à jour axios vers1.7.x (vulnérabilité de sécurité CVE-2026-xxxxx)
- [ ]Mise à jour de la documentation API (la PR#308 est en retard par rapport au code après la fusion)

## Terminé
- [x]Correction du [problème] du module de facturation causé par des noms d'entreprise contenant des guillemets simples500erreur (PR#312, fusionnée)
- [x]Mettre à niveau la version de Node.js vers20.x(PR #307, fusionnée)

Cinq modèles de boucle courants

Différents types de tâches nécessitent différents signaux de rétroaction et conditions d'arrêt, c'est pourquoi plusieurs modèles de boucle classiques ont émergé.

ModèleSignal d'observation principalCondition d'arrêtScénario typique
Boucle pilotée par les testsRéussite / échec du testTous les tests cibles réussissentCorrections de bugs, tests de régression, logique de transformation de données
Boucle pilotée par le compilateurErreurs de type, liste d'erreurs de compilationZéro erreur de vérification de typeMigration TypeScript, mises à niveau des dépendances, refactorisation
Boucle pilotée par la revueCommentaires de revue humaineTous les commentaires traités ou documentés comme ignorésSuivi mécanique des revues de PR
Boucle de débogage à l'exécutionJournaux, traces de pile, réponses HTTPReproduire le problème → formuler une hypothèse → vérifier le correctifBugs de production, problèmes de performance, exceptions d'API
Boucle d'itération produitCaptures d'écran, vérifications du navigateur, rapports d'accessibilitéAligné avec les maquettes de design, responsive correct, aucune violation des spécificationsPages de destination, ajustements d'interface utilisateur, composants marketing

Construire votre première boucle

N'essayez pas de construire une boucle entièrement automatisée et multi-agent qui fusionne automatiquement les PR dès le départ. Commencez par la plus petite boucle utilisable, comprenez son comportement, puis développez-la progressivement.

Étape 1 : Commencez par une tâche étroite

Plus la tâche est étroite, plus l'Agent sait clairement quels fichiers sont importants et quels signaux de validation sont pertinents.

Mauvaise définition de tâcheBonne définition de tâche
"Optimiser les performances du tableau de bord""Réduire de 30 % le temps de chargement initial du tableau de bord en différant le chargement des graphiques non critiques tout en maintenant le fonctionnement des filtres existants"
"Corriger les problèmes de paiement""Corriger le test de calcul de taxe qui échoue dans test/checkout/tax.spec.ts"
"Améliorer la page des paramètres""Corriger le problème de mise en page où le bouton de suppression de compte est tronqué sur mobile (largeur 375px)"

Étape 2 : Spécifier clairement la méthode de vérification

La Boucle doit savoir ce que signifie "terminé". Si vous connaissez la commande de vérification, écrivez-la directement dans les instructions.

Exemple : Instructions de boucle avec conditions de vérification

# Mauvais : aucune condition de vérification, l'Agent ne sait pas quand s'arrêter
/goal "Corriger le bug d'authentification"

# Bon : a des commandes de vérification spécifiques et des critères de succès
/goal "Corriger la fuite de session causant des tests instables dans test/auth/login.spec.ts.
       Condition de succès : exécuter 'pnpm test test/auth/login.spec.ts' 5 fois
       consécutivement sans aucun échec. Ne touchez pas aux autres fichiers de test."

Étape 3 : Mettre en place des mécanismes de sécurité

Avant que la Boucle puisse ouvrir automatiquement des PR, faites en sorte qu'elle écrive uniquement des fichiers et n'effectue aucune action externe ; vous examinez le diff et décidez s'il faut commiter.

Exemple : Boucle de triage quotidien des échecs CI (version minimale sûre)

# Voici la première Boucle recommandée :
# - Opérations en lecture seule (lire les logs CI, lire les Issues)
# - Écrire uniquement TODO.md (ne toucher aucun autre fichier)
# - Aucune PR, aucune fusion de code
# - Vous consultez TODO.md chaque matin et décidez manuellement de l'étape suivante

/loop "Lire les logs d'échec CI d'hier et les Issues GitHub étiquetées 'bug'.
       Catégorisez les résultats par cause probable.
       Écrivez un résumé avec des éléments d'action priorisés dans TODO.md.
       Ne modifiez AUCUN fichier source. N'ouvrez aucune PR."
\
       --schedule "0 8 * * 1-5"

Cette version minimale de la Loop est déjà précieuse : elle organise pour vous la liste des problèmes de la veille chaque matin, et lorsque vous arrivez au bureau, vous pouvez ouvrir TODO.md et savoir quoi faire aujourd'hui au lieu de passer une demi-heure à fouiller dans les journaux CI. C'est le meilleur point de départ pour comprendre le comportement de la Loop, avec un risque quasi nul.

Étape 4 : Augmenter progressivement l'autonomie

ÉtapeCe que la Loop peut faireCe que l'humain fait
Phase 1 (lecture seule)Détecter les problèmes, trier les tâches, écrire des fichiers d'étatExaminer TODO.md, décider manuellement de l'ordre de traitement
Phase 2 (brouillon)Rédiger des correctifs, exécuter les tests, écrire dans une brancheExaminer le diff, exécuter manuellement git push
Phase 3 (semi-automatique)Ouvrir une PR en brouillon, lancer la CI, notifier SlackExaminer la PR, cliquer manuellement sur Merge
Étape 4 (entièrement automatique)Agents doubles Producteur + Réviseur, fusion automatique après réussite de la CIIntervention humaine en cas d'anomalie, audit périodique de l'historique des fusions

Trois risques majeurs de l'ingénierie Loop

La Loop change votre façon de travailler, mais n'élimine pas la responsabilité de l'ingénieur. Trois problèmes deviennent plus graves à mesure que la Loop s'améliore, et non plus faciles.

Risque 1 : la vérification reste votre responsabilité

Une Loop qui fonctionne sans surveillance est aussi une Loop qui commet des erreurs sans surveillance. Mettre en place un sous-agent réviseur est un bon moyen de réduire le risque, mais « vérification réussie » est une affirmation, pas une preuve.

Peu importe la fiabilité de la Loop, la revue humaine du code fusionné ne peut pas disparaître.

Risque 2 : la dette de compréhension s'accumule plus vite

Plus la Loop produit du code rapidement, plus la proportion de code que vous comprenez réellement est faible. Ce n'est pas un problème propre à la programmation par IA, mais la Loop l'a accéléré.

Le seul antidote est :Lisez le code que Loop produitNe cessez pas de comprendre ce que fait Loop simplement parce que Loop fonctionne bien.

Risque 3 : Capitulation cognitive

Lorsque Loop s'exécute automatiquement, accepter quel que soit le résultat qu'il renvoie est le choix le plus confortable. C'est le danger le plus caché de l'ingénierie Loop.

Deux personnes peuvent construire exactement le même Loop et pourtant obtenir des résultats complètement opposés : l'une l'utilise pour avancer plus vite sur la base d'une compréhension profonde, l'autre l'utilise pour éviter le travail de la compréhension elle-même. Loop ne connaît pas la différence. Vous, si.

Quatre types de modes de défaillance de Loop et leurs contre-mesures :

Mode d'échecSymptômesCause racineSolution
ThrashingL'agent modifie le code de manière répétée, mais ne converge pasObjectifs flous, signaux de vérification bruités, ou portée de chaque modification trop grandeRéduisez la portée de l'objectif, réduisez la taille de chaque diff, utilisez des commandes de vérification plus fiables
Surapprentissage des testsTous les tests passent, mais la fonctionnalité est en réalité incorrecteLa couverture de tests est trop étroite, les scénarios utilisateur réels ne sont pas vérifiésCombinez les tests automatisés avec des vérifications d'acceptation manuelles, ajoutez des tests de bout en bout
Dérive du contexteL'agent continue de travailler sur la base d'hypothèses obsolètes, en ignorant les changements nouvellement apparusLe contexte n'est pas actualisé après des observations clésAprès des observations importantes, recollectez le contexte ; ne considérez pas le plan initial comme sacré
Autonomie dangereuseL'agent effectue des opérations destructrices sans autorisationPérimètre d'autorisation trop large, sans conditions d'arrêt clairesPrincipe du moindre privilège ; les opérations à haut risque nécessitent une approbation humaine ; définissez des règles d'arrêt claires

Résumé des bonnes pratiques

Les éléments suivants sont des principes fondamentaux pour construire des Loops fiables ; chacun correspond à une classe courante de défaillance.

PrincipesPratiques spécifiques
Commencer par des tâches cibléesNe définissez qu’un seul objectif clairement délimité à la fois ; des objectifs larges empêchent l’Agent de déterminer quels fichiers et quels signaux de validation sont pertinents.
Indiquez à l’Agent comment validerÉcrivez la commande de validation directement dans les instructions (pnpm test test/auth), les scénarios d’acceptation, ou les points de terminaison d’API, rendant la « complétion » mesurable
Privilégiez les petites modifications réversiblesExigez de l’Agent qu’il effectue la plus petite modification cohérente, exécute la validation, puis élargisse ; les réécritures spéculatives à grande échelle rendent difficile de déterminer quelle hypothèse était erronée.
Respectez les modèles de code existantsDemandez à l’Agent d’inspecter d’abord les implémentations adjacentes, de réutiliser les composants existants, de suivre les conventions de nommage existantes et d’éviter d’introduire de nouvelles abstractions inutiles.
Garder les humains au poste de jugementL'Agent se charge de la collecte de preuves et des corrections mécaniques ; le jugement produit, les décisions d'architecture et la revue finale restent du ressort des humains
Codifier les boucles réutilisablesLorsqu'une boucle fonctionne bien, transformez-la en fichier Skill ou en déclencheur standardisé afin de réduire les coûts de répétition futurs
Autres extensions