Une production logicielle largement autonome, pilotée par des intentions et validée par des preuves : la Dark Factory a tout d'un horizon, et j'y crois. Elle se construit en plaçant l'usine au centre du système, en la confiant à une capacité Product Builder qui couvre la Tech, le Produit, le Design et la Qualité, et en y encodant tout ce que l'ingénierie logicielle sait déjà faire.
Vous exprimez une intention, et des agents vous rendent un produit prêt à partir en production. Avouez que la promesse est séduisante ! Elle a même un nom depuis que Dan Shapiro a classé les niveaux d'autonomie du développement logiciel. La Dark Factory, c'est le dernier niveau : une usine qui tournerait lumières éteintes, puisque plus personne n'a besoin d'y voir clair. Les expérimentations de StrongDM ont montré qu'on pouvait s'en approcher ailleurs que sur une slide de keynote.
Je suis convaincu que l'IA transforme la façon de construire des produits, bien au-delà du développement. On passe peu à peu d'équipes qui réalisent des tâches de développement à des Product Builders qui pilotent des systèmes d'agents. Reste à savoir ce qu'on confie vraiment à ces agents, et avec quel outillage. La question devient pressante : depuis la rentrée, OpenAI, GitHub et AWS livrent des agents qui ne s'éteignent plus en fin de session.
Le mythe du prompt qui devient produit
Le scénario "du prompt au produit, sans intervention humaine" repose sur une série d'hypothèses que je trouve, disons, optimistes. Il suppose qu'une intention métier se traduit automatiquement en une spécification assez complète, et qu'un agent comprend l'ensemble des contraintes d'un système d'information existant (si vous en avez déjà cartographié un, vous mesurez l'ampleur de la tâche). Il considère qu'une solution qui passe ses tests est forcément correcte, et que multiplier les agents produit mécaniquement plus de valeur.
J'en ajoute une, plus insidieuse : puisque plus personne ne lit le code, sa qualité n'aurait plus d'importance. C'est exactement l'inverse, et les praticiens les plus en vue du moment le rappellent avec insistance.
Toutes ces hypothèses reposent sur la même confusion : on prend l'autonomie de production pour de l'autonomie de décision. Une machine peut savoir fabriquer sans savoir quoi fabriquer, et vérifier qu'un résultat est conforme sans savoir s'il est pertinent.
Ceux qui ont inventé nos pratiques d'ingénierie ne les lâchent pas
Regardez ce que font les artisans du logiciel qui codent aujourd'hui avec des agents. Aucun d'eux ne met de vibe coding en production, et tous reviennent, chacun à sa façon, aux fondamentaux de l'ingénierie.
Uncle Bob (Clean Code, les trois lois du TDD) a annoncé en juillet, dans une série de posts sur X, qu'il ne lisait plus le code de ses agents. Il le fait passer par une batterie de contrôles automatiques : tests unitaires et d'acceptation, seuils de complexité, limites de taille des modules, analyse des dépendances, tests de mutation. Sa confiance, dit-il, vient de là : le code de ses agents "a dû passer par l'épreuve". J'en tire une conséquence qu'il ne formule pas ainsi : ces seuils maintiennent le code propre, et c'est tant mieux, parce qu'un agent se perd dans du code emmêlé aussi vite qu'un humain.
Kent Beck, à l'origine de l'Extreme Programming et du TDD, écrivait dès 2023 que 90 % de ses compétences venaient de tomber à zéro, et que le levier des 10 % restants avait été multiplié par mille. Il appelle sa pratique l'"augmented coding" : à la différence du vibe coding, on se soucie du code, de sa complexité et des tests. Il guette aussi les signes d'un agent qui dérape, comme une boucle sans fin, une fonctionnalité que personne n'a demandée ou un test désactivé en douce.
Simon Willison tient depuis février un guide en ligne, Agentic Engineering Patterns. Son point de départ : écrire du code ne coûte presque plus rien, alors qu'un bon code a toujours un coût. Son premier réflexe en début de session est de demander à l'agent de lancer les tests. Et il nomme sans détour l'anti-pattern à éviter : imposer à ses collègues du code qu'on n'a pas relu.
Matt Pocock a publié en open source les skills qu'il utilise chaque jour, et son dépôt affichait 307 000 étoiles sur GitHub au 13 novembre 2026 (si si). Son README part de quatre symptômes que tout le monde a vécus : l'agent n'a pas fait ce qu'on voulait, il est trop bavard, le code ne marche pas, et on finit avec une grosse boule de boue. Les remèdes qu'il propose sont étonnamment classiques : se faire poser des questions avant de coder, partager un vocabulaire, resserrer les boucles de retour et soigner le design.
Quatre parcours différents, une même conclusion. Quand le code devient gratuit, ce qui prend de la valeur, ce sont les tests qui fixent le contrat, le design qui garde le code navigable, les boucles de retour courtes et quelqu'un qui répond de ce qui part en production. L'ingénierie logicielle devient la matière première de la Dark Factory.
Le Product Builder, une capacité avant d'être un poste
Si la décision ne s'automatise pas, quelqu'un doit la porter. J'appelle Product Builder la capacité de conduire une intention produit jusqu'à sa réalisation en s'appuyant sur une usine d'agents. Elle comprend le problème, les utilisateurs et la valeur recherchée. Elle spécifie, c'est-à-dire qu'elle traduit les intentions en comportements, en critères d'acceptation et en preuves attendues. Elle décide enfin : elle arbitre les compromis, accepte les risques et mesure les résultats.
Cette capacité suppose de couvrir quatre sensibilités. La sensibilité Produit sait pourquoi on construit et pour qui. La sensibilité Tech connaît l'architecture, les contraintes du SI et le coût réel de ce qu'on ajoute. La sensibilité Design veille à l'expérience et à sa cohérence, et la sensibilité Qualité sait ce qui constitue une preuve et ce qui risque de casser.
Qui l'incarne ? Je crois aux deux formes. Une micro-squad peut réunir ces sensibilités en trois ou quatre personnes. Une seule personne peut aussi les porter, à condition de les couvrir d'une manière ou d'une autre : par son propre parcours, par un pair qu'elle sollicite au bon moment, par des agents spécialisés (un relecteur Design, un agent QA) ou par des garde-fous qui encodent l'exigence à sa place. Le critère, c'est la couverture des quatre sensibilités, et l'effectif s'en déduit.
Le vrai risque est l'angle mort. Un Développeur seul qui néglige le Design livrera des écrans corrects et inutilisables. Un PM seul qui ignore la Tech empilera une dette que l'usine accumulera à sa vitesse à elle. Une usine amplifie tout ce qu'on lui confie, y compris la sensibilité qui manque.
Avec une usine derrière elle, la capacité Product Builder cesse d'être le goulot de la fabrication, et le goulot se déplace vers la validation. Après un an de déploiement d'OpenRewrite et de Moderne, Morgan Stanley en a tiré cette leçon : "le code généré par l'IA a déplacé le goulot vers la revue de code". La pertinence du résultat reste sous la responsabilité du Product Builder, et l'anti-pattern de Simon Willison vaut aussi pour lui : on ne livre pas à ses utilisateurs, ni à ses collègues, ce qu'aucun contrôle n'a vérifié.
Au centre du système, la Dark Factory
Au centre du système, je mets l'usine elle-même. Le Product Builder se tient à ses deux extrémités : il y fait entrer des intentions et il accepte ou refuse ce qui en sort. Entre les deux, tout ce qui peut être spécifié et vérifié est exécuté par la Dark Factory. C'est donc elle qu'il faut concevoir, outiller et faire progresser comme un produit à part entière.
Ce déplacement a une conséquence pratique. Un Product Builder change de sujet, d'équipe ou de client, alors que l'usine reste. Ses skills, ses hooks, ses agents et sa mémoire sont des actifs partagés : chaque amélioration apportée pour un projet profite aussitôt à tous les autres. C'est là que se capitalise le savoir-faire d'une organisation.
Autre malentendu fréquent : la Dark Factory serait un nouvel IDE, ou un orchestrateur multi-agents un peu plus costaud que les autres. Je la vois comme un système de production, qui repose sur quatre capacités complémentaires.
- Harness, pour orchestrer le travail. C'est la couche qui fait travailler les agents : planification, décomposition des tâches, exécution en boucle fermée, gestion du contexte, et récupération quand quelque chose échoue. Il orchestre désormais des agents permanents autant que des sessions ponctuelles, et il vaut surtout par la façon dont on l'équipe.
- Knowledge, pour comprendre l'environnement. C'est la mémoire de l'entreprise, rendue lisible pour des agents. Un agent ne comprend les contraintes d'un SI que si on les met à sa portée.
- Platform, pour rendre l'exécution reproductible. Elle comprend les environnements isolés et éphémères, les accès maîtrisés, l'intégration CI/CD, l'outillage de déploiement et l'observabilité. Rien de glamour, j'en conviens. C'est pourtant elle qui permet de rejouer une exécution à l'identique.
- Guardrails, pour produire des preuves. On y retrouve la batterie d'Uncle Bob (tests déterministes, seuils de complexité, analyse des dépendances, tests de mutation), à laquelle s'ajoutent les contrôles de sécurité, la conformité, la traçabilité et les conditions de mise en production. L'autonomie n'est crédible que si le système sait démontrer que ce qu'il produit répond aux attentes.
La Platform et les Guardrails sont les briques les mieux connues, parce qu'elles prolongent le DevOps. Le Knowledge et le Harness sont plus neufs, et c'est là que se joue aujourd'hui l'écart entre une démo et une capacité industrielle.
Le knowledge, une mémoire d'entreprise pour les agents
Un agent démarre chaque session sans souvenir de la précédente, sauf ce qu'on a pris soin de lui faire noter. Tout ce qu'il sait de votre produit, de votre SI et de vos règles, il le tient de ce que vous avez mis à sa portée. Le knowledge, c'est cette mémoire d'entreprise, et sa qualité plafonne celle de tout ce que l'usine produit.
On y range d'abord le code lui-même, avec ses graphes de dépendances. C'est la première source de connaissance, et c'est pourquoi les seuils de complexité et de taille d'Uncle Bob comptent autant : un code bien nommé et bien découpé se lit comme une documentation, alors qu'un code emmêlé égare l'agent avant même qu'il ait commencé. Viennent ensuite les spécifications, les règles métier, les décisions d'architecture (ADR), les conventions de l'équipe, les runbooks et l'historique des incidents.
J'y ajoute un élément souvent oublié, le glossaire du domaine. C'est le "vocabulaire partagé" de Matt Pocock, que les adeptes du Domain-Driven Design appellent depuis plus de vingt ans le langage omniprésent. Quand l'agent, le Product Builder et le métier mettent la même chose derrière le mot "contrat" ou "client actif", une bonne part des malentendus disparaît avant d'avoir coûté une ligne de code.
Cette mémoire s'organise en deux étages. Un fichier d'instructions court (AGENTS.md, CLAUDE.md, selon l'outil) est chargé à chaque session : comment lancer les tests, quelles conventions respecter, où trouver le reste. Tout le reste est consulté à la demande, par recherche ou via des connecteurs MCP. Un agent noyé sous le contexte est aussi perdu qu'un agent qui n'en a pas, et la discipline consiste à lui donner la bonne information au bon moment.
Reste le plus difficile : la garder vivante. Une documentation périme aussi vite que du code qu'on ne touche plus. Il faut donc la traiter comme du code : versionnée, relue, et mise à jour en fin de session par l'agent lui-même, qui propose d'amender une ADR ou d'enrichir le glossaire quand il a appris quelque chose. Le Product Builder valide, et la connaissance s'accumule au lieu de s'évaporer d'une session à l'autre.
Les agents permanents rendent ce point encore plus critique. Chez Kiro, chaque bot tient ses propres notes, isolées de celles des autres. OpenAI, avec ChatGPT Space, mise au contraire sur un contexte partagé entre humains et agents. Les deux logiques posent la même question : où se trouve la référence ? Je considère la mémoire d'un bot comme un carnet de travail. Ce qu'il y apprend de durable doit remonter dans la mémoire d'entreprise, relu et versionné, sans quoi la connaissance se fragmente en dizaines de carnets que personne ne relit.
Équiper le harnais : skills, hooks et agents
Un harnais nu, c'est un modèle brillant et sans méthode. Ce qui le transforme en outil de production, c'est l'équipement qu'on lui ajoute, et cet équipement tient en trois familles qui ne jouent pas le même rôle.
Les skills encapsulent un savoir-faire. Ce sont des instructions, parfois accompagnées de scripts, que l'agent charge uniquement quand la tâche s'y prête : conduire un cycle TDD, modéliser un domaine, écrire une ADR, préparer une migration. Le dépôt de Matt Pocock en donne une bonne idée, avec par exemple un skill qui oblige l'agent à vous cuisiner, question après question, avant d'écrire la moindre ligne. Un skill rend la pratique d'une équipe transmissible à une machine, et c'est sans doute le meilleur investissement pour démarrer.
Les hooks apportent le déterminisme qui manque au modèle. Ils se déclenchent à des moments précis du travail de l'agent (avant l'appel d'un outil, après une modification, en fin de tâche) et exécutent un contrôle sans rien lui demander : lancer le linter et les tests après chaque édition, refuser un commit tant que la suite est rouge, bloquer toute modification qui désactive un test, ce qui correspond exactement au dérapage que Kent Beck surveille. La règle que j'applique est simple : tout ce qui doit arriver à chaque fois va dans un hook, parce qu'une consigne dans un prompt reste une suggestion.
Les agents spécialisés (ou sous-agents) travaillent chacun dans leur propre contexte. L'un explore le code et rend une carte, un autre écrit les tests, un troisième relit avec un œil de sécurité, d'architecture ou de design. Ce découpage protège le contexte de l'agent principal et permet surtout un regard indépendant. C'est aussi par eux qu'un Product Builder seul couvre la sensibilité qui lui manque.
Autour de ces trois familles, les connecteurs MCP branchent le harnais sur la mémoire d'entreprise et sur les outils de l'organisation (tickets, documentation, observabilité).
Ce qui fait entrer dans la Dark Factory : boucles fermées et agents de revue
Une mémoire riche et un harnais bien équipé donnent un excellent développement assisté, où un humain reste derrière chaque étape. Pour éteindre une partie des lumières, il faut deux pratiques de plus, qui viennent toutes deux en droite ligne de l'ingénierie logicielle. Ce sont elles qui marquent le seuil.
La première est le développement en boucle fermée. L'agent ne rend la main qu'au moment où la boucle se referme sur une preuve. Concrètement, cela ressemble au red/green TDD que décrit Simon Willison :
- l'agent lance la suite existante, pour partir d'un état connu ;
- il traduit un critère d'acceptation en test, et vérifie que ce test échoue ;
- il implémente jusqu'à ce que le test passe, sans toucher aux autres ;
- il refactore, puis repasse toute la batterie : tests, seuils de complexité, dépendances ;
- en cas d'échec, il lit l'erreur, corrige et recommence, dans une limite d'essais fixée à l'avance, au-delà de laquelle il s'arrête et fait remonter le problème.
Le rôle de l'humain se déplace. Plutôt que d'intervenir à chaque tour de boucle, il en fixe les conditions de sortie, et c'est là que se loge le vrai travail de spécification. Ces boucles existent à plusieurs échelles : quelques secondes entre une modification et les tests déclenchés par un hook, quelques minutes pour une tâche validée par ses tests d'acceptation, quelques jours entre une mise en production et ce que l'observabilité en dit. Quand le changement est répétitif (une montée de version sur des centaines de dépôts, une API dépréciée à remplacer partout), la boucle gagne à devenir déterministe : l'agent écrit une recette OpenRewrite, on la vérifie une fois, et elle s'applique partout à l'identique.
La seconde pratique est la revue par des agents dédiés. Une fois la boucle refermée, un ou plusieurs relecteurs reprennent le travail avec un contexte vierge, idéalement avec un autre modèle ou d'autres consignes que l'agent qui a codé. On leur demande de trouver ce qui ne va pas, jamais d'approuver. L'un vérifie la conformité à la spécification et repère la fonctionnalité que personne n'a demandée. Un autre traque la boule de boue en devenir, un autre encore la faille de sécurité ou le test qui ne teste rien (les tests de mutation sont là pour ça). Leurs remarques repartent dans la boucle, et l'agent corrige. Kiro en a fait un rôle permanent : son bot de revue confronte chaque pull request aux décisions passées de l'équipe et peut demander des changements, sans avoir le droit d'approuver ni de fusionner.
C'est ce dispositif qui permet à Uncle Bob de ne plus lire le code de ses agents. La relecture humaine y change de place : le Product Builder lit les rapports de revue, les décisions prises en chemin et les exceptions que le système fait remonter d'office (un test modifié, une dépendance ajoutée, un seuil dépassé, un relecteur qui doute). Une nuance tout de même : Uncle Bob travaille seul sur ses projets. Dans une équipe, et a fortiori dans un secteur régulé, "ne plus lire le code" ne tient que si l'on sait montrer, pour chaque changement, quelles preuves en ont tenu lieu.
De la session à l'équipe agentique
En quelques semaines, l'unité de travail a changé chez les principaux éditeurs. Après la session isolée, qu'on lance puis qu'on oublie, vient l'agent permanent, avec un rôle, une mémoire et un agenda. Plusieurs de ces agents forment une équipe agentique, et c'est à cette échelle que la Dark Factory commence à tourner sans qu'on la surveille.
| Offre | Disponibilité | Mémoire | Déclenchement | Garde-fous |
|---|---|---|---|---|
| Dots (OpenAI) | Annoncés au DevDay, 29 septembre 2026, déploiement progressif | Préférences apprises au fil du temps, contexte partagé dans ChatGPT Space | Travail en tâche de fond, suivi de projets, sollicitation via ChatGPT, Slack ou Teams | Custom Rules (autoriser, soumettre à approbation, interdire), auto-review des actions sensibles, journal d'activité |
| Copilot projects et automations (GitHub) | Annoncés à Universe, 28 octobre 2026, projects en preview | Préférences et conventions de chaque dépôt | Sessions parallèles sur plusieurs dépôts, automatisations sur événement ou calendrier | Améliorations des automatisations soumises à approbation, revue de code "Max" pour les changements sensibles |
| Kiro bots (AWS) | Disponible (GA) dans Kiro Crew, 5 novembre 2026 | Notes propres à chaque bot, visibles et modifiables | Objectif continu, tâches planifiées, sessions parallèles | Permissions limitées au rôle, accès supplémentaire sur approbation, ni merge ni release sans signature humaine |
Les exemples publiés par Kiro ressemblent à un organigramme. Un bot d'intake trie les tickets et rédige les étapes de reproduction. Un bot build-health surveille la CI toutes les 30 minutes et distingue les vraies régressions des tests instables. Un bot de revue confronte les pull requests aux décisions passées, et un bot release-readiness déroule la checklist avant mise en production. OpenAI montre de son côté un Dot qui surveille les retours clients, repère les bugs récurrents et rend des pull requests accompagnées d'une vidéo des changements. GitHub, enfin, a ouvert sa conférence par cette phrase de Jay Parikh : "l'objectif, c'est du travail terminé, pas davantage de code".
Le même mouvement déborde le développement. Claude Duet chez Anthropic et Muse chez Meta tournent chacun sur leur propre machine virtuelle, avec une mémoire que l'utilisateur peut consulter, un journal d'activité et une approbation obligatoire avant tout envoi, paiement ou suppression. Chez Meta, un second agent baptisé Sentinel valide même tout ce que Muse envoie vers l'extérieur. Quand des produits grand public embarquent ces garde-fous par défaut, il devient difficile de justifier qu'une usine logicielle s'en passe.
Ces équipes d'agents apportent aussi leurs problèmes d'organisation. Les analystes cités par InfoWorld recommandent de gouverner les bots comme des prestataires, avec des identités strictement délimitées, des budgets plafonnés et une télémétrie centralisée. Ils pointent la "taxe de coordination", quand les coûts en tokens s'additionnent à mesure que les agents se parlent, et la dérive des permissions accordées sans réexamen. J'ajoute un risque plus sérieux encore : un agent permanent qui lit des tickets, des retours clients ou des pages web lit aussi ce qu'un attaquant a pu y glisser. L'injection de prompt devient un risque d'exploitation continu, et des permissions taillées au plus juste en sont la première défense.
Pour le Product Builder, le travail prend une dimension managériale. Il définit les rôles de l'équipe agentique, leur périmètre et leurs droits, et décide de ce qui doit remonter à un humain. Un bot mal cadré se comporte comme un stagiaire sans fiche de poste, avec l'endurance d'une machine en prime.
L'AI-DLC s'encode dans la Dark Factory, au bénéfice de tous
Pour organiser cette transformation sur l'ensemble du cycle de vie, l'AI-DLC, le cadre formalisé par AWS, donne une bonne base (je suis passé par la maison, je ne vais pas faire semblant de le découvrir). Sa force, à mes yeux, tient à ce qu'il se prête très bien à l'encodage. Une méthode qui vit dans des slides s'applique inégalement, selon l'équipe et l'humeur du jour. Une méthode traduite en skills, en hooks, en agents de revue et en bots s'applique à chaque fois, et on l'améliore une seule fois pour tout le monde.
| Phase | Ce que la Dark Factory encode | Qui y gagne, et quoi |
|---|---|---|
| Prepare | Mémoire d'entreprise alimentée, harnais équipé de ses skills, hooks et agents, Platform prête | Chaque nouveau projet démarre avec l'acquis des précédents |
| Frame | Intention, valeur et critères de succès écrits sous une forme que l'usine sait vérifier | Le métier voit ses critères devenir les conditions de sortie des boucles |
| Inception | Spécification, ADR et plan de réalisation versionnés dans la mémoire d'entreprise | Les choix d'architecture restent consultables par les humains comme par les agents |
| Construction | Boucles fermées, agents de revue, recettes déterministes pour les changements de masse | L'ingénierie applique ses standards à chaque incrément sans relire chaque ligne |
| Operations | Bots de suivi (CI, mise en production, incidents) qui renvoient leurs enseignements dans la mémoire | L'exploitation nourrit la conception suivante au lieu de dormir dans des tickets |
Le bénéfice se répartit sur tous les acteurs. Le Product Builder passe moins de temps à coordonner et davantage à décider. Les équipes d'ingénierie voient leurs standards appliqués par défaut, plutôt que négociés à chaque revue. La qualité et la sécurité obtiennent des preuves systématiques. Le métier raccourcit le délai entre une intention et une valeur disponible, et l'organisation, surtout dans un secteur régulé, gagne une traçabilité que les processus manuels n'ont jamais vraiment offerte.
Dans ce découpage, le Product Builder gouverne les intentions, les décisions et les résultats, et la Dark Factory exécute tout ce qui peut être suffisamment spécifié et vérifié. Les points de contrôle humains demeurent, déplacés vers les décisions à forte valeur et vers les risques qu'aucun contrôle automatique ne couvre.
Ce que montrent les résultats
Les études disponibles convergent sur un point encourageant : le résultat dépend de la façon dont on s'y prend. Le rapport DORA 2025 montre que l'IA amplifie les forces des organisations, si bien que celles qui ont déjà de bonnes pratiques en tirent le plus. Faros AI mesure une nette accélération de la production, et la hausse des bugs et des incidents qui l'accompagne indique où investir en priorité : dans la vérification. METR rappelle que, sur des bases de code existantes et complexes, les gains demandent un contexte bien outillé. Lus ensemble, ces travaux donnent raison à nos quatre praticiens : appuyée sur une discipline d'ingénierie, l'IA accélère la création de valeur, et c'est précisément cette discipline que la Dark Factory encode.
Le nombre de lignes de code, de pull requests ou de tokens consommés ne mesure aucune valeur, même s'il remplit joliment un dashboard. Pour piloter une Dark Factory, je partirais des métriques DORA, qui mesurent déjà le débit et la stabilité de la livraison : délai de mise en production d'un changement, fréquence de déploiement, temps de rétablissement après un échec, taux d'échec des changements et taux de reprise. Elles restent la bonne base, puisqu'une usine d'agents doit d'abord livrer vite et de façon stable. J'y ajouterais ce que la Dark Factory rend nécessaire :
- le délai entre une intention validée et une valeur disponible, qui prolonge le délai DORA en amont du commit ;
- le coût complet d'un incrément accepté, corrections et fonctionnement de l'équipe agentique compris ;
- le taux de conformité aux critères d'acceptation ;
- le score de mutation des tests produits, pour savoir si les preuves prouvent quelque chose ;
- la part des tâches réalisées en autonomie avec des preuves suffisantes, et les motifs pour lesquels les autres sont remontées à un humain ;
- l'impact réel sur les utilisateurs et sur les objectifs métier.
Une trajectoire à notre portée
La bonne nouvelle, c'est que rien de tout cela ne demande d'attendre. Les agents savent déjà réaliser des fonctionnalités complètes sous supervision, les éditeurs livrent les premières équipes agentiques, et les pratiques qui rendent une usine fiable existent depuis des décennies. La discipline dont la Dark Factory a besoin, nous la connaissons déjà : il reste à l'encoder.
Le premier pas est modeste et à la portée de n'importe quelle équipe. Un fichier d'instructions soigné, un skill qui fixe une pratique maison, un hook qui bloque les tests désactivés, un agent de revue sur les pull requests, une boucle fermée sur un périmètre bien borné : chacun de ces gestes se rentabilise vite, et chacun devient une pièce de l'usine que les projets suivants récupèrent. À court terme, des équipes agentiques prendront en charge des périmètres bornés. À terme, des Dark Factories opéreront sur des domaines de plus en plus larges, supervisées par les exceptions, les risques et les résultats.
Ce que j'attends le plus de cette usine, c'est ce qu'elle rend aux personnes. Les Développeurs consacrent leur temps à concevoir le système qui produit et contrôle le code, là où leur expérience pèse le plus. Les profils qui réunissent plusieurs sensibilités, Produit, Tech, Design et Qualité, trouvent un rôle à leur mesure. Et les organisations peuvent enfin produire davantage de valeur sans que l'effort humain grimpe au rythme de la complexité du logiciel.
Dans une usine qui tourne lumières éteintes, les tests, les hooks et les agents de revue gardent les yeux ouverts. Le Product Builder, lui, peut lever la tête et regarder plus loin, vers ce qui mérite d'être construit.
Prêts à faire tourner votre propre usine ? Équipes, gouvernance, standards rendus actionnables, plateforme dotée de garde-fous jusqu'à la production : avec le Product Operating Model AI, Thiga aide les organisations Produit et Tech à adapter leur fonctionnement à l'IA.