Il y a deux ans, demander une fonctionnalité à un développeur, c’était attendre quelques jours. Aujourd’hui, un agent IA bien briefé livre une première version en quelques minutes, tests compris. J’utilise ces agents tous les jours, et je ne reviendrais pas en arrière.
Mais à force de les voir produire, une question a pris le dessus sur toutes les autres. Ce n’est plus « comment coder plus vite ? ». C’est : comment garder la main sur ce qu’on construit ?
L’IA code vite, mais sans cadre
Un agent travaille sur ce qu’on lui donne. Si la demande est floue, il comble les trous avec des suppositions raisonnables, et le résultat a l’air convaincant. Si la spec qu’il lit est une vieille version, il l’implémente avec le même aplomb.
Le problème n’est pas la qualité du code. Le problème, c’est que rien ne garantit que l’agent travaille sur une demande que l’équipe a réellement validée. Personne n’a dit « oui, c’est ça qu’on veut ». L’agent a simplement reçu un texte, et il l’a pris au mot.
Avec un développeur humain, ce garde-fou existait de fait : il posait des questions, il discutait avec le produit, il sentait quand quelque chose clochait. Un agent, lui, ne lève jamais la main pour dire « je ne suis pas sûr que ce soit validé ».
Des outils éclatés, des décisions qui s’évaporent
Ce manque de cadre est aggravé par la façon dont la plupart des équipes s’organisent.
Les specs vivent dans un wiki ou un dossier partagé. Le suivi est dans un outil de tickets que plus personne ne met vraiment à jour. Le code est dans la forge Git. La recette tient dans un tableur ou dans des messages. Rien n’est relié : impossible de passer d’une spec au code qui l’implémente, puis aux tests qui la vérifient.
Et surtout, les décisions ne sont pas tracées. Une validation, c’est un « ok pour moi » dans une réunion ou un pouce levé sous un message. Trois semaines plus tard, quand une anomalie remonte, personne ne sait plus qui avait validé quoi, ni sur quelle version.
Tant qu’on avançait au rythme humain, on s’en accommodait. Avec des agents qui produisent dix fois plus vite, ce flou devient un vrai risque : on accumule du code plus vite qu’on ne sait dire s’il était voulu.
Des outils pensés avant l’IA
On pourrait se dire que Jira, Linear ou Plane règlent le problème. Ce sont d’excellents outils, mais ils ont été conçus pour des équipes 100 % humaines.
L’IA y arrive comme un ajout : un assistant qui résume un ticket, un plugin qui génère une description. L’agent n’est pas un acteur du processus, avec des droits définis. Et surtout, aucun de ces outils ne porte l’idée qui me semble essentielle aujourd’hui : certaines étapes ne doivent pouvoir être franchies que par un humain.
C’est ce constat qui m’a poussé à construire mon propre outil, Régie. Pas pour remplacer ces logiciels dans l’absolu, mais parce que la façon de travailler avait changé plus vite que nos outils.
Premier principe : l’agent prépare, l’humain décide
Le partage des rôles tient en une phrase : l’agent rédige, propose et prépare ; l’humain valide.
Concrètement, une évolution avance d’étape en étape, et trois validations humaines bloquent le passage tant qu’elles ne sont pas données : celle du produit sur le besoin, celle du lead technique sur la conception, celle du recetteur sur le résultat.
- Brouillon
- En revue
- Validation produit · PO
- Conception
- Validation technique · Lead tech
- Développement
- Recette
- Validation recette · Recetteur
- Livré
Entre ces validations, l’agent fait l’essentiel du travail : il rédige la proposition, détaille le plan technique, découpe les tâches, implémente, prépare les points de recette. Il peut commenter, faire avancer une évolution, demander une relecture.
Mais il ne peut pas valider. Et ce n’est pas une consigne qu’on lui donne en espérant qu’il la respecte : c’est une impossibilité technique. L’agent se connecte avec un jeton qui agit au nom d’une personne, avec ses droits, et l’outil refuse toute validation qui ne vient pas d’un humain dans l’interface.
Une règle écrite dans un prompt finit toujours par être contournée, par erreur ou par excès de zèle de l’agent. Une règle portée par l’outil, elle, ne se discute pas.
Chaque validation est tracée : qui, quand, sur quelle version. Quand une anomalie remonte, on sait exactement ce qui avait été décidé, et par qui.
Deuxième principe : la spec d’abord
Le deuxième principe vient du développement piloté par les spécifications (spec-driven development) : on ne code rien qui n’a pas été spécifié et validé.
Chaque évolution décrit précisément ce qu’elle change dans un référentiel d’exigences : ce qu’elle ajoute, ce qu’elle modifie, ce qu’elle retire. Chaque exigence porte ses critères d’acceptation, sous une forme simple : étant donné…, quand…, alors….
Ce référentiel devient la mémoire du produit. Quand l’évolution est livrée, ses changements y sont fusionnés. Le prochain agent qui travaillera sur le même module lira l’état réel du produit, pas une spec périmée retrouvée dans un coin du wiki.
Et la recette en découle directement : chaque critère d’acceptation devient un point à vérifier. Le recetteur ne part pas d’une page blanche, et chaque anomalie reste rattachée à l’évolution qui l’a introduite. Une anomalie renvoie l’évolution en développement, sans qu’on perde le fil.
Pour l’agent, c’est un changement profond. Il ne reçoit plus un message isolé, mais un contexte complet et validé : le besoin, les exigences touchées, le plan accepté, les critères à satisfaire. Il travaille mieux, parce qu’il travaille sur du solide.
Troisième principe : le sur-mesure redevient rentable
Pendant des années, construire son propre outil interne était un luxe. Trop long, trop cher à maintenir : on prenait le logiciel du marché et on adaptait sa façon de travailler à l’outil.
Les agents ont inversé l’équation. Régie a été développée en grande partie par des agents IA, encadrés par des normes strictes : conventions de code, tests systématiques, relecture humaine obligatoire du code sensible (authentification, droits, validations). En quelques semaines, l’outil couvrait le cycle complet, de la spec à la recette, avec un serveur MCP pour que les agents y travaillent directement.
L’outil qui encadre les agents a donc lui-même été construit par des agents, dans le cadre qu’il impose. C’est, je crois, la meilleure démonstration que l’approche tient.
Le sur-mesure a un avantage décisif à l’ère de l’IA : l’outil peut épouser exactement votre processus, y compris les règles qui comptent pour vous, comme cette frontière entre ce que l’agent peut faire et ce qui reste humain. Plus besoin de tordre votre organisation pour rentrer dans les cases d’un logiciel générique.
Les équipes qui s’organisent ainsi prendront de l’avance
L’IA ne remplace pas le jugement humain : elle le rend plus précieux. Quand produire du code ne coûte presque plus rien, ce qui fait la différence, c’est de savoir quoi construire, de le décider clairement et de vérifier que c’est bien ce qui a été livré.
Les équipes qui l’auront compris ne se contenteront pas d’ajouter un assistant à leurs outils actuels. Elles organiseront le travail autour de ce nouveau partage des rôles : des agents qui préparent et exécutent à grande vitesse, des humains qui décident à chaque étape clé, et un outil qui garantit que cette frontière est respectée.
Ces équipes-là iront plus vite, et surtout dans la bonne direction.
Si vous réfléchissez à la place des agents IA dans votre équipe, ou à un outil sur mesure qui colle à votre façon de travailler, j’en parle volontiers autour d’un café.

