Le problème avec un seul modèle d'IA qui écrit du code, c'est qu'il corrige ses propres copies. C'est le biais de confirmation intégré directement dans votre pipeline. GPD6 Astra et Fable 5.1 peuvent maintenant bosser sur le même projet ensemble, et ça ne demande qu'un seul skill open source gratuit pour le faire. Le repo est à 2 100 étoiles et le tout tient dans un dossier que vous glissez dans Claude Code ou Codex.
Si vous débutez, ça veut dire concrètement deux modèles d'IA différents qui construisent et se vérifient mutuellement, au lieu d'un seul modèle qui valide son propre travail. Voici comment ça tourne.
Vous choisissez qui construit, l'autre devient inspecteur automatiquement
Le principe est simple mais la mécanique change tout. Vous décidez quel modèle prend le rôle de constructeur. L'autre devient automatiquement l'inspecteur. Pas de configuration compliquée, pas de chaîne de prompts à maintenir. Le système attribue les rôles et les modèles s'y tiennent.
Fable écrit le plan. Astra déchire ce plan avec des preuves. Pas des opinions, pas des "je pense que". Des preuves. Et ils font des allers-retours jusqu'à ce que le plan tienne réellement la route. Ce n'est pas un simple check de surface où l'inspecteur dit "ok ça a l'air bien". Le modèle qui inspecte doit argumenter, pointer les failles, exiger des clarifications.
C'est la différence entre une relecture polie et un vrai débat technique.
La permutation des rôles, c'est tout l'intérêt du système
Une fois que le plan est solide, les rôles s'inversent. Fable écrit le code. Astra devient celui qui lit chaque ligne. Et c'est là que le système montre sa vraie valeur.
Le modèle qui a écrit le code n'a jamais le droit de l'approuver. Jamais. Cette règle est absolue et c'est elle qui change tout. Quand vous laissez un seul modèle écrire et vérifier, il va naturellement défendre ses choix. Il va justifier ses approximations. Il va passer sur ses angles morts parce que ce sont les siens.
Avec la permutation, vous brisez cette boucle. Le constructeur construit. L'inspecteur inspecte. Et l'inspecteur n'a aucune attache émotionnelle avec le code qu'il lit. Il ne cherche pas à le défendre. Il cherche à le casser.
55 problèmes détectés avant le déploiement
Dans un run que le mainteneur a publié, l'inspecteur a attrapé 55 problèmes avant que quoi que ce soit parte en production. Pas des warnings cosmétiques. Des vrais problèmes qui seraient passés si le même modèle avait fait le build et la review.
C'est ça le game changer. Vous arrêtez de merge le premier plan que votre IA a bien voulu produire. Vous arrêtez d'accepter du code parce qu'il "a l'air correct" sans avoir été vraiment challengé.
Le chiffre est important parce qu'il n'est pas théorique. Ce n'est pas "ce système pourrait trouver des bugs". C'est "ce système en a trouvé 55 sur un vrai run". La différence entre un concept et une preuve.
Pourquoi un seul modèle qui s'auto-vérifie est un piège
On est nombreux à être tombés dans ce piège. Vous demandez à Claude ou GPT d'écrire du code. Il le fait. Vous lui demandez de le vérifier. Il vous dit que tout est bon. Vous déployez. Et puis vous découvrez le bug en production.
Le problème n'est pas que le modèle est mauvais. Le problème est structurel. Un modèle qui évalue son propre output va naturellement reproduire ses biais. Il va juger correct ce qui correspond à sa logique interne, même si cette logique est bancale sur ce cas précis.
C'est comme demander à un étudiant de corriger son propre examen. Il va être indulgent sur les points qu'il ne maîtrise pas, simplement parce qu'il ne voit pas qu'il ne les maîtrise pas.
Deux intelligences qui se challengent mutuellement
Ce qui rend le système puissant, c'est que les deux modèles ne pensent pas pareil. Astra et Fable ont des architectures différentes, des forces différentes, des angles morts différents. Quand l'un écrit et l'autre vérifie, vous obtenez une vraie contradiction.
Fable peut écrire un plan qui lui semble parfaitement logique. Astra va regarder ce plan avec un œil neuf et dire "attends, ce cas-là, tu l'as pas couvert". Et il va le prouver. Pas juste l'affirmer.
C'est la friction qui produit la qualité. Sans friction, vous avez de la vélocité mais pas de fiabilité. Avec friction, vous ralentissez un peu la première itération mais vous gagnez énormément sur les bugs évités.
Un dossier à glisser, c'est tout
L'installation est ridiculement simple. Le repo pèse un dossier. Vous le glissez dans Claude Code ou Codex. C'est tout. Pas de dépendances complexes, pas de configuration YAML à maintenir, pas de token à gérer entre services.
Cette simplicité est importante parce qu'elle abaisse la barrière à l'entrée. Si c'était compliqué à mettre en place, les gens testeraient une fois et abandonneraient. Là, vous glissez un dossier et vous avez deux modèles qui bossent ensemble.
Le fait que le projet soit open source et à 2 100 étoiles veut aussi dire que la communauté valide le truc. C'est pas un projet expérimental que personne n'a testé. Il y a du monde derrière.
Ce que ça change dans votre workflow quotidien
Concrètement, votre pipeline change de structure. Avant, vous aviez un prompt, une réponse, et vous croisiez les doigts. Maintenant, vous avez un dialogue structuré entre deux modèles qui se challengent avant que vous ne voyiez le résultat.
Vous ne recevez plus le premier plan que l'IA a pondu. Vous recevez un plan qui a survécu à une inspection contradictoire. Vous ne recevez plus du code non vérifié. Vous recevez du code qu'un autre modèle a lu ligne par ligne et a tenté de casser.
Le temps que vous passiez à faire la review vous-même diminue mécaniquement. Pas parce que vous faites moins attention. Parce que le gros du travail de vérification a déjà été fait par un modèle qui n'a pas écrit le code.
Points clés à retenir
- Deux modèles différents qui construisent et vérifient, au lieu d'un seul qui corrige ses propres copies
- Le modèle qui écrit le code n'a jamais le droit de l'approuver, c'est la règle centrale
- Fable écrit le plan, Astra le déchire avec des preuves, puis ils inversent les rôles pour le code
- Dans un run réel, l'inspecteur a attrapé 55 problèmes avant le déploiement
- Le système tient dans un dossier à glisser dans Claude Code ou Codex, open source, 2 100 étoiles
- Vous arrêtez de merge le premier plan que votre IA a bien voulu produire
Le point qui mérite qu'on s'y arrête, c'est que ce système ne remplace pas la revue humaine. Il la déplace. Au lieu de passer votre temps à traquer des bugs qu'un modèle aurait pu voir, vous passez votre temps sur des décisions architecturales qu'aucun modèle ne peut prendre à votre place. C'est pas de l'automatisation bête. C'est de la délégation intelligente.