Agents IA en développement logiciel : notre méthode

Camille Wanty
·
·
Un agent peut produire du code en quelques minutes. Pour lui confier une partie du développement d’un produit, il faut surtout organiser ce qui l’entoure.
VOLTA comprend une application web, une API, une base de données et un moteur de calcul. Une petite équipe fait évoluer l’ensemble. Nous utilisons désormais des agents à plusieurs étapes du développement, du tri d’un bug à la préparation d’une note de version.
Un agent doit savoir quel travail prendre, où trouver le contexte, quelles règles respecter, comment vérifier son résultat et quand s’arrêter pour laisser un humain décider. C’est ce système que nous avons construit autour de VOLTA.
Notre organisation s’inspire de Shape Up, la méthode de Basecamp, et de pstack, un ensemble de pratiques consacrées au travail avec des agents. Nous les avons adaptées à notre produit et à nos contraintes.
Basecamp comme référence
Tout travail commence dans Basecamp.
Un bug, une demande produit ou un retour de QA devient une carte. Son emplacement indique son état : à clarifier, prêt, en cours ou prêt pour la QA. Les décisions importantes restent dans le corps de la carte, même lorsqu’elles ont d’abord été prises dans les commentaires.
Cette discipline existait avant les agents. Elle est devenue indispensable avec eux.
Un agent qui reprend un sujet ne peut pas dépendre d’une conversation Slack disparue ou de la mémoire de la personne qui l’a créé. La carte doit contenir assez d’informations pour comprendre le problème, retrouver les décisions et poursuivre le travail.
Les agents participent eux-mêmes à cet entretien. Ils réécrivent les cartes, signalent les informations manquantes et ajoutent des liens vers les tâches, les branches et les pull requests qu’ils créent.
Deux parcours de travail : bugs et fonctionnalités
Nous avons défini un parcours pour les bugs et un autre pour les fonctionnalités.

Les fonctionnalités et les bugs suivent deux parcours distincts. Les décisions humaines restent visibles aux étapes qui engagent le produit.
Pour un bug, un premier agent examine le rapport. Il vérifie le contexte, la version concernée et les étapes de reproduction. Si une information décisive manque, il pose une question ciblée et s’arrête. Sinon, il normalise la carte et la déplace vers la file des sujets prêts.
Un second agent peut alors reproduire le problème, chercher sa cause, proposer une correction et ajouter un test de non-régression. Il ouvre ensuite une pull request en brouillon. La carte conserve les liens et passe en QA.
Le parcours d’une fonctionnalité commence plus tôt. L’agent aide d’abord à transformer une idée en problème suffisamment précis. Il explore ensuite les parties concernées du produit avant d’en estimer la taille. Cette étape évite de déduire la complexité technique d’une maquette.
Une fois le périmètre accepté, un autre agent prépare l’approche technique et les tâches de réalisation. Le développement avance par blocs vérifiables. Une tâche n’est terminée que lorsque le code et les tests correspondants passent.
Après validation, l’agent peut aussi préparer la recette utilisateur et le texte de la note de version. Ce dernier décrit le bénéfice pour l’utilisateur, sans exposer les détails du code.
Chaque transition produit un élément durable : une carte mise à jour, une liste de tâches, une branche, une pull request ou un scénario de recette.
Le savoir-faire vit dans le dépôt
Nous n’avons pas construit cette organisation avec une collection de prompts personnels.
Chaque étape est décrite dans un fichier d’instructions versionné avec le code. Nous appelons ces fichiers des skills. Ils précisent le point de départ, le résultat attendu, les vérifications obligatoires et les situations dans lesquelles l’agent doit s’arrêter.
Le dépôt contient aussi des instructions consacrées aux opérations techniques récurrentes : créer une migration, ajouter un champ dans toutes les couches du produit, modifier les traductions ou faire évoluer notre API destinée aux agents.
Une modification de notre façon de traiter les bugs passe ainsi par une pull request. L’équipe peut la relire et retrouver son historique. Les mêmes instructions fonctionnent avec plusieurs outils, dont Codex et Claude Code. Un nouvel agent dispose dès son arrivée des règles que l’équipe a apprises au fil du temps.
Certaines de ces règles concernent des erreurs difficiles à voir. Par exemple, notre API peut ignorer silencieusement un paramètre qui n’a pas été déclaré dans son contrat. Sans instruction ni contrôle automatique, l’appel réussit mais renvoie trop de données. Le dépôt indique donc comment modifier ce contrat et comment vérifier le résultat.
Automatiser ce qui doit être répétable
Nous ne demandons pas aux agents de refaire librement toutes les opérations.
Lorsqu’une action doit produire exactement le même résultat à chaque exécution, nous l’implémentons dans un outil en ligne de commande. Notre outil interne crée les branches avec les bonnes métadonnées, vérifie les migrations et les traductions, contrôle certains contrats et rassemble les changements destinés aux notes de version.
Les commandes qui modifient le dépôt commencent par afficher un aperçu. Une confirmation explicite déclenche ensuite l’action. Elles produisent aussi une sortie structurée que l’agent peut lire sans devoir interpréter du texte libre.
L’agent choisit l’action. L’outil exécute la partie mécanique.
Cette séparation compte. Un modèle peut comprendre un rapport ambigu ou comparer plusieurs solutions. Un programme reste plus fiable pour appliquer deux cents fois la même convention de nommage.

L’agent exerce son jugement, l’outil garantit la répétition et l’humain prend la décision finale.
L’humain conserve les décisions importantes
Cette organisation ne rend pas le développement autonome.
Un agent peut qualifier, explorer, rédiger, modifier du code et lancer des vérifications. Il ne décide pas seul qu’une fonctionnalité répond au besoin, qu’un compromis produit est acceptable ou qu’une version peut être publiée.
Nous plaçons donc les validations humaines aux changements de responsabilité : acceptation du périmètre, revue de la pull request, recette et publication.
Notre objectif n’est pas de retirer l’humain de la chaîne. Il est de lui présenter un travail documenté, vérifié et traçable au moment où son jugement apporte le plus de valeur.
Une erreur doit améliorer le système
La partie la plus utile de cette organisation est peut-être sa capacité à conserver les leçons.
Lorsqu’une erreur se répète, nous ne nous contentons pas de corriger le code. Nous cherchons ce qui manque autour de l’agent : une instruction, un contrôle, une donnée dans la carte ou un outil déterministe.
Le paramètre d’API perdu silencieusement en est un exemple. Après deux occurrences, nous avons ajouté un contrôle automatique. La même erreur ne repose plus sur la vigilance du prochain développeur.
Notre « usine logicielle agentique » tient surtout à cela. Elle transforme progressivement les erreurs de l’équipe en règles exécutables et les décisions ponctuelles en savoir partagé.
L’agent accélère le travail. Le système qui l’entoure permet de lui faire confiance.
Précédent






