Le problème n’est plus d’écrire du code

Le gain IA sur le développement est réel, et il plafonne. Ce plafond est mesuré : le Do Tank CAST × Cigref relève 20,75 % de gain moyen sur 83 DSI françaises, contre 11 % un an plus tôt. Le rapport DORA d’avril 2026 explique l’écart. On observe 35 à 40 % de gain sur du code neuf, mais 10 % ou moins sur du legacy complexe, et DORA en tire une formule nette : l’IA est un amplificateur, pas un transformateur.

J’ai développé ce diagnostic ailleurs — les gains IA plafonnent parce que la chaîne autour du Build n’a pas bougé. Scaled Agile a publié la même analyse en juin 2026 en annonçant AI-Native SAFe : le goulot d’étranglement s’est déplacé, et les organisations doivent sortir de pilotes IA fragmentés.

Cet article traite donc la suite. Pas le diagnostic, mais le chemin. Où vous situer, ce que contient concrètement une chaîne outillée de bout en bout, et quelles populations elle renforce.

Cinq niveaux de maturité, et la plupart des DSI sont au deuxième

Or l’erreur classique consiste à viser un niveau cible sans savoir d’où l’on part. Chaque marche règle un problème d’échelle et en ouvre un autre. La question utile n’est donc pas « où veut-on aller », mais « quel problème veut-on régler maintenant ».

Ce qui se partage grandit à chaque marche : rien, puis un texte, puis une procédure, puis un outillage, enfin un système gouverné.

Les trois premières marches : un texte, puis une procédure

Niveau 1 — chacun ses prompts. Chaque collaborateur écrit dans son chat et garde pour lui. Démarrage immédiat, coût limité aux licences. En contrepartie, la qualité dépend de chaque personne, le savoir-faire part avec elle, et personne ne maîtrise ce qui est collé dans les conversations.

Niveau 2 — prompts et assistants partagés. Les prompts qui marchent entrent dans une bibliothèque commune, ou se figent dans un assistant préconfiguré. Les galeries Copilot, les GPTs et les Gems relèvent de ce niveau. Ainsi un premier langage commun apparaît, sans aucun développement. Mais un texte copié devient un texte modifié par chacun : ni version, ni responsable, ni contrôle. Et un assistant par besoin ne s’enchaîne pas avec les autres.

Niveau 3 — skills packagées. Une skill regroupe instructions, modèles et fichiers de référence, que l’assistant charge quand la tâche le demande. Un relecteur de contrat, un analyseur d’impact d’architecture. Le savoir-faire devient un objet partagé et maintenu, les résultats s’homogénéisent. Le standard Agent Skills publié par Anthropic fin 2025 est ouvert, et plus de trente outils l’ont adopté, ce qui protège l’investissement. En revanche, chacun installe ses skills, les versions divergent, et surtout les règles restent du conseil. L’IA peut s’en écarter.

Les deux dernières marches : l’outillage, puis la gouvernance

Niveau 4 — plugins complets. Un plugin est un paquet versionné qui installe ensemble skills, commandes, règles, hooks et connecteurs MCP sur chaque poste. Une installation, une version, la même pratique pour tous. Changement de nature : les hooks appliquent les règles au lieu de les rappeler. Mais en face, un produit à développer, tester et maintenir, et chaque serveur MCP ouvre un accès à qualifier.

Niveau 5 — écosystème gouverné. Un plugin socle porte les faits et les règles communs, des plugins métier s’appuient dessus, un catalogue d’organisation les distribue. Une seule source de vérité pour toutes les directions, et des parcours complets plutôt que des tâches isolées. Le prix à payer, en revanche, est une gouvernance : un propriétaire, des évaluations, une revue de sécurité, et la vigilance sur un socle recopié qui peut diverger.

Je fais tourner cet écosystème sur ma propre activité : quatre plugins, un socle de vérité partagé, des orchestrateurs de bout en bout et un contrôle qualité sur chaque livrable. Ce n’est pas une projection théorique.

