Boucle de relecture (Review Loop)
Cycle itératif travailleur-relecteur au sein d’une session unique. Vous effectuez le travail, vous générez un sous-agent relecteur pour le critiquer, vous révisez en fonction des retours, et vous répétez jusqu’à atteindre le seuil de qualité.
Principe fondamental : Les premières versions ne sont jamais définitives. La critique itérative produit de meilleurs résultats qu’un seul passage.
Note sur les plateformes : Cette compétence fonctionne mieux avec des agents qui prennent en charge le spawning de sous-agents. Sur les plateformes sans cette fonctionnalité, simulez l’étape de relecture en ouvrant un nouveau contexte de discussion, en collant uniquement le livrable (sans le raisonnement antérieur) et en demandant une note de 1 à 10 avec des retours spécifiques.
Prise en main rapide
- Dites : « implémente X, utilise review-loop » ou « exécute review-loop sur le fichier que je viens d’écrire »
- L’agent effectue le travail (ou lit le travail existant)
- Un sous-agent critique distinct le note de 1 à 10 avec des retours spécifiques
- L’agent révise et répète jusqu’à ce que la note soit >= 8 (seuil de qualité par défaut)
- Un récapitulatif de la boucle est fourni avec le résultat final
Quand l’utiliser
- L’utilisateur dit « utilise review-loop », « polish this », « iterate on this », « /review-loop »
- Implémentations complexes où la qualité prime sur la rapidité
- Documents de conception, spécifications ou écrits techniques
- Code devant être robuste (sécurité, pipelines de données, logique financière)
- Lorsque l’utilisateur souhaite une critique contradictoire intégrée au processus
Quand ne PAS l’utiliser
- Corrections simples, modifications rapides, changements d’une ligne
- Tâches où les tests sont le seuil de qualité (utilisez TDD + CI à la place)
- Lorsque l’utilisateur veut simplement que ce soit fait rapidement
- Travail exploratoire / d’investigation où l’objectif est d’apprendre, pas de livrer
- Tâches sans critères d’acceptation clairs – définissez-les d’abord, puis utilisez review-loop
Valeurs par défaut
| Réglage | Valeur par défaut |
|---|---|
| Boucles min | 2 |
| Boucles max | 4 |
| Seuil de qualité | 8/10 |
| Modèle travailleur | (votre modèle actuel) |
| Modèle relecteur | (votre modèle actuel ou alternative rapide/équilibré) |
Sélection du modèle
La tâche du relecteur évalue la logique et les contraintes. La tâche du travailleur écrit et modifie le code. Choisissez les capacités du sous-agent en conséquence.
RÈGLE CRITIQUE : Le relecteur doit toujours ÊTRE AU MOINS AUSSI PUISSANT que le travailleur. Si le relecteur est plus faible que le travailleur, il ne peut pas critiquer correctement une logique complexe ni détecter des régressions subtiles.
| Complexité de la tâche | Capacité du travailleur | Capacité du relecteur | Justification |
|---|---|---|---|
| Simple / mécanique (CRUD, formatage, code générique) | Rapide / Léger | Équilibré | Le travailleur léger est rapide, le relecteur équilibré détecte facilement les problèmes |
| Standard (fonctionnalités, refactorisations, documentation) | Équilibré | Équilibré | Bon compromis coût, rapidité et qualité |
| Complexe (multi-fichiers, intégration, conception) | Équilibré | Avancé / Raisonnement | Le relecteur avancé détecte les problèmes d’architecture subtils, le travailleur équilibré peut les implémenter |
| Très complexe (sécurité, quant, systèmes distribués) | Avancé / Raisonnement | Avancé / Raisonnement | Les deux ont besoin du contexte complet et de la puissance de raisonnement. Le relecteur DOIT égaler la puissance du travailleur. |
La règle d’or : Le travailleur doit être assez intelligent pour AGIR sur les retours du relecteur. Si le relecteur dit « corrigez la condition de concurrence avec un sémaphore basé sur un canal » et que le travailleur ne peut pas raisonner sur la concurrence, la boucle ne convergera pas.
Signal d’escalade : Si la note ne s’améliore pas après 2 boucles consécutives avec les mêmes retours, le modèle du travailleur est trop faible. Escaladez :
- Option A : Demandez à l’utilisateur de passer à un modèle plus performant
- Option B : Abaissez temporairement le seuil de qualité et notez l’écart pour l’utilisateur
- Option C : Divisez la tâche en sous-tâches plus petites et exécutez review-loop sur chacune
Comportement par défaut : Puisque vous (l’agent principal) ÊTES le travailleur, générez un sous-agent relecteur qui correspond ou dépasse votre capacité actuelle en fonction de la tâche :
- Tâches courantes → Relecteur Standard/Équilibré
- Tâches spécialisées/difficiles → Relecteur Avancé/Raisonnement
- Vérifications rapides → Relecteur Rapide/Léger (uniquement si vous agissez également en tant que travailleur léger)
Surcharges utilisateur
Les utilisateurs peuvent surcharger n’importe quelle valeur par défaut directement dans leur demande. Analysez-les naturellement :
« implémente X avec review-loop, seuil de qualité 9, utilise un modèle avancé pour la relecture, max 5 boucles »
« polish this, 2 boucles minimum, seuil à 8 »
« exécute review-loop avec relecteur rapide, max 2 boucles »
« utilise review-loop, relecteur raisonnement, seuil de qualité 9, min 3 max 6 »
Règles d’analyse :
- « seuil de qualité N » ou « gate N » → quality_gate = N
- « relecteur [modèle] » ou « relecture avec [modèle] » → substitution du modèle de relecteur
- « max N boucles » → max_loops = N
- « min N boucles » → min_loops = N
- Si l’utilisateur ne précise pas, utilisez les valeurs par défaut
- Si l’utilisateur dit « approfondi » ou « strict » → interprétez comme quality_gate 8, min_loops 2
- Si l’utilisateur dit « rapide » ou « vite » → interprétez comme max_loops 2, quality_gate 6
Le processus
flowchart TD
A[Effectuer le travail] --> B[Lancer le sous-agent relecteur]
B --> C{Boucles min atteintes ?}
C -- non, toujours continuer --> E[Réviser en fonction des retours]
C -- oui --> D{Note >= seuil de qualité ?}
D -- oui --> F[Passage de polissage final]
D -- non --> G{Boucles max atteintes ?}
G -- oui, arrêter quand même --> F
G -- non --> E
E --> B
F --> H([Terminé])
Pas à pas
Étape 1 : Effectuer le travail
Réalisez la tâche comme vous le feriez normalement. Écrivez le code, créez la spécification, implémentez la fonctionnalité. Ne vous retenez pas — produisez votre meilleure première version.
Étape 2 : Lancer le sous-agent relecteur
Utilisez l’outil Agent pour envoyer un relecteur. Le relecteur doit :
- Être un sous-agent séparé (contexte frais, sans ancrage à votre raisonnement)
- Ne recevoir que le livrable (fichiers, diffs) — pas votre processus de réflexion
- Noter de 1 à 10 avec des retours spécifiques et exploitables
- Utiliser par défaut un modèle équilibré/standard (ou un modèle de raisonnement avancé pour les tâches complexes/spécialisées)
Modèle de prompt du relecteur :
Vous êtes un relecteur critique. Notez le travail suivant de 1 à 10 et fournissez des retours spécifiques et exploitables.
## Ce qui a été fait
{brève description de la tâche}
## Critères de relecture
{critères spécifiques à la tâche — ce qui compte pour CETTE tâche}
Exemples de critères bien rédigés :
Pour un point de terminaison d’API REST :
- Codes de statut HTTP corrects utilisés
- Validation des entrées présente sur tous les paramètres
- Authentification appliquée ; pas d’accès non authentifié
- Pas de modèle de requête N+1
Pour un document de conception :
- L’énoncé du problème est sans ambiguïté
- Alternatives envisagées avec compromis
- Pas d’approximations sur la complexité de l’implémentation
- Les métriques de succès sont mesurables
Pour un pipeline de données :
- Idempotent — sûr à réexécuter
- Les changements de schéma sont gérés élégamment
- Modes de défaillance documentés
- Traitement des données personnelles abordé
## Instructions
1. Lisez attentivement le travail
2. Notez de 1 à 10 où :
- 1-3 : Fondamentalement cassé ou ne répond pas aux exigences majeures
- 4-6 : Fonctionne mais présente des problèmes significatifs
- 7-8 : Bon, seulement des problèmes mineurs
- 9-10 : Excellent, prêt à être livré
3. Listez les problèmes spécifiques avec les références fichier:ligne si applicable
4. Pour chaque problème, expliquez POURQUOI il compte et QUOI corriger
5. Ne soyez PAS poli — soyez honnête et direct
6. Indiquez clairement votre note comme « Note : N/10 »
## Fichiers à relire
{collez le contenu du fichier ou listez les chemins de fichiers avec les extraits pertinents}
Étape 3 : Analyser les retours
Extrayez de la réponse du relecteur :
- Note (le nombre)
- Problèmes (classés comme Critique / Important / Mineur)
- Corrections spécifiques (quoi modifier)
Signalez à l’utilisateur :
Boucle {N}/{max} : Note {X}/10
- {résumé des principaux points de retour}
Étape 4 : Vérifier les conditions d’arrêt
Dans cet ordre :
- Si boucles effectuées < min_loops → continuer (toujours)
- Si note >= seuil de qualité → arrêter, passer au polissage final
- Si boucles effectuées >= max_loops → arrêter, passer au polissage final
- Sinon → réviser et boucler
Étape 5 : Réviser
Traitez les retours du relecteur. Corrigez les problèmes Critiques et Importants. Les problèmes Mineurs sont facultatifs. Revenez ensuite à l’Étape 2.
Important : Chaque révision doit être ciblée. Ne réécrivez pas tout — corrigez ce que le relecteur a signalé. Maintenez une liste mentale de TOUS les retours antérieurs pour éviter les régressions.
Étape 6 : Polissage final
Une fois la boucle terminée (seuil de qualité atteint ou boucles max atteintes) :
- Corrigez les éventuels problèmes mineurs restants s’ils sont triviaux
- Vérifiez que le résultat final est cohérent (sans artefacts des cycles de révision)
- Signalez la note finale et le nombre de boucles à l’utilisateur
Adapter les critères du relecteur par type de tâche
| Type de tâche | Sur quoi le relecteur doit se concentrer |
|---|---|
| Code | Exactitude, cas limites, gestion des erreurs, lisibilité, aucun problème de sécurité |
| Spécification/Conception | Complétude, faisabilité, pas d’approximations, implémentabilité |
| Refactorisation | Aucun changement de comportement, aucune régression, plus propre qu’avant |
| Rédaction | Clarté, structure, adapté au public, pas de fioritures |
| Correction de bug | Cause racine traitée, test de régression existant, aucun effet secondaire |
| Infrastructure / IaC | Idempotence, moindre privilège, pas de secrets codés en dur, sécurité de destruction |
| Migration de base de données | Réversibilité, stratégie d’index, risque de perte de données, performance à l’échelle |
| Conception d’API | Rétrocompatibilité, authentification, versioning, contrat d’erreur |
| Suite de tests | Couverture des cas limites, aucune interdépendance entre tests, assertions significatives |
Deux modes de fonctionnement
Mode A : « Faire et relire » (cycle complet)
L’utilisateur donne une tâche + dit d’utiliser review-loop. Vous effectuez le travail ET exécutez la boucle de relecture.
Utilisateur : « Implémente la couche de cache. Utilise review-loop, seuil de qualité 8. »
Vous :
1. Implémentez la couche de cache
2. Lancez le relecteur → Note 6, retours : éviction manquante, pas de TTL
3. Révisez : ajoutez éviction + TTL
4. Lancez le relecteur → Note 8, retours : mineur sur le nom
5. Polissage final, terminé
Mode B : « Relire un existant » (relecture seule)
L’utilisateur a déjà effectué le travail ou vous l’avez déjà effectué. Exécutez simplement la boucle de relecture sur ce qui existe.
Utilisateur : « Exécute review-loop sur le module d’authentification que je viens d’écrire »
Vous :
1. Lisez le module d’authentification
2. Lancez le relecteur → Note 5, retours : injection SQL, pas de limitation de débit
3. Corrigez : paramétrez les requêtes, ajoutez un limiteur de débit
4. Lancez le relecteur → Note 8, approuvé
5. Terminé
Signaux d’alerte
Ne jamais :
- S’auto-relire au lieu de lancer un sous-agent (biais d’ancrage)
- Sauter un cycle de révision parce que « les retours sont erronés » sans justification
- Gonfler sa propre note (« Je pense que c’est en fait un 9 »)
- Continuer au-delà de max_loops sans le consentement de l’utilisateur
- Lancer le relecteur avec tout votre raisonnement/historique (il doit relire le TRAVAIL, pas votre intention)
Si le relecteur a tort :
- Opposez-vous avec des preuves (montrez le code/les tests qui infirment le retour)
- Ignorez ce point spécifique dans la révision
- Notez-le dans votre rapport à l’utilisateur
- N’abaissez PAS la barre de qualité pour compenser
Exemple de format de rapport
--- Boucle de relecture : {nom de la tâche} ---
Boucle 1/4 : Note 6/10
Relecteur : Validation d’entrée manquante, pas de gestion d’erreur pour le délai d’attente réseau,
fonction trop longue (80 lignes).
Action : Correction des trois problèmes.
Boucle 2/4 : Note 8/10
Relecteur : Propre. Mineur : le nom de variable `d` pourrait être plus descriptif.
Action : Seuil de qualité atteint (8 >= 8). Polissage final.
Résultat : 8/10 en 2 boucles. Terminé.
Limitations connues
- Le sous-agent relecteur n’a pas de mémoire des boucles précédentes — incluez explicitement le contexte des retours antérieurs dans chaque prompt du relecteur pour éviter de répéter les problèmes déjà résolus
- L’inflation de la note est possible si les critères du prompt du relecteur sont trop vagues — consacrez du temps à la rédaction de critères spécifiques et mesurables
- Cette compétence ne remplace pas une relecture humaine pour le code critique en matière de sécurité ou de conformité ; traitez le résultat comme une première passe solide
- La convergence de la boucle n’est pas garantie si la tâche est sous-spécifiée — définissez des critères d’acceptation clairs avant de commencer
Coût et rapidité
- Chaque boucle = 1 appel du sous-agent relecteur
- Prévoyez environ 1 à 2 fois le temps d’un seul passage d’implémentation pour un cycle complet de 3 boucles
- C’est peu coûteux par rapport à la livraison de code bogué, de spécifications vagues ou au déclenchement d’un cycle de relecture tardif
- Utilisez votre modèle par défaut/standard pour la plupart des relectures ; ne passez à des modèles de raisonnement avancés que pour des domaines spécialisés (audits de sécurité, systèmes distribués, finance quantitative)
Licence
MIT — libre d’utilisation, d’adaptation et de redistribution avec tout outil ou plateforme d’IA. Citation appréciée. Contributions bienvenues.