En bref
- Notre ancien workflow Claude Code était conçu pour des modèles qui n’existent plus : de petites fenêtres de contexte, beaucoup d’accompagnement pas à pas, une douzaine de commandes à retenir. Plus de six mille lignes au total.
- Je l’ai reconstruit sur des preuves plutôt que sur l’habitude : des mesures publiées sur l’effort de raisonnement, un débat de trente tours que j’ai organisé entre deux modèles d’IA, et la carte, dressée par un collègue, des endroits où l’attention d’ingénierie rapporte le plus.
- La nouvelle version tient en une boucle avec deux portes d’entrée, deux contrôles, des relecteurs qui ne peuvent pas modifier le code, et un fichier de configuration que la boucle n’a pas le droit de changer. Environ 1 400 lignes au total, dont quelques centaines seulement pour la boucle elle-même.
- La plus grande leçon ne portait pas sur les prompts. Une page de documentation m’a affirmé qu’une fonctionnalité clé n’existait pas, et un test de deux minutes a prouvé le contraire. Mesurez avant de croire quoi que ce soit… documentation comprise.
Nous avions un workflow dont nous étions fiers. Nous l’avions construit ensemble, utilisé pendant des mois sur de vrais projets clients, et il a livré du vrai travail. Puis les modèles se sont améliorés, pas le workflow… et un jour, j’ai remarqué que nous dépensions plus d’efforts à satisfaire le workflow qu’il ne nous en faisait économiser.
#Ce que nous avions
Sur le papier, c’était rigoureux. En pratique, c’était un cérémonial conçu pour un modèle plus faible.
Six commandes et un pilote automatique. Une pour créer un fichier de prompt, une pour l’exécuter, une pour sauvegarder la session, une pour la recharger, une pour suggérer la suite, une pour gérer une liste de fonctionnalités. Le pilote automatique enchaînait les fichiers de prompt tout seul.
Une grille de complexité. Cinq dimensions, chacune notée de un à cinq, additionnées sur vingt-cinq, avec quatre paliers de seuil… tout cela pour décider si une tâche tenait en un prompt ou en plusieurs. En gros, de l’arithmétique pour contourner une petite fenêtre de contexte.
Un rituel sauvegarder, vider, recharger, répété dans six fichiers différents et déclenché par un moniteur de contexte.
Le moniteur s’est trompé pendant deux mois. Il supposait une fenêtre de 200 000 tokens alors que le modèle en avait un million ; il affichait donc environ cinq fois l’utilisation réelle et nous disait de nous arrêter et de sauvegarder à environ quinze pour cent de remplissage. Et nous l’avons cru :(
Et quand j’ai enfin audité l’ensemble, certaines commandes avaient leurs étapes exécutables imbriquées dans leur section de sortie, les permissions d’une commande interdisaient précisément les écritures qu’elle effectuait, et un générateur produisait des agents sans aucun en-tête de configuration. Aucun d’eux n’était donc même enregistré.
Cela fonctionnait, à peu près, parce que le modèle était assez bon pour le contourner. Ce n’est pas la même chose qu’un bon workflow. Rafistoler un workflow d’accompagnement pour en faire un workflow autonome vous laisse généralement avec les deux, alors j’ai tout recommencé.
#D’où vient la nouvelle idée
L’effort ne rend pas le modèle plus intelligent
La première source a été une analyse approfondie de l’équipe Claude Code sur l’effort de raisonnement. Son affirmation principale a changé ma façon de voir l’ensemble : l’effort ne rend pas le modèle plus intelligent. Il change la mesure dans laquelle le modèle vérifie son propre travail, et le nombre de décisions qu’il prend sans vous demander.
Taux de réussite, de l’effort faible à l’effort maximal
D’après l’analyse approfondie de l’équipe Claude Code sur l’effort de raisonnement.
| Travail | Effort faible | Effort maximal |
|---|---|---|
| Sécurité | 64 % | 87 % |
| Logiciel en général | 43 % | 56 % |
| Opérations | 12 % | 22 % |
L’effort maximal coûte environ trois fois plus de tokens, et sur une tâche il a pris 33 minutes au lieu de 2. L’effort vaut donc d’être payé précisément là où la vérification est rentable, et il est gaspillé partout ailleurs.
Le chiffre qui m’a marqué est un autre. Une application volontairement sous-spécifiée a pris une minute et demie en effort faible et 67 minutes au maximum. Un effort élevé sur un brief vague ne vous donne pas une meilleure réponse… il vous donne, une heure plus tard, une version soigneusement vérifiée de la mauvaise chose. La première règle du nouveau workflow est donc devenue : la clarté de la spécification décide de l’effort, avant toute autre chose.
Deux modèles qui débattent avec des preuves
La deuxième source a été une expérience. J’ai placé deux modèles d’IA dans un même fichier partagé pendant trente tours et je les ai fait débattre de leur façon de travailler, avec des règles strictes : chaque affirmation doit s’appuyer sur un incident réel ou une expérience exécutable, et chaque tour doit contester le précédent.
Deux constats ont changé la conception.
Le tableau des récidives. Cinq règles que j’avais déjà écrites ont de nouveau été enfreintes par l’agent même qui les avait rédigées. L’une d’elles, huit fois. Connaître la règle n’a jamais été le problème ; l’appliquer au moment d’agir, si. Des règles écrites ne suffiraient donc pas à me sauver.
L’écart de vitesse tenait à une habitude, pas à une personnalité. Sur le même ticket, un modèle a atteint la ligne d’arrivée en 15 minutes et l’autre en 33, avec un volume de lecture similaire et un temps par étape identique. Le plus rapide lisait d’abord les preuves propres à l’incident. Le plus lent lisait d’abord le code.
Et un vrai bug est apparu dans du code déjà fusionné, parce qu’un modèle a mis l’autre au défi d’exécuter réellement les tests au lieu de les citer :D
Une carte, et mes propres inquiétudes
La troisième source a été la carte d’un collègue indiquant où une heure d’attention rapporte le plus, en cinq niveaux, du système agentique dans son ensemble jusqu’à une seule ligne de code. Plus le niveau est élevé, plus il rapporte et plus il est ambigu. Si vous vous retrouvez à modifier des lignes à la main, c’est que quelque chose a déjà échoué plus haut.
J’y ai ajouté mes propres inquiétudes. Avec les agents, je ne lis plus tout ce qu’ils produisent. J’avais perdu de vue ce que contenait réellement notre base de données. Et je voulais qu’un humain, et non un agent, décide avant que la structure d’une table ne change.
#Le nouveau flux
Une boucle, deux portes d’entrée : un ticket, ou une simple description de ce que vous voulez. Après la première étape, les deux chemins sont identiques. Voici en détail les étapes de la vidéo en haut de page.
- Repères. Prendre un verrou pour que deux sessions ne puissent pas tourner en même temps, lire où le travail s’est arrêté, lire l’index des connaissances.
- Prise en charge. Passer le ticket en cours. Cette transition sert de verrou, pour que personne d’autre ne s’en empare.
- Cadrage. Lire les commentaires du ticket avant sa description, car les corrections arrivent après la rédaction de la description. Puis les leçons pertinentes, puis une carte de la base de données, puis une recherche de ce qui existe déjà. Seulement ensuite, décider si le brief est assez bon pour construire.
- Contrôle du plan. Conditionnel. Il se déclenche sur un brief trop mince, des critères que l’agent a dû inventer, toute modification de la base de données, une surface à risque, quelque chose de nouveau sur le plan de l’architecture, un effort élevé, ou un nouveau projet qui n’a pas encore gagné la confiance. Il bloque le ticket, pas la boucle, si bien que la file continue d’avancer.
- Construction. Le plan fait office de contrat. Quand la réalité le contredit, l’agent amende le plan en le justifiant au lieu d’improviser.
- Revue. Trois relecteurs qui n’ont pas écrit le code : exactitude, sécurité, performance. C’est la gravité qui décide de la boucle de correction, pas un compteur. Un problème sérieux est revérifié, une remarque de style n’est jamais corrigée dans la même passe.
- Contrôle de confiance. Universel. Un score, plus une liste de points bloquants qu’aucun score ne peut lever.
- Livraison et vérification. Fusionner, attendre que le déploiement passe réellement au vert, puis vérifier le résultat sur le système en fonctionnement, du point de vue de l’utilisateur. Des tests qui passent ne sont pas une vérification. Un échec entraîne un retour en arrière.
- Passation. Un commentaire en deux niveaux : d’abord en langage clair pour le produit et la QA, ensuite le détail technique.
- Apprentissage. Un ticket renvoyé par la QA est l’événement le plus riche en signal du système, car les deux contrôles ont été passés et c’était quand même faux. Celui-là produit toujours une leçon.
Les deux contrôles répondent à des questions différentes. Le contrôle du plan élimine l’incertitude, le contrôle de confiance élimine le risque. Un plan approuvé lève les points bloquants liés à l’incertitude, jamais ceux liés au risque… approuver un plan, ce n’est pas approuver une fusion.
Les deux contrôles
| Contrôle du plan | Contrôle de confiance | |
|---|---|---|
| Élimine | L’incertitude | Le risque |
| Se déclenche | Sur un brief trop mince, des critères inventés, une modification de la base de données, une surface à risque, quelque chose de nouveau sur le plan de l’architecture, un effort élevé ou un nouveau projet | Sur chaque ticket |
| Décide avec | L’approbation du plan par une personne | Un score, plus des points bloquants qu’aucun score ne peut lever |
| Bloque | Ce ticket ; la file continue d’avancer | La fusion |
#Agents et effort
L’effort est défini par agent : la boucle choisit donc l’effort en choisissant quel agent fait le travail. Un explorateur en effort faible, qui ne peut que lire. Un planificateur en effort élevé, orienté vers les cas limites et explicitement chargé de ne jamais répondre lui-même à ses propres questions sur l’intention. Un implémenteur en effort moyen. Et trois relecteurs en effort moyen, élevé et maximal, tous en lecture seule. La revue de sécurité monte au maximum quand une modification touche à l’authentification, aux secrets ou aux paiements, car c’est là que les mesures montrent que la vérification supplémentaire est rentable.
Qui fait quoi, avec quel effort
| Agent | Effort | Son rôle |
|---|---|---|
| Explorateur | Faible | Lit, n’écrit jamais |
| Planificateur | Élevé | Trouve les cas limites ; ne répond jamais lui-même à ses propres questions sur l’intention |
| Implémenteur | Moyen | Écrit le code et les tests |
| Trois relecteurs | Moyen, élevé et maximal | Exactitude, sécurité et performance ; lecture seule. La sécurité passe au maximum pour l’authentification, les secrets ou les paiements |
| Conseiller | Un second modèle, différent | Consulté avant un plan important, quand une erreur se répète, et avant qu’une longue tâche soit déclarée terminée |
Tous les relecteurs sont en lecture seule. L’élément le plus autonome du système, un relecteur en effort maximal, dispose d’un jeu d’outils qui ne peut pas modifier un seul fichier.
Par-dessus vient un conseiller : un second modèle, différent, consulté avant un plan important, quand une erreur se répète, et avant qu’une longue tâche soit déclarée terminée. La boucle le sollicite dans ces conditions, et non quand l’agent en a envie, car « mon plan est-il assez gros pour mériter un deuxième avis ? » est précisément la question sur laquelle un agent se trompe à propos de son propre travail.
#Les scripts
Un installateur qui livre les éléments qui ne changent jamais d’un projet à l’autre, et refuse d’écraser un fichier que quelqu’un a modifié.
Un générateur de carte de la base de données qui construit la carte à partir du schéma en production, jamais de la mémoire d’un agent, et signale tout ce qu’il a dû deviner. Un contrôle de dérive échoue bruyamment quand la carte devient obsolète.
Un hook de prompt qui repère une référence de ticket et rappelle à l’agent d’utiliser la boucle. Il ne peut que rappeler, pas refuser… et je préfère le dire franchement plutôt que d’en exagérer la portée.
Une commande de configuration qui lit un projet, étiquette chaque section de son fichier d’instructions avant d’y toucher, ne supprime jamais rien, élague les conseils concernant des frameworks que le projet n’utilise pas, propose chaque correction sur sa propre ligne, et attend qu’un humain approuve.
#Ce qui va dans le fichier d’instructions
Ma première version des instructions indiquait où se trouve la boucle et où sont conservés les plans. Un agent lit cela, apprend que l’outillage existe, et continue à travailler à la main lol. Une fiche de référence ne change rien. Je l’ai donc réécrite sous la forme d’un déclencheur et d’une conséquence : quand vous recevez un ticket, lancez la boucle, car travailler à la main, c’est le même travail sans les vérifications.
Quelques-unes des règles retenues :
L’achèvement se vérifie, il ne se déclare pas. Nommer ce qui devait être vrai et le vérifier par rapport à quelque chose que le code n’a pas écrit lui-même.
Les preuves de première main d’abord. Lire les logs propres à l’incident avant le code.
Le support avant la prose. La deuxième fois qu’une règle écrite est enfreinte, arrêter de la reformuler et la transformer en test, en hook ou en valeur par défaut.
La boucle ne peut jamais modifier sa propre configuration. Un mauvais calibrage devient une proposition soumise à un humain.
Vous ne pouvez pas approuver votre propre plan. Et une approbation relayée par un autre agent n’est pas non plus une approbation.
#La leçon que je n’attendais pas
Vers la fin de la construction, j’ai demandé à un agent de vérifier un détail dans la documentation : ce réglage d’effort par agent existe-t-il vraiment ? Il est revenu sûr de lui. Pas un champ pris en charge. Toute l’échelle d’effort n’était probablement que de la décoration.
J’ai failli l’arracher de tous les agents. J’ai plutôt lancé un test de deux minutes : trois agents identiques à cette seule ligne près, puis j’ai lu à quel niveau chacun avait réellement tourné. Faible a tourné en faible, moyen en moyen, max en max. La fonctionnalité marchait ; la documentation était simplement incomplète.
La même semaine, l’ancien moniteur de contexte m’a annoncé qu’une session était remplie à 246 %. Une lecture corrigée de la même session indiquait 52 % 😁
Les deux fois, la description du système était fausse et la mesure était juste.
#Mon avis
Le nouveau workflow fait un quart de la taille de l’ancien, et la boucle elle-même tient en quelques centaines de lignes. Il est aussi honnête sur ce qu’il n’a pas encore prouvé : aucun gain de temps démontré pour l’instant. Il est en phase d’essai et je mesure deux choses… le temps pour atteindre la même ligne d’arrivée, et les corrections après la passation. Je reviendrai avec les chiffres, bons ou mauvais.
Le changement que je préfère, c’est la destination de mon attention. Je lis des plans et j’approuve des fusions. Je ne regarde plus le travail se faire.