Pourquoi un prompt ne garantit rien

Or le passage du niveau 3 au niveau 4 est le seul qui change la nature de ce qu’on obtient. Avant lui, on partage des intentions. Après lui, on partage des garanties. Trois défaillances expliquent pourquoi l’arrêt aux premiers niveaux ne tient pas à l’échelle.

Les règles vivent en dehors de l’outil qui écrit. Elles sont dans les têtes, dans un wiki, dans des commentaires de revue — jamais dans la chose qui génère. Par conséquent, on les réapprend à chaque projet et on les applique quand quelqu’un y pense.

Un prompt ne garantit rien. Bien demander va vite, mais rien n’est reproductible, rien n’est tracé, et le contexte a disparu à la session suivante. Deux développeurs, deux prompts, deux résultats, et aucun moyen de dire lequel était conforme.

La posture change. On n’écrit plus seulement l’application : on outille et on opère la chaîne qui la produit. Générer est devenu bon marché en dix-huit mois. Vérifier, non. Ce qui devient rare, c’est la vérification.

Quatre symptômes, une seule cause

Sur le terrain, ça produit donc quatre symptômes que vous reconnaîtrez peut-être. Le débit monte et la confiance baisse — on livre plus qu’avant, sans pouvoir dire si c’est juste. Les revues approuvent — quatre cents lignes, vingt minutes, « ça me paraît bon ». Chaque étape repart de zéro — « rappelle-moi pourquoi on avait décidé ça ». Et personne ne sait énoncer les limites — « est-ce qu’on avait le droit de toucher à ce fichier ? ».

Quatre symptômes, une seule cause : personne n’a jamais écrit les points de contrôle quelque part qu’une machine puisse lire.

D’où la position que je défends sans nuance. Une règle sans machine derrière ne tient que tant que l’acteur y pense. Le jour où personne n’y pense, elle n’existe pas.

Ce que contient un atelier agentique de bout en bout

OM-CRAFT est l’atelier que j’ai construit, puis instancié en contexte client. Je l’ai tiré de mon propre cadre de travail quotidien, je l’ai confronté à une vraie chaîne de livraison avec ses outils et ses portes, puis je l’ai découpé en vingt-six facettes rejouables dans n’importe quel contexte.

Trois objets, donc, dans un seul dépôt versionné. Un plugin que l’agent des équipes charge. Une doctrine écrite que cet agent lit, dont chaque règle porte sa source et se vérifie une par une. Des ateliers d’instanciation avec vos équipes, une facette à la fois.

Le poste de travail devient l’agent en ligne de commande — Claude Code, Gemini CLI, Codex. L’agent est le moteur, le plugin la boîte de vitesses. Changer de modèle ne change donc pas la pratique.

Plan et Build : 24 commandes jusqu’au code relu

Le découpage suit les chaînes de valeur IT4IT, et non une logique d’outil. C’est ce qui permet à un CIO de voir immédiatement ce qui est couvert, ce qui ne l’est pas, et pourquoi.

Plan — Strategy to Portfolio, 5 commandes. demand-triage qualifie une demande brute contre votre propre référentiel d’architecture : services métier, parcours, activités touchées. Elle dimensionne par l’étendue d’impact, résout les équipes par lecture de la carte des responsabilités, et s’arrête si le référentiel ne dit rien. Ensuite portfolio-gate formalise l’epic, pose l’hypothèse de valeur et le périmètre explicite. risk-new et risk-sweep instruisent les risques. Ce qui en sort : une demande qualifiée et dimensionnée, un élément de portefeuille qui passe sa porte ou qui est refusé en nommant qui peut lever le blocage.

Build — Requirement to Deploy, 19 commandes. C’est de loin le cœur de l’atelier, et le plus dense. feature-new et feature-extend produisent une feature avec sa table d’exigences non fonctionnelles et sa matrice de couverture. story-decompose découpe verticalement, story-new et iteration-plan ordonnancent. Puis story-start ouvre une branche en commitant le plan avant le code. test-plan, test-run et test-gate tiennent la discipline de test. Enfin story-review, review-code et story-finish ferment la boucle, pendant que debtfixer traite la dette identifiée en chemin.

