Accueil / Articles

Arrêtez de donner des souhaits aux agents d’IA : un processus axé sur les spécifications pour les petites équipes.

Cessez de formuler des souhaits pour les agents d’IA : une approche axée sur les spécifications pour les petites équipes, avec une revue par deux familles de modèles, des tests en temps réel, des fusionnements effectués par des humains et un suivi de la mémoire.

Éditeur : REACTAPP.TOP7 min de lecture1708 mots

Sources: *A small dev team, a stack of AI agents, and the spec-first process that keeps them honest.*

Imaginez un agent IA qui crée une fonctionnalité en vingt minutes. La demande de fusion semble parfaite : diffs bien organisés, tests réussis, résumé poli. Pourtant, elle est erronée, à un point tel que l’équipe en a besoin de trois jours pour résoudre le problème.

Le modèle en question n’était pas mauvais ; il faisait simplement ce qui lui était demandé. Le problème résidait dans l’instruction, qui n’était en réalité qu’un souhait. « Créez une page affichant X » est un souhait, et un prestataire rapide et littéral cherchera à le satisfaire en devinant tout ce qui n’a pas été dit. Ces suppositions seront plausibles, car c’est précisément ce que ces systèmes produisent.

Une petite équipe refuse désormais de créer quoi que ce soit avant que la description ne soit écrite par écrit et qu’elle ait résisté à un traitement rigoureux, avant même qu’une ligne de code ne soit écrite. Cette approche est appelée développement piloté par des spécifications. C’est ce qui permet aux agents d’être fiables lorsque l’on doit développer plus de logiciels que de personnes pour le faire. Les humains prennent les décisions, effectuent les revues et fusionnent les modifications. Les agents se chargent de la saisie. Ce système ne fonctionne que lorsque les agents reçoivent des instructions plus précises qu’un simple souhait.

Ce qu’une spécification contient

Rien n’est créé avant qu’un bref document Markdown n’existe, définissant trois éléments dans cet ordre :

  1. Le problème actuel et la raison pour laquelle il mérite attention.
  2. Ce qui sera vrai par la suite, décrit de manière à ce qu’un utilisateur puisse le vérifier.
  3. Ce qui doit rester exactement tel quel pendant que le travail est en cours.

Le dernier point revêt une importance surprenante. Une grande partie de toute spécification solide consiste simplement à délimiter la zone que les modifications ne sont pas autorisées à toucher. Le reste concerne les scénarios, c’est-à-dire chaque cas limite que l’auteur peut imaginer, chacun étant formulé sous la forme « si ceci, alors cela ».

Les spécifications sont rédigées sous forme de deltas, jamais comme des documents universels. Voici le comportement actuel, voici exactement ce qui changera. Une spécification qui tente de décrire tout le monde finit par ne décrire rien.

Deux IA attaquent d’abord la spécification

Lorsque le projet est terminé, deux évaluateurs IA le reçoivent. Ils proviennent de fournisseurs différents et de lignées de modèles distinctes, et leur seule mission est de trouver des manières dont le plan pourrait échouer. L’équipe a surnommé cette session un « pow-wow ». Le mélange de lignées est intentionnel : les évaluateurs d’une même famille ont tendance à passer à côté des mêmes choses, comme des frères et sœurs qui se complètent dans leurs récits. C’est le désaccord que l’on cherche.

Les constats sont réintégrés dans la spécification. Une objection devient alors une exigence. Ce n’est que lorsque la spécification ne présente plus d’erreurs que l’agent de développement est envoyé.

Cet ordre de procédure a une raison derrière lui. Autrefois, un développeur a été envoyé alors qu’une revue était encore en cours. La revue a révélé des problèmes qui rendaient la moitié du code invalide, et l’équipe a dû payer deux fois pour ce code. Depuis, la règle est stricte : un développeur attend que les deux reviewers aient terminé leur travail et que chaque constat accepté ait été inscrit dans la spécification, même si cela semble inoffensif à première vue.

Cette réunion a porté ses fruits de manières inattendues. Un document de spécification a un jour donné un nom à un outil d’autorisation existant et a supposé, rien qu’à partir de ce nom, ce qu’il vérifiait. Un des reviewers a ouvert le code et a découvert que son champ d’application était bien plus restreint : il ne s’appliquait qu’au demandeur initial, et uniquement dans un état donné. Les noms de fonctions peuvent induire en erreur. C’est pourquoi il est essentiel d’avoir l’habitude de lire l’implémentation avant même que la spécification ne l’évoque. Cette habitude a sauvé plus de week-ends que n’importe quelle règle de vérification.

