Un configurateur produit vieux de vingt ans, dont les règles vivaient dans des procédures stockées. Nous le reconstruisons contexte métier par contexte métier, avec une chaîne de production assistée par IA et vérifiée par script.

Discac conçoit et fabrique des meubles sur-mesure. Derrière chaque référence vendue se cache une combinatoire : un squelette de produit, des composants, des finitions, des coloris techniques, des programmes de fabrication, des règles de compatibilité, un tarif qui dépend de tout cela. Cette combinatoire était pilotée depuis vingt ans par un configurateur maison, dont l'essentiel des règles vivait dans des procédures stockées en base.
Ce genre de système fonctionne. Jusqu'au jour où il faut le faire évoluer.
Quand nous sommes arrivés, le diagnostic évident était technique : une base de données qui portait la logique métier, pas de tests, une interface d'un autre âge. Le diagnostic réel était ailleurs.
La connaissance métier n'était écrite nulle part. Elle était répartie entre le code, les procédures stockées, et surtout la tête de quelques personnes — au bureau d'études, à l'administration des ventes, à l'ordonnancement, à l'atelier. Chacun avait raison dans son périmètre, et les mêmes mots ne désignaient pas les mêmes choses d'un service à l'autre.
Reconstruire le logiciel sans d'abord reconstruire ce vocabulaire, c'était la garantie de réécrire les malentendus en TypeScript.
Nous avons commencé par découper le système en douze contextes métier, chacun répondant à une seule question : que vend-on ?, combien ça coûte ?, comment le fabrique-t-on ?, quelle commande le client passe-t-il ?, quand produit-on ?, comment le livre-t-on ?
Ce découpage n'est pas un diagramme d'architecte. C'est une règle de rangement opérationnelle : une donnée appartient au contexte dont les acteurs la font évoluer, pour leurs raisons à eux. Un contexte référence les données d'un autre par identifiant, jamais en les recopiant. Quand une nouvelle fonctionnalité arrive, la question « où va-t-elle ? » a une réponse, et c'est toujours la même.
En parallèle, un glossaire métier versionné s'est construit, contexte par contexte, avec la correspondance explicite vers les termes du système historique. Chaque terme y a une définition unique, validée par les personnes qui l'emploient. Ce fichier est devenu la source de vérité du projet : le code, les tickets, les tests et les écrans en reprennent les mots exacts.
Chaque fonctionnalité suit le même chemin, et ce chemin est outillé.
Un atelier d'impact mapping mené avec le client part de l'objectif — jamais de la solution — et descend jusqu'aux user stories, avec leurs règles et leurs exemples écrits dans un format que le client relit. L'atelier produit un fichier structuré et versionné, pas un compte rendu.
De ce fichier, nous dérivons un contrat exécutable en TypeScript : les types, la surface d'erreur complète, et les scénarios d'acceptation déclaratifs. Ce contrat est validé mécaniquement — un script refuse un contrat incomplet — puis figé et commité avant que la première ligne de code métier n'existe.
L'implémentation part de ce contrat : les tests d'abord, rouges, sur cinq couches (domaine, intégration, HTTP, interface, end-to-end), puis le code qui les fait passer au vert. Entre les deux, rien n'est laissé à l'interprétation : le contrat dit la route, le verbe, les erreurs possibles et les types.
“Un manque dans le code se corrige dans le code. Un manque dans le métier remonte au client. La chaîne est conçue pour que personne, humain ou agent, ne comble un trou métier en devinant.”
C'est là que le projet sort de l'ordinaire. L'ensemble de cette chaîne est exécuté par des agents — aujourd'hui quarante skills Claude Code versionnés dans le dépôt — répartis en deux pistes : la discovery (« construit-on la bonne chose ? ») et la delivery (« le construisons-nous bien ? »).
Un prototype frontend est généré à partir du vrai code, avec les appels réseau remplacés par des données en mémoire : le client valide l'interface sur quelque chose de manipulable, avant tout développement backend. Un agent compare ensuite l'application livrée à ce prototype, écran par écran, et archive le verdict.
Mais le point décisif n'est pas ce que les agents produisent. C'est ce qui les arrête.
Nous ne faisons pas relire l'IA par l'IA. La norme du projet est tenue par soixante-neuf vérifications déterministes — des scripts, pas des revues : l'arborescence d'un slice, la pureté du domaine, la correspondance entre le contrat et son adaptateur, l'absence de SQL brut côté écriture, la présence des cinq couches de test, la forme du message de commit. Un agent qui s'écarte de la norme est bloqué par un script qui donne toujours le même verdict, pas par un relecteur de bonne humeur variable.
Les décisions, elles, sont écrites : plus de six cent cinquante décisions d'architecture datées, chacune citable par les skills et par l'équipe. C'est ce qui permet à une session d'agent ouverte un mardi matin de respecter un arbitrage pris six mois plus tôt, sans que personne n'ait à s'en souvenir.
Le système en production couvre aujourd'hui le catalogue produit, la configuration, la tarification, la saisie de commande et son accusé de réception, l'ordonnancement, l'expédition, et les échanges avec l'ERP et le logiciel d'atelier.
Les effets concrets, côté client :
Un logiciel métier n'est pas difficile parce qu'il est gros. Il est difficile parce que la connaissance qu'il encode est dispersée, implicite, et parfois contradictoire. L'IA ne résout pas ce problème — elle l'amplifie si on la lâche sans cadre, parce qu'elle produit du code plausible à une vitesse que personne ne peut relire.
Ce qui marche, et que nous appliquons depuis sur nos autres projets : capturer le jugement métier une seule fois, en atelier, avec le client ; le figer dans un artefact que la machine sait vérifier ; et ne laisser aux agents que ce qui est dérivable de cet artefact.
Le reste — l'arbitrage, le découpage, la décision — reste le métier de l'équipe.