Deliver — Request to Fulfil, aucune commande, et c’est déclaré. Déployer n’est pas activer. Ce geste appartient à votre pipeline. La doctrine en fixe les règles, mais rien dans l’atelier ne les exécute. Un périmètre annoncé vaut toujours mieux qu’une couverture floue découverte en projet.

Run — Detect to Correct, aucune commande, et c’est déclaré. La gestion des incidents et des problèmes reste hors périmètre, pour la même raison.

Improve et Foundation : la boucle et le socle

Improve, 4 commandes. retro instruit la rétrospective, puis a3 et root-cause produisent une fiche et une chaîne causale. Surtout, capitalize verse l’enseignement dans la doctrine — donc dans chaque projet suivant. C’est la commande la plus sous-estimée et la plus structurante.

Foundation, 7 commandes. bootstrap-project initialise un projet avec son miroir daté de la doctrine. doctordiagnostique si l’installation est saine. Enfin sync-standards réaligne, connector-setup branche les sources d’autorité, et tool-mapping cartographie les portes et les livrables de votre chaîne réelle.

Dix-huit de ces commandes servent un processus nommé sur la carte d’un modèle opérationnel. Les dix-sept autres non, et ce n’est pourtant pas un manque : une carte de modèle opérationnel nomme ce qu’une organisation fait, pas comment on construit. C’est précisément là que se loge l’expérience terrain.

Les populations dont la productivité change vraiment

La question que pose tout CIO est légitime : qui gagne quoi ? Voici donc la réponse, population par population.

En amont : de la demande au backlog prêt

Le demandeur métier et le demand manager. Ils reçoivent une demande instruite, au lieu d’une demande à instruire. L’agent lit la taille, l’impact et les équipes concernées dans le référentiel, au lieu de les deviner. L’agent ne remplit pas une case par une valeur plausible : une case vide reste une question posée, adressée à quelqu’un de nommé.

Le portfolio manager et l’Epic Owner. Le dossier arrive complet pour l’arbitrage, avec hypothèse de valeur et périmètre explicite. En revanche, ce qui relève de la cérémonie reste à la cérémonie : des personnes fixent le coût du retard, la taille et le WSJF. L’agent prépare la décision, il ne la prend pas.

Le Product Manager et le Product Owner. C’est le gisement le plus fort, et le moins anticipé. Une feature sort avec ses exigences, ses exemples issus du métier, sa table non fonctionnelle et sa matrice de couverture. Le découpage en stories est vertical, et chaque critère d’acceptation mène à un test. Pas de critère, pas de story. L’atelier remonte alors les ambiguïtés, au lieu de les trancher en douce.

En aval : de la branche jusqu’à la traçabilité

L’Enterprise Architect et le System Architect. L’analyse d’impact devient un geste de quelques minutes au lieu d’un atelier. L’agent parcourt les relations du modèle, couche par couche, à partir d’un changement. Condition impérative, toutefois : l’analyse ne vaut que ce que vaut le modèle. Un référentiel incomplet produit une analyse incomplète, et l’atelier le dit plutôt que de combler.

L’ingénieur. L’ingénieur commite le plan avant le code, ce qui rend la revue argumentable. Les tests reprennent ensuite les exemples que le métier a validés. La porte de qualité passe au vert, ou elle ne passe pas.

Le relecteur et le test lead. La revue devient adversariale. Trois relecteurs séparés, avec des entrées différentes : le premier voit les critères et le code et traque les critères orphelins, le deuxième ne voit que le diff et cherche à casser sans connaître l’intention, le troisième parcourt systématiquement les chemins limites. Tous restent en lecture seule. Trouver et corriger sont deux actes séparés, comme une séparation des tâches, parce qu’un relecteur qui répare est un co-auteur qui se relit.