Le processus, du début à la fin

Pour tout changement d’une certaine importance, la séquence est la suivante :

spec → adversarial review → apply findings → build → diff review → runtime testing → human testing → human merge

Quelques points méritent des commentaires.

Le développeur ne reçoit que les spécifications, rien de plus. Il ne voit jamais de journal de conversation ni de demande d’extension occasionnelle. Tout ce que le développeur doit savoir doit être indiqué dans le document, car tout ce qui manque peut donner lieu à des suppositions.

Les tests en temps de exécution vérifient ce que fait le logiciel, et non à quoi ressemblent les fichiers. Le simple fait de réussir les tests ne dit pas grand-chose. Lors d’un incident initial, un message de validation devait apparaître à l’écran mais ne l’a jamais fait, car le code chargé de l’afficher était inaccessible. Les comparaisons de fichiers et les tests étaient tous deux corrects. Personne n’avait essayé de faire quelque chose de faux en tant qu’utilisateur, et une comparaison de fichiers ne peut pas afficher un message qui n’existe pas. Aujourd’hui, les défauts sont introduits délibérément : on envoie du contenu inutile, on s’assure que l’erreur est bien visible, et ce n’est qu’alors que l’on marque le travail comme testé.

Le geste humain consiste pour quelqu’un à parcourir l’application comme un utilisateur impatient, et c’est justement là l’essentiel. Une catégorie de bugs échappe à toute revue automatisée : la fonctionnalité fonctionne, mais une personne ne parvient pas à la trouver. Écrans de création manquants, navigation sans issue. Les clics agacés servent de test d’acceptation et gagnent plus de confiance que n’importe quel résumé.

La fusion reste entre les mains d’un humain. Les agents ne fusionnent ni ne déploient. La vitesse est acceptable, mais la demande de fusion doit indiquer avec précision quels contrôles ont été exécutés et lesquels ont été sautés, et l’orchestrateur marque immédiatement les contrôles sautés comme tels. Lorsque la plupart de l’équipe se compose de machines qui vérifient d’autres machines, des registres honnêtes sont essentiels.

La complexité du processus dépend de l’ampleur du changement. Une petite correction de texte devient une PR directe. Les modifications liées à la sécurité, aux permissions et au modèle de données nécessitent une étape approfondie. Imposer un processus lourd à des tâches mineures les rend inutiles, tandis que confier des tâches importantes à un processus simplifié met en péril le projet.

Lorsqu’un changement est intégré, sa spécification est archivée avec le code. Le dépôt constitue progressivement un document écrit des décisions prises, de sorte que la question de savoir pourquoi quelque chose fonctionne d’une certaine manière trouve souvent une réponse antérieure au code lui-même.

Revue par deux personnes qui n’ont pas écrit le code

La réunion vise à examiner le plan. Le code final est soumis à un comité distinct, et c’est cette version que l’autre équipe doit d’abord adopter.

Le constructeur est un outil fiable, choisi pour sa capacité à fonctionner sans cesse et son faible coût par token. L’argent destiné aux fonctionnalités avancées est épargné pour des analyses plus approfondies, sous forme de deux modèles de pointe provenant de laboratoires distincts, aucun n’étant lié au constructeur. Leurs rôles diffèrent délibérément : l’un occupe le poste d’ingénieur senior, examinant ligne par ligne les différences par rapport aux spécifications, puis travaillant directement sur la version en cours de développement pour tenter de détruire la fonctionnalité en question. L’autre constitue une étape obligatoire, et aucune modification significative ne peut être intégrée sans son approbation, aussi mineure soit-elle.

Deux laboratoires au lieu de deux copies du modèle le plus performant ? Les modèles apparentés partagent des comportements similaires. Un évaluateur a tendance à excuser du code écrit dans son propre style et à avoir du mal avec du code provenant d’un externe. Si les deux indiquent la même ligne de code depuis des directions différentes, il s’agit presque certainement d’un défaut. S’ils se contredisent, c’est que la spécification présentait une lacune, ce qui est mieux détecté avec deux modèles qu’avec un utilisateur.

