Du code artisanal à la software factory

Le logiciel suit le chemin de tous les outils devenus trop utiles : l'invention, l'artisan, puis l'usine. La plupart des devs sont encore à l'atelier. Ceux qui en sortent seront les mieux placés pour configurer les workflows agentiques de tous les autres métiers.

Aujourd’hui, n’importe qui peut cloner un SaaS en trois heures avec un LLM. Une landing, un dashboard, un Stripe branché, et c’est en ligne le soir même.

Savoir shipper ne fait donc plus la différence. Ce qui la fait, c’est de tenir la suite : le centième ticket, le millième client, une codebase multipliée par six en un trimestre.

D’autres industries ont connu ce moment avant le logiciel, et elles en sont toutes sorties par le même chemin.

L’atelier : chaque dev est devenu un artisan augmenté

Le progrès suit souvent trois temps :

  1. Quelqu’un invente un outil.
  2. Des artisans apprennent à le fabriquer à la main. Chacun à sa manière, mais avec des patterns communs et une idée partagée de ce qu’est une bonne conception.
  3. L’outil devient trop utile pour rester cher. Pour faire baisser son coût, on le fabrique en usine, à la chaîne.

La montre a suivi exactement ce chemin. Pendant des siècles, des horlogers la fabriquent pièce par pièce, chaque atelier avec ses méthodes, tous avec les mêmes principes de mécanique. Au milieu du XIXe siècle, des manufactures américaines comme Waltham se mettent à la produire avec des machines et des pièces interchangeables. La montre devient accessible, et le métier se déplace : on ne lime plus chaque rouage, on conçoit, on règle et on contrôle la chaîne.

Le logiciel a eu son invention, puis ses décennies d’artisanat. Le mot est même revendiqué : le mouvement « software craftsmanship » parle de développeurs artisans. Chacun code avec son style, mais tout le monde partage les mêmes repères : design patterns, tests, revue de code, intégration continue.

Les LLM ont d’abord donné de meilleurs outils aux artisans. Chaque dev a son Claude Code ou son Codex (ou même son Cursor), ses prompts, ses skills, sa façon de faire. C’est encore de l’artisanat, juste beaucoup plus rapide.

Sauf qu’un atelier qui va dix fois plus vite reste un atelier.

Le mur : la plupart des devs restent à l’atelier

Je pense que la grande majorité des devs en sont restés à ce deuxième temps. Ils font toujours tout à la main, juste avec Claude Code : lancer l’agent, relire, corriger, merger, recommencer. Ils vont beaucoup plus vite, mais ils ne passent pas à l’étape suivante.

Et à cette vitesse, l’atelier craque. Voici un dépôt réel en production, en lignes de code :

Date Lignes de code Dont tests
Mi-août 230 000 40 000
Mi-septembre 448 000 120 000
Mi-octobre 857 000 310 000
Mi-novembre 1 540 000 661 000

Multiplié par six en trois mois, les tests par seize, plus de 6 900 commits pour une poignée de développeurs. Personne n’a écrit ça à la main : ce sont des devs armés d’IA agentique, chacun dans son coin, qui livrent vite.

Cette vitesse a un prix :

  • la bande passante : plus personne ne relit tout, et les humains passent leurs journées à valider au lieu de décider ;
  • les coûts : en tokens, en CI, en infrastructure, en heures de debug ;
  • la vélocité elle-même : une codebase qui grossit plus vite qu’on ne la comprend finit par ralentir tout le monde, agents compris.

Ce dépôt n’est pas une exception. Chez les équipes qui adoptent l’IA, Faros mesure +98 % de PR mergées, mais aussi +91 % de temps passé en review. On produit deux fois plus de code, et on passe presque deux fois plus de temps à le relire.

Les horlogers ont buté sur le même mur. Ils n’en sont pas sortis avec des artisans plus rapides, mais avec une chaîne.

Dans le logiciel, certains ont déjà franchi le pas, au cas où tu l’aurais loupé :

  • Warp a popularisé le schéma : un agent par étape (triage, spec, implémentation, review, vérification, déploiement, monitoring), déclenché par un événement. Leur billet « crawl, walk, run » est devenu une référence.
  • Stripe fait tourner des Minions, des agents lancés depuis Slack ou un rapport de bug, qui vont jusqu’à la pull request.
  • StrongDM est allé le plus loin, avec une factory où les humains écrivent les spécifications et les scénarios de test, et les agents font le reste.