Le CIO Office, le risk owner et le facilitateur. Ils obtiennent enfin ce qui manque le plus : la traçabilité. Chaque artefact porte l’identifiant de sa demande, chaque porte a un décideur nommé, et chaque leçon redescend dans tous les projets par un commit.

Sur toute la chaîne, le gain n’est donc jamais « l’IA fait à votre place ». Il est que chaque population reçoit un dossier instruit, et passe son temps à décider plutôt qu’à rassembler.

Quatre couches, et ce que l’atelier refuse de faire

La plupart des organisations s’arrêtent pourtant à la première couche et appellent ça un framework.

La doctrine énonce ce qu’on tient pour vrai, avec la provenance de chaque règle. Vous obtenez une charte. Les commandes sont les gestes qui l’appliquent, un artefact à la fois. Vous obtenez une méthode. Les gardes définissent ce qui ne peut pas arriver, quoi que quelqu’un décide sur le moment. Vous obtenez des garanties. Enfin le filet contrôle la configuration de l’atelier lui-même. Vous obtenez la certitude que les trois premières ne s’érodent pas.

Une règle se porte à quatre niveaux, et les deux derniers manquent presque toujours. D’abord, la doctrine conseille et attrape ce qui demande du jugement. Ensuite, le hook bloque au moment de l’acte et attrape ce qui doit tenir sans exception. Puis la revue vérifie après coup et attrape ce qu’aucune règle n’avait prévu. Enfin, le test de non-régression attrape la doctrine qu’on casse en la modifiant. La doctrine classe chaque règle : imposée, vérifiée ou conseillée. Rien entre les deux.

Même principe à chaque porte de la chaîne : rien n’est terminé sans un artefact versionné, une porte humaine nommée et une métrique. Pas un compte rendu de réunion, pas un statut qui change tout seul.

Ce que l’atelier refuse de faire

C’est d’ailleurs la liste des refus qui surprend le plus en démonstration. L’atelier n’estime pas : coût du retard et taille se fixent en cérémonie, et l’agent laisse les cases vides. Il n’approuve pas davantage : un verdict n’est pas une approbation, et le relecteur n’est jamais l’auteur. Une porte de décision, ensuite, il ne la franchit pas : il prépare seulement ce dont elle a besoin. Il ne corrige pas ce qu’il trouve, parce qu’un correctif automatique supprime le moment où une personne décide s’il est souhaitable. Il n’invente aucun seuil non fonctionnel, parce qu’un seuil plausible devient un engagement contractuel fabriqué — pire qu’une ligne vide, puisqu’une ligne vide, elle, se voit. Et il ne construit pas ce qui n’est pas prêt : il le dit, en nommant les critères non satisfaits et qui peut les lever.

Ce sont ainsi dix refus, chacun rattaché à un fichier de doctrine qui le porte. Ce ne sont pas des principes affichés, ce sont des adresses.

Le coût est mesuré, pas estimé

Enfin, dernier point, et c’est celui que les COMEX demandent en premier : le coût est mesuré, pas estimé. J’ai rejoué la chaîne complète, de l’initialisation du projet jusqu’à la capitalisation de la leçon, sans personne au clavier. Cinquante-cinq sessions, cent quatre-vingt-dix-neuf minutes de travail machine. Vérifier prend des secondes, écrire un artefact prend des minutes, découper une feature et relire du code sont les gestes chers. Je ne revendique en revanche aucun chiffre de productivité : les gains se lisent dans la métrique de chaque pratique, pas dans une promesse globale.

Comment l’atelier s’adapte à votre contexte

Un atelier générique qu’on installe tel quel ne survit pas à la première semaine. OM-CRAFT se vend donc facette par facette, et chaque facette se joue en atelier avec vos équipes. L’adaptation se fait là, pas dans un écran de paramétrage.

Ce qui arrive déjà fait, et ce qui se construit avec vous