Ces postes ne sont pas permanents. Un évaluateur a été mis de côté après que son système ait répété indéfiniment la même découverte plus d’une centaine de fois. Les grands modèles de raisonnement peuvent entrer en boucle lorsqu’ils reçoivent une requête de taille variable. Le poste a été remplacé, mais le système de contrôle est resté le même.

L’agent qui maintient tout ensemble

Rien de tout cela n’est exotique. Les spécifications, les évaluations et les tests sont des idées anciennes revêtues d’un nouveau visage. Ce qui est plus difficile à prédire, c’est l’importance de l’orchestration et le nombre d’agents nécessaires pour maintenir le flux de travail cohérent.

L’équipe utilise Hermes Agent, un framework d’agent open source développé par Nous Research, en tant qu’orchestrateur. Il ne se charge pas principalement d’écrire du code ; il exécute plutôt le processus, ce qui constitue probablement sa tâche la plus importante. Trois caractéristiques permettent à cela de fonctionner.

Mémoire. La plupart des assistants commencent chaque conversation sans mémoire des précédentes et avec un ton amical. Hermes conserve le contexte entre les sessions, ce qui permet aux décisions prises d’être respectées. Il connaît les niveaux de risque, sait que les créateurs ne notent jamais eux-mêmes leur travail, et est au courant que chaque mission débute par une réunion préalable, car les erreurs passées y sont consignées. Si une personne pressée souhaite contourner une étape, l’agent refuse : le processus est respecté par celui qui s’en souvient parfaitement.

Apprentissage. Une défaillance se transforme en analyse post-mortem, et cette analyse devient une compétence ; chez Hermes, cela correspond à un document de procédure chargé lors des sessions ultérieures lorsque c’est pertinent. Après six mois, l’agent dispose d’une pile de notes acquises au prix de gros efforts, tirées de incidents réels, et il lit d’abord celles qui sont pertinentes. Les connaissances qui se trouvaient auparavant dans l’esprit d’un ingénieur fatigué se trouvent désormais sous contrôle de version.

Délégation. La construction et l’examen sont confiés à des sous-agents. Comme Hermes fonctionne avec n’importe quel fournisseur, les rôles peuvent être associés librement à des modèles : un modèle économique s’occupe de la construction, tandis que les modèles sophistiqués et coûteux s’occupent de l’examen. Si un modèle rencontre des difficultés pendant un mois, on le remplace et rien d’autre ne change.

Qu’est-ce que cela apporte et quel en est le coût

Il n’y a pas de pourcentage de productivité ici. De tels chiffres ne peuvent pas être vérifiés, et presque tous ceux qui les publient vendent quelque chose. Voici les affirmations qui peuvent être défendues :

  • Les livraisons hebdomadaires ont lieu même si personne ne travaille à plein temps sur le codage.
  • Le rayon d’action est maîtrisé dans les délais prévus, avant que le contrôle ne devienne coûteux.
  • Toute personne se demandant pourquoi le logiciel se comporte d’une certaine manière peut trouver la réponse écrite quelque part.
  • Le rôle du personnel évolue, passant du temps passé au clavier à des décisions et des actions de clic.

C’est un rôle meilleur, mais aussi plus difficile. Rédiger des spécifications précises signifie savoir ce que l’on veut avant même de le voir. Avec une mise en œuvre peu coûteuse, l’exactitude est devenue la compétence la plus rare.

Les inconvénients sont réels. Rédiger des spécifications exige de la discipline, et la tentation de prendre des raccourcis pour une modification censée être mineure est ce qui fait échouer ce type de processus. Les évaluateurs basés sur l’IA peuvent vous submerger de plaintes mineures, il faut donc développer une compétence pour les trier. Lorsque les exigences sont déjà évidentes, le processus devient lent. De plus, il nécessite une attention constante : laissé à lui-même, il se détériore comme tout processus humain.

La question n’est plus de savoir si l’IA peut écrire du code, car elle le peut. Ce qui importe désormais, c’est de savoir si vous pouvez définir avec précision ce que le logiciel doit faire et respecter votre propre processus lorsque le temps est limité. Sans cela, aucun modèle ne sera d’une grande aide ; il ne fera qu’accélérer votre confusion.

Lectures complémentaires

  • Les bases de TanStack Query : requêtes, mise en cache, mutations et invalidation — Découvrez comment useQuery, queryKey, staleTime, gcTime, useMutation et l’invalidation s’associent pour gérer l’état du serveur dans React sans avoir à écrire manuellement des effets fetch.