L’idée n’est même pas neuve : Hitachi avait monté une « software factory » à la fin des années 60, avec des développeurs humains. Ce qui change, c’est qu’aujourd’hui les postes de la chaîne peuvent être tenus par des agents.

Concevoir la chaîne : elle commence avant le ticket

Comme pour la montre, une usine se conçoit, se règle et se contrôle. Le schéma en haut de cet article montre la chaîne entière, de la question à la réponse.

Le schéma classique de la software factory part d’un ticket. Sauf qu’un ticket, c’est déjà le résultat d’un tri : quelqu’un a décidé que la demande méritait du code. Avant ce tri, il y a toutes les questions qui arrivent à l’équipe. Après le déploiement, il y a quelqu’un qui attend toujours sa réponse.

La chaîne a donc trois zones :

  1. Répondre : comprendre la demande, aller chercher les faits, répondre ou préparer la décision.
  2. Construire : la software factory au sens habituel, du ticket au déploiement.
  3. Boucler : corriger les données touchées par le bug, vérifier que l’erreur a disparu, prévenir la personne qui avait demandé.

Pour rendre ça concret, on va suivre une demande fictive de bout en bout. Un account manager écrit dans le canal de l’équipe : « Le remboursement de Durand SA, il en est où ? »

Répondre

L’agent de réponse traite trois demandes distinctes, chacune par un skill différent, puis relit avant de publier

Le même matin, l’agent reçoit deux autres demandes sans rapport, chacune routée vers un skill qui a ses propres règles et ses propres outils. Pour Durand SA, le skill « comptes clients » trouve le remboursement bloqué depuis neuf jours, et la même erreur dans les logs sur onze autres comptes. Il répond à l’AM et ouvre un ticket qualifié.

Deux choses ont fait la différence sur cette zone :

  • deux lecteurs, deux messages : la personne qui demande veut savoir ce qu’elle peut faire et quand elle aura sa réponse, la personne qui tranche veut les faits. Mélanger les deux dans un seul message, c’est rater les deux.
  • le droit de se taire : quand l’agent n’a rien d’utile à ajouter, il ne poste rien. Un bot qui répond « je regarde » à chaque message se fait couper en une semaine.

Construire

Les postes de la software factory, ce que fait chacun, et ce qui arrive au ticket de Durand SA

C’est la partie que tout le monde appelle software factory. Le ticket de Durand SA y passe de poste en poste, et une erreur de prod remontée par le monitoring y entre exactement de la même façon.

Boucler

Après le déploiement : corriger les données, vérifier que l’erreur a disparu, prévenir le demandeur

C’est la zone que la plupart des schémas oublient, alors que c’est la seule que le demandeur voit. Sans elle, les douze comptes resteraient bloqués après le correctif, et l’AM relancerait une semaine plus tard sans savoir que c’est réglé.

Régler la chaîne : trois règles et une boucle quotidienne

Une chaîne qui tourne se dérègle : les règles métier changent, la doc vieillit, des demandes partent au mauvais endroit.

Trois règles valent pour tous les postes, et elles ont compté plus que le choix du modèle :

  • un agent par poste, avec un périmètre étroit, plutôt qu’un agent qui fait tout ;
  • une identité de bot pour chaque agent, jamais la clé d’un humain, pour que l’audit distingue ce qu’a fait la machine ;
  • ouvrir les vannes petit à petit : un poste à la fois, et aucun agent ne bloque un merge ni ne crée un ticket sans un humain, tant qu’il n’a pas fait ses preuves.

Ensuite, la chaîne se règle tous les jours. Chaque matin, un job relit les fils de la veille (les réactions 👍 / 👎, les corrections apportées par un humain) et propose au plus trois corrections : une règle périmée, une erreur de routage, un outil manquant. Le plus souvent, le problème ne vient pas du modèle, mais d’une demande envoyée à la mauvaise personne ou d’une règle qui a changé sans que la doc suive.