Chaque facette annonce d’avance son niveau de preuve. Certaines tiennent d’une expérience terrain déjà payée, d’autres ont passé une mise à l’épreuve en conditions réelles, les dernières se co-conçoivent avec vous. Vous savez donc, avant d’entrer dans la salle, ce que vous pourrez revendiquer et ce qui reste à écrire.

Même transparence sur la variabilité d’adaptation. Dix-sept facettes bougent peu d’un client à l’autre, six moyennement, deux fortement. Celles qui bougent le plus touchent précisément vos processus propres.

La doctrine contient par ailleurs près de deux cents emplacements explicitement marqués à remplir. L’atelier ne les devine jamais. Mieux : il dit ce que vous perdez si la réponse est « personne ». Un propriétaire de persona introuvable ne bloque pas le travail — mais l’hypothèse de valeur s’écrit alors contre un utilisateur que personne n’a rencontré, et le document l’indique noir sur blanc.

Enfin, une liste fermée nomme tout ce que l’atelier ne livre pas, chaque absence avec sa raison. Rien ne se découvre en cours de mission.

Le raccordement à votre chaîne logicielle existante

L’adaptation ne porte pas que sur vos processus. Elle porte aussi sur l’outillage que vous avez déjà.

Une commande cartographie vos portes et vos livrables réels : qui fait autorité sur quel type d’artefact, par quelle transition nommée, avec quel déclencheur. Une autre branche vos sources d’autorité — référentiel d’exigences, modèle d’architecture, dépôts de code — en respectant une identité par personne, jamais un jeton partagé.

Le socle reste ensuite volontairement agnostique de votre stack technique. Vos idiomes, vos conventions et vos règles de langage arrivent en extension, jamais en duplication du socle. Même logique côté agent : la pratique se porte d’un runtime à l’autre, parce que le plugin porte la doctrine pendant que l’agent ne porte que la puissance.

Le cadre d’action : quatre questions pour vous situer

Avant de choisir une cible, posez d’abord le diagnostic. Quatre questions, testables en une heure avec vos équipes.

1. Sur quelle marche êtes-vous réellement ? Pas la marche que vous visez. Celle où se trouve la majorité de vos équipes aujourd’hui, prompts individuels compris.
2. Vos règles d’ingénierie sont-elles lisibles par une machine ? Si elles vivent dans un wiki ou dans des commentaires de revue, elles s’appliquent quand quelqu’un y pense.
3. Chaque porte produit-elle un artefact, un décideur nommé et une métrique ? Ou une réunion et un changement de statut ?
4. Qui est propriétaire de la configuration de vos agents ? Si la réponse est personne, cette configuration dérive sans que personne le voie — et c’est du code, au même titre que l’application.

Si vous butez sur deux de ces quatre questions, le problème n’est pas votre outillage IA. C’est votre Product Operating Model.

Pour aller plus loin

Finalement, le point de contrôle remonte, et il passe dans la machine. Ce qui était relu devient empêché, ce qui était recommandé devient vérifié. C’est le seul mouvement qui transforme un gain local sur le Build en valeur livrée.

Reste enfin la question que je pose à chaque DSI que j’accompagne, et qui met rarement moins d’une heure à trouver sa réponse honnête : parmi les règles que vous considérez comme non négociables, combien sont aujourd’hui portées par une machine ?

Pour poser le diagnostic sur votre situation en 30 minutes : prendre rendez-vous

Sources : Do Tank CAST × Cigref, « Rupture structurelle dans l’ingénierie logicielle », février-mars 2026 · DORA / Google Cloud, « The ROI of AI-Assisted Software Development » (2026.1), avril 2026 · Scaled Agile, AI-Native SAFe, juin 2026 · Standard Agent Skills, Anthropic, décembre 2025 · The Open Group, référentiel IT4IT.

L’article SDLC IA : les 5 niveaux de maturité, du prompt au plugin est apparu en premier sur Agile Enterprise Partner.