La Software Factory : pourquoi former vos développeurs à l'IA ne suffit plus
Utiliser l'IA, ce n'est plus savoir prompter — c'est construire l'usine. Entre les solutions clés en main comme Claude Code ou Codex et une architecture sur mesure qui combine modèles ouverts (ZLM 5.3, DeepSeek), modèles locaux (Qwen 3.8) et modèles frontière (Claude Fable) sur vos propres serveurs, voici comment une entreprise IT bâtit sa Software Factory — et ce que nous avons appris en transformant la nôtre depuis des mois.

Depuis deux ans, les entreprises IT forment leurs développeurs à l'IA : prompter correctement, piloter un agent, fournir le bon contexte. C'était la bonne réponse — hier. Selon la Stack Overflow Developer Survey 2025, 84 % des développeurs utilisent déjà des outils d'IA ou prévoient de le faire : la compétence individuelle est en train de devenir un acquis, pas un avantage. Le vrai chantier s'est déplacé. Il ne s'agit plus d'apprendre à chacun à dialoguer avec un agent, mais de construire l'usine dans laquelle ces agents travaillent : une Software Factory.
Chez nous, Les Entrecodeurs, ce constat n'est pas théorique. Cela fait des mois que nous transformons notre propre manière de produire du logiciel — pour nos produits comme pour les projets de nos clients. Cet article partage ce retour de terrain : ce qu'est une Software Factory, les deux voies pour en construire une, comment arbitrer entre les solutions propriétaires clés en main et une architecture sur mesure — et les objections documentées qu'il faut regarder en face avant d'investir.
Le travail change : de l'ingénieur au bâtisseur
Le métier de développeur a déjà changé deux fois en trois ans. Avant, un ingénieur écrivait du code qui devenait une fonctionnalité. Aujourd'hui, il dialogue avec une IA qui pilote un agent, lequel écrit le code. Demain — et ce demain a déjà commencé dans certaines organisations — un bâtisseur formulera une intention, et une usine logicielle largement autonome la transformera en fonctionnalité livrée, testée et documentée.
Le travail change
Avant
Aujourd'hui
Demain
Ce schéma dit une chose essentielle : la valeur remonte. Elle quitte l'écriture du code — que les agents produisent plus vite et de mieux en mieux — pour se concentrer sur deux points : la qualité de l'intention formulée en amont, et la solidité des points de contrôle en aval. Entre les deux, l'usine tourne. Et comme toute usine, quelqu'un doit la concevoir, la maintenir et l'améliorer.
Qu'est-ce qu'une Software Factory ?
Une Software Factory est un socle outillé et maintenu comme un produit interne : des agents configurés, des compétences réutilisables (skills), du contexte métier structuré, des règles de qualité et des points de contrôle. Les équipes de développement la consomment sans avoir à la construire, comme un opérateur utilise une chaîne de production sans l'avoir conçue — nous reviendrons plus bas sur ce que cette analogie a de trompeur si on la pousse trop loin.
Le terme n'est pas un buzzword de 2026 : l'idée d'industrialiser la production logicielle remonte aux années 1960, et Microsoft publiait déjà « Software Factories » en 2004. Ce qui change aujourd'hui, c'est que les agents d'IA rendent enfin l'ambition exécutable. À ne pas confondre avec les « AI factories » au sens de NVIDIA, qui désignent les datacenters produisant de l'intelligence : ici, il s'agit bien d'une usine qui produit du logiciel.
C'est le basculement organisationnel qui s'annonce dans les entreprises tech : un noyau d'experts qui maintient l'usine en mode produit, et le reste de l'organisation qui l'utilise. Cette architecture a une conséquence directe : une organisation n'a pas besoin que tout le monde « sache utiliser l'IA » au sens profond du terme. Elle a besoin d'une petite équipe qui construit la chaîne, et d'équipes qui peuvent passer directement à l'étape d'après — concevoir, arbitrer, vérifier.
Voie 1 : l'usine sur étagère, avec Claude Code ou Codex
La première voie consiste à bâtir son usine sur une plateforme propriétaire existante. Claude Code d'Anthropic et Codex d'OpenAI sont les deux références du moment : des agents de développement qui s'installent dans le terminal ou s'exécutent dans le cloud, et qui se personnalisent en profondeur — compétences sur mesure (skills), sous-agents spécialisés, hooks qui déclenchent des vérifications automatiques, connexion aux outils internes via le protocole MCP.
Soyons clairs : pour démarrer, ces solutions sont redoutables d'efficacité. En quelques semaines, une équipe monte une première usine fonctionnelle — conventions de code encodées dans des skills, revues automatisées, agents spécialisés par domaine. C'est par là que nous avons commencé, et c'est par là que nous recommandons de commencer à la plupart de nos clients.
Mais cette voie a des limites structurelles qu'il faut connaître avant d'y investir lourdement :
- Dépendance à un fournisseur unique : vos agents tournent sur les modèles d'un seul éditeur, à ses tarifs, selon ses conditions. Un changement de prix ou de politique s'impose à vous.
- Personnalisation bornée par l'outil : vous configurez ce que la plateforme permet de configurer. L'orchestration fine — quel modèle pour quelle tâche, quelle boucle de validation, quelle télémétrie — reste dans les mains de l'éditeur.
- Données qui transitent par un acteur unique : votre code, votre contexte métier et vos échanges passent par l'infrastructure d'un fournisseur américain, avec les questions de gouvernance que cela pose — un arbitrage que nous avons détaillé dans notre article sur l'IA cloud ou locale.
- Obsolescence rapide : ces outils évoluent tous les trimestres. Le CLI soigneusement customisé d'aujourd'hui est le legacy de demain, et la Software Factory elle-même est en train de devenir un produit sur étagère.
Voie 2 : l'usine sur mesure, avec vos propres modèles et votre architecture serveur
La seconde voie consiste à construire l'usine vous-même, sur vos serveurs, en gardant la main sur chaque maillon — à commencer par le choix des modèles. C'est l'approche que nous pratiquons, et elle ne se limite pas aux modèles frontière : des modèles ouverts comme ZLM 5.3 ou DeepSeek pour les tâches de support à fort volume comme la documentation automatisée, du Qwen 3.8 exécuté en local sur nos machines pour les traitements sur données sensibles, et des modèles frontière comme Claude Fable pour la production de code et les décisions structurantes. Derrière une couche de routage commune, changer de modèle devient un paramètre, pas une réécriture.
Ce découplage change tout dans la conception d'une usine logicielle. Le bon modèle au bon endroit : la puissance d'un modèle frontière là où le code part en production et où une mauvaise décision coûte cher, le coût réduit d'un modèle ouvert pour les tâches de support à fort volume comme la documentation, la confidentialité d'un modèle local là où les données l'exigent. Vous basculez de modèle quand les prix ou les performances évoluent — sans toucher à votre code. Et surtout, l'orchestration tourne chez vous : vous décidez quand un agent se lance, avec quel contexte, sous quelle surveillance, et avec quels garde-fous.
- Choix du modèle par tâche : le bon rapport capacité/coût à chaque étape de la chaîne, au lieu d'un modèle unique pour tout.
- Réversibilité totale : un modèle déprécié ou un tarif qui double se gère par configuration, pas par migration.
- Observabilité et maîtrise des coûts : chaque appel est tracé, mesuré, attribué à un projet — la facture IA devient un indicateur de production, pas une surprise de fin de mois.
- Gouvernance des données : le contexte métier, la documentation projet et les artefacts produits restent sur votre infrastructure.
C'est cette voie que Les Entrecodeurs explorent en production depuis des mois, sur notre propre plateforme interne. Concrètement : des sessions d'agents se lancent sur nos serveurs, outillées d'emblée avec le contexte métier du projet concerné — pourquoi le logiciel a été construit ainsi, pour quel client, sous quelles contraintes. Ce que les agents produisent est documenté automatiquement, les contradictions entre le code et la documentation sont détectées et remontées, et les décisions structurantes passent par un arbitrage humain explicite. L'usine produit ; l'humain formule l'intention et tient les points de contrôle. Nous en reparlerons.
Sur étagère ou sur mesure : comment arbitrer ?
La réponse honnête : les deux voies se combinent, et le bon arbitrage dépend de votre volume de production logicielle. Voici les critères qui comptent, tels que nous les utilisons dans nos audits :
- Délai de mise en œuvre : quelques semaines sur étagère, plusieurs mois sur mesure. Si vous partez de zéro, commencez sur étagère.
- Coût d'entrée : un abonnement par développeur d'un côté ; de l'ingénierie d'infrastructure et d'orchestration de l'autre. Le sur mesure ne se justifie qu'à partir d'un volume d'usage soutenu.
- Contrôle des modèles : imposé par l'éditeur sur étagère ; choisi tâche par tâche sur mesure.
- Souveraineté des données : transit obligatoire par l'éditeur sur étagère ; gouvernance complète sur mesure, y compris la possibilité de router les données sensibles vers des modèles ouverts auto-hébergés.
- Maintenance : assurée par l'éditeur sur étagère — avec son rythme et ses ruptures ; assurée par votre noyau d'experts sur mesure — un vrai coût, mais un vrai actif.
- Réversibilité : faible sur étagère, vos skills et workflows étant liés à la plateforme ; élevée sur mesure, le routage multi-modèles étant le cœur du système.
Dans la pratique, le schéma qui émerge chez les organisations matures est hybride : des outils sur étagère comme postes de travail des développeurs, et une orchestration sur mesure pour la production industrielle — les traitements de masse, les agents longue durée, les chaînes qui touchent aux données clients. L'un n'exclut pas l'autre ; l'un prépare l'autre.
Les objections qu'il faut regarder en face
La Software Factory n'est pas une promesse sans friction : le terrain documente des effets pervers réels, et un goulot d'étranglement que nous constatons sur notre propre usine. Mieux vaut les regarder en face que les découvrir en production. Voici les cinq objections les plus sérieuses — et ce que nous en faisons.
« Une usine qui produit du code plus vite que les humains ne peuvent le vérifier ne fait que déplacer le goulot d'étranglement. »
C'est exact, et nous en témoignons : c'est le plus gros problème que nous rencontrons. La fiabilité des agents se compose mal — enchaînez dix étapes fiables à 95 % chacune, et l'ensemble ne l'est plus qu'à 60 % — si bien que le goulot s'est déplacé vers la relecture humaine. Chez nous, c'est sur l'UI et l'UX que le phénomène est le plus net : il faut beaucoup revenir sur ce que les agents produisent, les décisions prises en amont sont parfois mal comprises, et nous devons repasser en mode manuel. Notre réponse : traiter les points de contrôle comme une partie de l'usine — revues outillées, tests systématiques, documentation automatique de ce que les agents produisent, arbitrage humain explicite sur les décisions structurantes — et dimensionner le débit de production sur la capacité de vérification, pas l'inverse.
« L'IA amplifie ce qui existe déjà : une organisation désordonnée aura une usine qui produit du désordre plus vite. »
Vrai aussi. Les mesures à grande échelle sur le code produit avec IA vont toutes dans le même sens : le débit de livraison monte, mais l'instabilité des déploiements aussi, et la duplication de code explose pendant que le refactoring recule. Une Software Factory sans discipline industrialise de la dette technique. C'est pourquoi les conventions, les seuils de qualité et le refactoring font partie de l'usine elle-même — pas d'un nettoyage en aval.
« Une usine sur mesure, c'est un système critique de plus au cœur de l'entreprise — qu'il faudra maintenir pendant des années. »
Nous connaissons bien cette objection : c'est l'histoire des frameworks PHP ou JavaScript maison que les agences installaient chez leurs clients dans les années 2000-2010, et qu'il a fallu maintenir, documenter et faire évoluer bien après le départ de leurs auteurs. Une Software Factory sur mesure obéit à la même loi : sans équipe dédiée, elle pourrit. C'est pour cela que nous la traitons comme un produit — avec une feuille de route, des versions, de la documentation — et non comme un projet interne de plus. Si vous ne pouvez pas dédier ce noyau, l'étagère est la bonne réponse.
« Les études montrent que l'IA ralentit les développeurs expérimentés sur les projets qu'ils connaissent par cœur. »
Une étude de 2025 l'a effectivement mesuré, sur des développeurs travaillant sur des dépôts qu'ils connaissaient intimement. Mais son périmètre est la clé : un ingénieur sur une poignée de projets maîtrisés, dont tout le contexte est déjà dans sa tête. Une agence qui livre et maintient des dizaines de projets clients par an vit la situation inverse : personne ne connaît tout par cœur, et l'essentiel du temps se perd à retrouver une logique d'architecture ou une règle métier enfouie. C'est exactement ce que l'usine fait pour nous — le contexte de chaque projet est structuré, interrogeable, à jour — et nous le constatons jusque sur les projets que nous connaissions par cœur : interroger l'usine va plus vite que relire le code.
« Si l'usine absorbe le travail des juniors, d'où viendront les tech leads de 2030 ? »
C'est l'objection la plus sérieuse — et presque une question politique. L'embauche de développeurs débutants s'est effondrée dans toute la tech, et une organisation « noyau d'experts + utilisateurs » consomme des tech leads sans en produire. C'est aussi là que l'analogie de l'usine atteint sa limite : le système Toyota ne sépare justement pas ceux qui pensent la chaîne de ceux qui l'exécutent — chaque opérateur peut l'arrêter (andon) et participe à son amélioration continue (kaizen). Mais même correctement lue, l'analogie ne dit pas comment on forme des tech leads qui ne touchent plus au code ni à certains aspects techniques. Nous préférons laisser la question ouverte plutôt que de vendre une réponse toute faite — nous y répondrons peut-être un jour.
Que reste-t-il du métier de développeur ?
L'essentiel — mais pas là où on le cherchait. Quand l'usine produit le code, le métier revient à son socle d'ingénierie logicielle : étudier les choix techniques et leurs impacts, faire des arbitrages pour prendre de bonnes décisions, définir et vérifier les points de contrôle. Trois compétences qui, dans beaucoup d'organisations, sont aujourd'hui associées au poste de tech lead plutôt qu'à celui de développeur.
C'est pourquoi la formation à mener dans les mois qui viennent n'est pas « apprendre l'IA à tout le monde » : c'est apprendre à tout le monde à penser comme un tech lead. Formuler une intention précise, savoir ce qu'on attend d'une fonctionnalité avant qu'elle soit produite, lire un diff avec un œil critique, refuser ce qui ne passe pas les points de contrôle. Ce sont ces compétences-là qui font la différence entre une usine qui produit de la valeur et une usine qui produit du volume — un sujet que nous avions déjà posé dans notre article sur l'IA comme système d'information.
Par où commencer ?
Pour une PME ou une ETI qui produit du logiciel — en interne ou via des prestataires — la trajectoire raisonnable tient en trois étapes :
- Auditer la chaîne de production actuelle : où passe le temps, quelles tâches sont répétitives, où les erreurs coûtent cher. L'usine se construit sur ces points-là, pas sur les démos spectaculaires.
- Monter un pilote sur étagère : Claude Code ou Codex sur un périmètre réel, avec des conventions encodées en skills et des points de contrôle explicites. Mesurer : vitesse, qualité, coût par fonctionnalité livrée.
- Industrialiser sur mesure quand le volume le justifie : passer l'orchestration sur vos serveurs, router chaque tâche vers le bon modèle — ouvert, local ou frontière —, centraliser le contexte métier et la documentation. C'est là que l'usine devient un actif de l'entreprise, pas un abonnement.
À propos de l'auteur
Flavien Bigi
Gérant des Entrecodeurs, chef de projet IT
Chef de projet IT depuis 2016, Flavien Bigi dirige Les Entrecodeurs. Il intervient sur les projets d'intelligence artificielle en entreprise — audits de système d'information, accès aux données, architectures de recherche augmentée et encadrement des agents — et accompagne les dirigeants de PME et d'ETI dans leurs arbitrages techniques.
Questions fréquentes
- Qu'est-ce qu'une Software Factory selon Les Entrecodeurs ?
- Les Entrecodeurs définissent la Software Factory comme un produit interne qui industrialise la production de logiciel par des agents IA : contexte métier centralisé, compétences réutilisables, orchestration des agents, règles de qualité et points de contrôle humains. Un noyau d'experts la maintient, les équipes de développement la consomment — comme une chaîne de production dans une usine.
- Comment Les Entrecodeurs aident-ils à choisir entre Claude Code et une architecture sur mesure ?
- Les Entrecodeurs arbitrent sur six critères : délai de mise en œuvre, coût d'entrée, contrôle des modèles, souveraineté des données, maintenance et réversibilité. En pratique, nous recommandons de démarrer sur étagère avec Claude Code ou Codex, puis d'industrialiser sur mesure quand le volume d'usage le justifie. Nos [services en intelligence artificielle](/services/intelligence-artificielle) couvrent les deux étapes.
- Pourquoi combiner plusieurs modèles d'IA plutôt qu'un seul fournisseur ?
- Combiner plusieurs modèles permet de choisir le bon rapport capacité/coût par tâche : des modèles ouverts comme ZLM 5.3 ou DeepSeek pour les tâches de support à fort volume comme la documentation automatisée, un modèle local comme Qwen 3.8 pour les données sensibles, un modèle frontière comme Claude Fable pour la production de code et les décisions structurantes. Les Entrecodeurs appliquent ce routage sur leur propre usine — un arbitrage détaillé dans [notre article cloud ou local](/blog/ia-cloud-ou-local).
- Quel est le principal obstacle à une Software Factory selon Les Entrecodeurs ?
- Le goulot d'étranglement de la vérification : l'usine produit du code plus vite que les humains ne peuvent le contrôler, un constat que Les Entrecodeurs font sur leur propre usine et que les analyses de 2026 confirment. La réponse consiste à traiter les points de contrôle comme une partie du produit — revues outillées, tests, documentation automatique — et à dimensionner le débit de production sur la capacité de vérification.
- Les développeurs vont-ils disparaître avec les Software Factories ?
- Non — mais le métier se déplace. Quand l'usine produit le code, le développeur revient au socle de l'ingénierie logicielle : étudier les choix techniques, arbitrer, définir et vérifier les points de contrôle. Ce sont les compétences du tech lead qui deviennent la norme. Les Entrecodeurs constatent ce déplacement sur leurs propres équipes depuis plusieurs mois.
Sources
- Stack Overflow Developer Survey 2025 — section IA
- Claude Code — documentation officielle Anthropic
- Codex — documentation officielle OpenAI
- Qwen 3.8 — benchmarks et configuration requise
- Google DORA — State of AI-assisted Software Development 2025
- GitClear — Write-Only Mode: AI Code Quality in 2026
- METR — étude sur les développeurs expérimentés (via InfoWorld)
- Forum économique mondial — d'où viendront les développeurs seniors ?
À lire ensuite
L'IA, un sujet de SI
D'après ce que nous observons sur nos projets, tout se joue quand une entreprise devient une grosse TPE — une dizaine de salariés, plusieurs services. L'intelligence artificielle cesse alors d'être un outil qu'on achète : elle devient une couche du système d'information, et elle se construit avec des professionnels du SI, pas avec des experts de l'usage de ChatGPT. Ce que ça change concrètement : le choix de l'ERP, les droits par service, l'encadrement des agents, et l'auditabilité qui en découle.
Intelligence artificielleIA : cloud ou local ?
Le nouveau Mac Studio M5 Ultra embarque jusqu'à 512 Go de mémoire unifiée et 1,2 To/s de bande passante : de quoi faire tourner de très grands modèles d'IA sans datacenter. Faut-il rapatrier votre IA en entreprise ? Ce que le matériel permet vraiment, ce que ça coûte, et ce que ça change pour vos données.