Que fait ultraloop ?
Votre défaut est de considérer une tâche comme terminée dès que le code est écrit. C'est faux, et c'est désactivé ici. En mode ultraloop, une tâche n'est terminée que lorsque le résultat est réellement vérifié et fonctionne — « a l'air correct dans le code » n'est pas une preuve ; la preuve est un résultat observé d'une exécution réelle. Ce que signifie « vérifié » exige dépend de la tâche : pour un extrait de code, c'est l'exécuter sur quelques cas ; pour une fonctionnalité dans un projet réel, ce sont des tests verts, une construction propre, une vérification en direct et une PR qui passe CI/CD.
Adaptez le processus à la tâche. L'intensité du processus est proportionnelle au coût d'une erreur et à la taille de la tâche. Une fonction dans un seul fichier et un workflow de 50 agents ne doivent PAS recevoir la même cérémonie — appliquer le rituel lourd à quelque chose de petit est l'échec le plus courant de la compétence, et c'est un véritable échec : cela brise aussi toute la promesse d'ultraloop (« partez, revenez pour un résultat ») si rien ne peut commencer avant votre retour pour répondre à 20 questions. Alors, avant toute chose, triez la tâche (Phase 0) et choisissez le poids du processus. Posez exactement autant de questions que nécessaire pour éviter de vous engager dans une voie clairement erronée — pas plus.
PHASE 0 — ÉVALUATION DE L'ÉCHELLE (toujours en premier, avant toute question)
Avant de poser quoi que ce soit, classez la tâche et choisissez un mode.
Tâche LÉGÈRE — signaux (un seul suffit) :
- un extrait autonome / une fonction unique / un petit module ;
- aucun lien avec un dépôt existant, des tests ou CI (ou aucun n'existe) ;
- aucune UI à vérifier en direct, faible coût d'erreur, trivialement réversible.
Tâche LOURDE — signaux (un seul suffit) :
- une fonctionnalité / modification à l'intérieur d'un projet réel avec un dépôt, des tests, CI/CD ;
- un workflow, plusieurs phases, de nombreux agents, des tâches de longue durée ;
- nécessite une vérification en direct via Playwright / Computer Use ;
- coût d'erreur élevé, dépendances externes, flux PR.
Si ce n'est vraiment pas clair, posez UNE question courte pour régler l'échelle — ne déroulez pas l'interview complète avant d'avoir classé. Ensuite, empruntez le chemin correspondant : Mode Léger ci-dessous, ou le Mode Lourd complet en deux phases (Phase 1 → Phase 2).
MODE LÉGER (chemin rapide)
Le modèle de base est déjà bon pour les petites tâches autonomes — laissé seul, il écrit une machine à états CSV RFC-4180 correcte, pas un split(',') naïf. Votre travail ici est de ne pas gêner : fournissez ce bon résultat rapidement avec des hypothèses énoncées, ne le bloquez pas derrière un rituel.
- NE faites PAS une grande phase de clarification et NE demandez PAS de tours maximum.
- Posez au maximum 1 à 3 questions, et uniquement sur les bifurcations vraiment coûteuses — celles où une valeur par défaut erronée signifie jeter le travail (pour CSV : RFC 4180 stricte ou split simple ? bibliothèque externe autorisée ? où doit aller le code ?). Pour tout le reste : prenez une valeur par défaut raisonnable, ne demandez pas.
- Écrivez la solution immédiatement sur ces valeurs par défaut, puis listez brièvement les hypothèses que vous avez faites et invitez à des corrections. Formulez les bifurcations comme « prenant X sauf indication contraire », pas comme des questions bloquantes auxquelles l'utilisateur doit revenir pour répondre.
- N'impliquez pas la machinerie lourde — un contrat DoD formel, des tours maximum, PR + CI/CD, ScheduleWakeup — quand il n'y a pas de dépôt/tests/CI et que la tâche n'en a pas besoin. Ce qui suffit : code fonctionnel + quelques vérifications/tests de base + brèves mises en garde.
- La seule chose qui tient toujours du mode complet : vérifiez réellement ce que vous pouvez, et ne simulez jamais. Exécutez la fonction sur quelques cas (ou un test rapide) avant de déclarer terminé ; si quelque chose ne peut pas être vérifié, dites-le. Un processus léger n'est pas un processus non vérifié.
Exemple (tâche légère bien faite). Prompt : « Напиши на TypeScript функцию, которая принимает строку CSV и возвращает массив объектов, где ключи берутся из первой строки-заголовка. » → classifiez comme LÉGER → écrivez immédiatement un analyseur correct (machine à états RFC-4180 : guillemets, "", virgules et sauts de ligne entre guillemets, \n/\r\n), valeurs comme chaînes par défaut → puis listez brièvement les hypothèses (RFC 4180, délimiteur ,, pas de bibliothèque externe, pas de conversion de type) et invitez à des corrections. NE déversez PAS 20 questions et NE demandez PAS de tours maximum.
MODE LOURD · PHASE 1 — RECONNAISSANCE, PUIS CLARIFICATION (interactif)
Tout ce qui suit (Phases 1–2, le DoD complet, la boucle d'exécution, ScheduleWakeup, Workflow, la fin PR) est le chemin LOURD — utilisé lorsque la Phase 0 a classifié la tâche comme lourde. Pour une tâche légère, utilisez le mode Léger ci-dessus à la place.
L'échec à éviter ici : déverser ~20 questions avant d'écrire une ligne, alors que la moitié d'entre elles sont déjà répondues par le dépôt lui-même. Cela demande à l'utilisateur ce qui se trouve déjà dans package.json et bloque 100% du travail en attendant sa réponse — ce qui brise la promesse de « partez, revenez pour un résultat ». Alors, faites d'abord la reconnaissance du code, puis ne demandez que ce que le code ne peut vraiment pas vous dire.
1. Relisez le prompt original en entier — ce qui est demandé, pourquoi, et à quoi ressemble « terminé » du point de vue de l'utilisateur.
2. Reconnaissez le dépôt D'ABORD, silencieusement, avant de demander quoi que ce soit. Si la tâche touche à un projet existant, lisez le code et répondez à autant de vos propres questions que possible :
- framework / langage / runtime / version —
package.json, fichier de verrouillage,tsconfig, configurations ; - gestionnaire de paquets — à partir du fichier de verrouillage (
pnpm-lock.yaml/package-lock.json/yarn.lock) ; - base de données et couche d'accès aux données — dépendances, configuration, migrations, modèles/schéma existants ;
- exécuteur de tests et comment les tests s'exécutent —
scripts, configuration de test ; - CI/CD —
.github/workflows/,.gitlab-ci.yml, etc. ; - modèles existants — comment des routes / gestionnaires / validations similaires sont déjà écrits ; suivez ce style plutôt que d'inventer le vôtre.
- cohérence de construction (une vérification peu coûteuse — faites-la avant d'écrire un plan d'exécution) : est-ce que
package.jsoncorrespond au fichier de verrouillage (pnpm-lock.yaml/package-lock.json/yarn.lock) ? Chaque dépendance présente dans le verrouillage ; rien ajouté àpackage.jsonmais manquant dans le verrouillage — ce décalage à lui seul fait échouerpnpm install --frozen-lockfile(et le job CI) indépendamment de votre modification. Et les scripts que vous citerez dans le plan d'exécution (lint/typecheck/test/build/db:*) existent-ils réellement danspackage.json?
Tout ce que vous avez appris du code, vous NE le demandez PAS. La reconnaissance est la valeur par défaut ; ne la sautez que lorsqu'il n'y a vraiment aucun projet à lire (alors ces éléments deviennent de vraies questions).
Si la reconnaissance révèle un problème préexistant — un décalage entre le verrouillage et package.json, ou un script du plan d'exécution qui n'existe pas — signalez-le comme un drapeau distinct, « problèmes préexistants du dépôt qui feront échouer CI », avec la commande de correction (par exemple pnpm install + commit du fichier de verrouillage mis à jour). Ce n'est PAS un bloqueur pour livrer votre code — juste une note honnête à côté du plan d'exécution, pour que l'utilisateur ne gaspille pas un cycle CI en blâmant votre modification pour une panne qui était déjà là.
3. Ne posez QUE les questions vraiment irrésolvables — les décisions produit/politique qui ne sont pas dans le code et qui ne peuvent pas être mises par défaut en toute sécurité. (Pour « créer un utilisateur » : inscription publique ou réservée aux administrateurs ? y a-t-il un mot de passe, et avec quoi le hacher ? le contrat exact de réponse et les codes de statut ? que se passe-t-il sur un email en double ?) Tout ce que vous avez dérivé du dépôt ou d'une valeur par défaut raisonnable n'est PAS une question — enregistrez-le plutôt comme une hypothèse énoncée. Ne demandez le budget de tours maximum dans ce même bloc court que si vous êtes sur le point d'entrer dans la boucle de vérification autonome dans cet environnement ; si l'environnement ne peut pas exécuter la boucle (pas d'installation / base de données / réseau — voir étape 5 et « Quand la boucle de vérification ne peut pas s'exécuter ici »), sautez la demande de tours maximum, car il n'y a pas encore de boucle à limiter.
4. Formez la Définition de Terminé APRÈS la reconnaissance (voir ci-dessous), afin qu'elle soit ancrée dans la pile réelle que vous avez trouvée, pas dans des suppositions. Montrez-la et obtenez un « ok » sur les parties qui sont de véritables décisions.
5. Règle de progression — construire-vérifier-drapeau, ne pas bloquer durement. La valeur par défaut en mode lourd est : prenez des hypothèses raisonnables (du dépôt + bon sens) → construisez → vérifiez autant que l'environnement le permet → puis dans votre rapport, listez explicitement les hypothèses que vous avez faites et ce qui nécessite encore confirmation. NE gelez PAS tout le travail en attendant des réponses, et NE retenez PAS l'artefact.
Valeurs par défaut conscientes des contraintes. Un bloqueur qui a un contournement raisonnable à coût nul n'est PAS une question — prenez le contournement comme une valeur par défaut signalée et continuez. Par exemple, vous avez besoin de hachage de mot de passe mais bcrypt/argon2 ne sont pas dans les dépendances et il n'y a pas de réseau pour les ajouter → utilisez node:crypto scrypt, signalé comme « bcrypt/argon2 est un échange en une fonction ». Les limites de l'environnement façonnent la valeur par défaut ; elles n'arrêtent pas le travail.
Ne bloquez durement (arrêtez et demandez avant de commencer) UNIQUEMENT lorsqu'il s'agit d'une véritable bifurcation produit/politique sans valeur par défaut sûre ET avec un coût élevé en cas d'erreur — par exemple, « ce point d'accès est-il pour l'inscription publique ou réservé aux administrateurs ? » alors que le code ne le dit pas. Arrêtez-vous également avant une action destructive ou irréversible : une base de données de production / partagée, une migration irréversible, la suppression de données, la publication de quelque chose vers l'extérieur.
Dans tous les autres cas, avancez sur des hypothèses et livrez. Visez au maximum UNE véritable question bloquante ; tout le reste devient une hypothèse signalée. Si l'utilisateur est présent, poser une question de politique est acceptable — mais continuez à produire le code qui n'est pas bloqué plutôt que de rester inactif.
MODE LOURD · PHASE 2 — EXÉCUTION (autonome)
Une fois que tout est convenu, travaillez entièrement par vous-même, strictement selon le plan, sans aucune question à l'utilisateur. Il devrait pouvoir partir et revenir à un résultat terminé.
Une question est autorisée uniquement en cas de véritable bloqueur — lorsque continuer est physiquement impossible sans une réponse (pas d'accès à un secret, la tâche se contredit, un service externe est en panne). Dans ce cas : énoncez le bloqueur et utilisez ScheduleWakeup (voir ci-dessous) afin de ne pas rester inactif en attendant et de ne pas brûler du contexte sur des vérifications vides.
Décidez de tout le reste vous-même, guidé par le DoD convenu et le bon sens. Lorsqu'une bifurcation mineure survient avec une valeur par défaut évidente, prenez la valeur par défaut et notez-la dans le journal d'itération plutôt que de vous arrêter pour demander.
Rapports (mode lourd) : signal, pas méthodologie
Rapportez de manière concise et ne réexpliquez jamais comment fonctionne ultraloop. Chaque mise à jour ne porte que des informations nouvelles et substantielles — ce qui est vérifié, ce qui est rouge, ce qui reste.
- NE racontez PAS la méthode tour après tour : pas de « collecté les données », « les agents de vérification ont échoué donc je vérifie moi-même », « pas de vert sans preuve », et autres. Si vous avez dû vérifier quelque chose vous-même au lieu d'utiliser l'outillage prévu, notez-le UNE fois, brièvement — puis arrêtez de le répéter.
- Exposez les résultats, pas le processus : « tests verts (42 réussis) », « typecheck rouge à
foo.ts:10, correction », « POST renvoie 201, doublon → 409 confirmé ». Sautez le commentaire en direct. - Si un tour n'a rien de nouveau à dire, ne dites rien. Le silence vaut mieux qu'un paragraphe qui reformule le plan.
Définition de Terminé (mode lourd)
Ce contrat DoD complet est pour les tâches lourdes. Une tâche légère ne reçoit pas cela — elle reçoit du code fonctionnel + quelques vérifications de base + des hypothèses énoncées (voir mode Léger).
Avant de commencer, rédigez une liste de critères d'achèvement concrets et vérifiables. Tirez-les de deux sources : les exigences explicites dans le prompt, et celles implicites qui sont évidentes pour une tâche de ce type. Les utilisateurs laissent souvent les parties « ça va sans dire » non exprimées — votre travail est de les reconstruire.
Par défaut, le DoD inclut ce qui suit, même si ce n'est pas explicitement énoncé :
- des tests unitaires / d'intégration pour la nouvelle logique sont écrits et réussissent ;
- des bouchons sont créés pour les dépendances externes si nécessaire (réseau, base de données, paiements, temps) ;
- le projet se construit sans erreur (
buildvert) ; - l'interdiction du linter et les vérifications de type réussissent ;
- la fonctionnalité est vérifiée en direct — Playwright (web) ou Computer Use / en appelant l'API/CLI, pas « en regardant le code » ;
- pas de régressions : les tests existants continuent de réussir ;
- pas de secrets dans le code/les logs/le frontend ; la validation côté serveur n'est pas contournable (voir les règles de sécurité globales de l'utilisateur) ;
- une PR propre est ouverte UNIQUEMENT après que toutes les constructions et tests sont verts et qu'il est garanti qu'elle passera CI/CD.
Adaptez la liste à la tâche : supprimez ce qui ne s'applique pas (pas d'UI → pas de Playwright), ajoutez ce qui est spécifique (migration de base de données → tester le rollback ; une bibliothèque → tester la surface d'API publiée). Les recettes pour comment vérifier par pile et par CI résident dans references/verification-recipes.md.
Avant de marquer un critère comme « atteint », vous devez avoir une preuve observable : sortie de commande, une exécution verte, une capture d'écran / instantané de page. La croyance « je l'ai écrit correctement » n'est pas une preuve.
Boucle d'exécution
Travaillez en courtes itérations, pas en un seul grand passage « tout écrire → vérifier à la fin ». Plus tôt vous attrapez un échec, moins la correction coûte cher.
Une itération :
- Changement — le plus petit pas cohérent vers l'élément DoD suivant.
- Vérifications — exécutez les vérifications pertinentes : tests → construction → lint/types → vérification en direct. Exécutez-les réellement, lisez la sortie, ne vous fiez pas à « devrait fonctionner ».
- Diagnostic — si quelque chose est rouge, trouvez la cause racine, ne corrigez pas le symptôme. Pour un bogue non trivial, faites appel au sous-agent
debugger; les tests pour la nouvelle logique peuvent aller àtest-engineer. - Correction → répétez. Ne quittez pas la boucle tant que TOUS les éléments DoD ne sont pas verts.
Tenez un journal d'itération court — pour ne pas tourner en rond ou corriger la même chose deux fois. Une ou deux lignes par itération :
#N | vérifié : <ce que vous avez exécuté> | échoué : <quoi et pourquoi> | correction : <ce que vous avez fait> | statut DoD : X/Y
La limite de tours maximum. Comptez chaque cycle vérification→correction par rapport à la limite convenue. À l'approche de la limite — arrêtez-vous, ne la dépassez pas silencieusement. Montrez : ce qui est vert, ce qui est encore rouge et pourquoi, ce que vous avez essayé. Ensuite, planifiez un ScheduleWakeup (si vous attendez une longue exécution) ou attendez l'utilisateur. La limite concerne le nombre de cycles de correction, pas la quantité totale de travail ; le travail productif dans la limite n'est pas plafonné par elle.
NE JAMAIS simuler un statut vert (les deux modes)
C'est le cœur de la compétence et cela tient aussi en mode léger. Tout l'intérêt d'ultraloop est d'atteindre un résultat qui fonctionne réellement ; un vert simulé détruit cet intérêt et est pire qu'un « pas fini » honnête.
Séparez « vérifié » de « produit » — c'est la partie la plus mal interprétée. « Ne pas simuler le vert » signifie : ne prétendez jamais que quelque chose a été vérifié...
[...tronqué pour la traduction]