Contrôler la chaîne : mesurer avant d’allumer

Le rejeu : l’agent rejoue des demandes déjà traitées, sans rien publier, jusqu’à passer les deux seuils

Une usine sans contrôle qualité produit des défauts à la chaîne. Avec des agents, le contrôle qualité, c’est le rejeu.

Avant de brancher l’agent de réponse sur le canal conformité, je l’ai fait tourner sur 150 demandes déjà traitées, sans rien publier. Puis j’ai comparé ses réponses à ce que l’équipe avait réellement décidé. Une réponse est utile si elle fait gagner du temps à la personne qui tranche, et nuisible si elle contient un fait faux, une mauvaise recommandation, ou une information interne qui fuite vers le demandeur.

Le premier passage était mauvais : allumé tel quel, l’agent aurait été coupé le lendemain, et à raison.

Les corrections qui ont payé étaient des changements de structure, pas des exceptions au cas par cas : séparer les deux messages, relire avant de publier, mettre les règles du domaine directement dans le contexte. Une itération a même fait reculer le score : j’avais ajouté un brouillon de réponse au client, et il produisait l’essentiel des réponses nuisibles. Je l’ai retiré.

On n’a jamais atteint les 80 %. Je l’ai allumé quand même à 75 %, parce que le nuisible était à zéro et que le pré-avis ne décide rien : un humain tranche toujours.

Chaque rejeu coûte quelques dizaines de dollars, beaucoup moins qu’un agent qu’on doit débrancher au bout d’une semaine.

Au-delà du code : les workflows agentiques

Pendant un moment, j’ai cru que mon job, c’était de construire une software factory. Puis j’ai regardé où s’arrêtaient vraiment les demandes qui entrent dans la chaîne :

Cent demandes réparties en huit sorties, avec qui s’en occupe aujourd’hui et qui s’en occupe avec des agents

Environ 80 % se règlent sans une ligne de code. Elles consomment pourtant le temps des gens les plus chers de l’équipe : ceux qui connaissent la base de données, et ceux qui connaissent les règles.

Toute la zone « Répondre » n’a rien à voir avec le software engineering. Un client pose une question sur l’outil de support, et ça déclenche une discussion avec un CS ou un account manager, une recherche dans la doc, parfois une action à la main : modifier la configuration d’un outil, débloquer un compte. Ça pourrait tout aussi bien être une juriste qui ouvre le dossier d’un client.

Ce que je construisais était donc plus large qu’une software factory : un workflow agentique. Des agents déclenchés par des événements, chacun branché sur ses outils et ses règles, avec des humains aux points de décision. La software factory n’en est qu’une zone, celle qui produit du code.

Et chaque métier qui travaille sur un ordinateur a sa propre chaîne : des demandes qui arrivent, des recherches, des décisions, des actions à la main.

Je pense que les devs qui sortent de l’atelier seront les mieux placés pour configurer ces workflows, pour tous les métiers :

  • Ils savent ce qu’une chaîne doit valider. Des années de sprint plannings, de baby steps, de tests, de pipelines d’intégration et de déploiement continus, de codebases qui doivent scaler en complexité comme en performance. Quelqu’un qui vibe code une app en deux heures aura du mal à t’expliquer pourquoi une CI explose, ou comment faire descendre une CI qui prend 40 minutes.
  • Ils l’auront fait en premier, pour leur propre métier. Le domaine est complètement naissant, et ce sont eux qui auront le plus d’expérience dessus.
  • C’est un travail technique. Des branchements dans tous les sens, des droits, parfois de l’infrastructure à configurer. Tout ça est beaucoup moins abstrait pour un tech que pour un non-tech.

C’est peut-être la nouvelle rassurante pour tous les devs en pleine crise existentielle. Demain, un AM senior et un tech pourront tenir le volume d’une équipe de cinq AM aujourd’hui. Et pareil pour le support, la conformité, et sans doute plein d’autres métiers.

Cloner un SaaS en trois heures, tout le monde saura bientôt le faire. Concevoir, régler et contrôler la chaîne qui le fait tourner, c’est là que le métier de dev se déplace, comme celui d’horloger avant lui. Et je ne pense pas que ça s’arrête au logiciel.