Reins Engineering

Reins Engineering — L’IA avec des renes Image: AI generated

Un cheval sans renes

Les outils de codage IA sont devenus rapides. Connexion en 30 secondes. Paiement en 2 minutes. Un MVP sort en trois semaines.

Trois mois plus tard, tout s’effondre.

L’IA « nettoie » la logique de paiement et modifie les calculs de remise. Une demande de refactoring change les noms de champs de l’API publique. L’ajout d’une nouvelle fonctionnalite casse l’authentification. Selon une recherche de Carnegie Mellon (MSR 2026), la complexite du code augmente de maniere permanente de 41 % apres l’adoption d’outils de codage IA. Le Google DORA Report (2025) montre une baisse de 7,2 % de la stabilite des livraisons pour chaque augmentation de 25 % de l’adoption de l’IA.

Le probleme n’est pas que l’IA est stupide. C’est qu’il n’y a pas de renes.

Le harnais est une cloture

L’industrie a repondu avec le « harness engineering ». Linters, formateurs, CI/CD, structure de projet, conventions de codage. Des clotures qui empechent l’agent de sortir du perimetre.

Les clotures ne fixent pas de direction. Quoi que l’agent fasse a l’interieur de la cloture — ecraser la logique existante, changer les types, sauter des transitions d’etat — le linter passe. Le formateur passe. Le CI passe. Le code arrive en production « propre mais faux ».

La selle est en place. Le cavalier est monte. Mais sans renes, il se tient avec les cuisses et tombe au bout de trois mois.

Reins Engineering est une approche d’ingenierie qui donne aux agents IA des contrats deterministes et bloque la progression lorsque les contrats sont violes.

Elle se compose de trois elements :

1. Feedback deterministe

Donnez a l’agent des faits, pas des opinions. Non pas « ca a l’air bizarre » mais « ligne 41 : nom de champ incompatible, attendu ‘user_id’, obtenu ‘userId’. » Un feedback qui ne laisse aucune place a la sycophancy. Selon l’etude TDAD (arxiv 2026), les instructions procedurales « fais du TDD » aggravent les regressions (6,08 % → 9,94 %), tandis que fournir des fichiers de test specifiques dans le contexte reduit les regressions de 70 % (6,08 % → 1,82 %).

2. Verrouillage des contrats (Ratchet Pattern)

Quand la verification passe, verrouillez. Le code de verification ecrit de cette maniere s’appelle ratchet code. Les tests Hurl declarent le comportement de l’API en texte brut, executes a chaque commit dans le CI. Le ratchet code qui a passe ne peut pas etre supprime. L’agent peut modifier librement le code, mais ne peut pas modifier le comportement. La derive est structurellement supprimee.

3. Separation des decisions et de l’implementation

Trois choses melangees dans le code — les decisions utilisateur, la logique metier, les details d’implementation — sont separees. Les decisions vivent dans des specifications declaratives (OpenAPI, DDL, diagrammes d’etats). L’implementation est librement generee par l’IA. L’IA ne peut pas confondre les decisions avec les details et les ecraser. La survie des decisions devient independante de la taille du modele.

Evolution

Prompt Engineering      → Bien le dire et ca marche
Context Engineering     → Donner un bon contexte et ca marche
Harness Engineering     → Contenir avec la structure
Reins Engineering       → Diriger avec les renes

Chaque etape est nee des limites de la precedente. Les prompts seuls manquaient de coherence. Le contexte n’empechait pas l’agent de devier. Les clotures ne pouvaient pas prevenir la derive a l’interieur du perimetre.

Reins Engineering n’est pas une cloture — ce sont des renes. Il ne contraint pas la liberte de l’agent ; il garantit que l’agent atteint la destination.

80 : 20

Reins Engineering ne couvre pas tout. Il sait exactement ce qu’il couvre.

Deque Systems a analyse environ 300 000 problemes de qualite d’accessibilite sur plus de 13 000 pages (2021). 57 % etaient entierement automatisables, 23 % necessitaient une assistance IA, et 20 % ne pouvaient etre juges que par des humains. L’accessibilite et le code sont des domaines differents, mais ils partagent la meme structure : « quelle proportion les machines peuvent-elles juger ? »

A travers ce prisme, la qualite du code se repartit ainsi :

57 % — Territoire du cliquet. Declarer le comportement, les machines jugent les violations sans demander. go test, Hurl, yongol check, filefunc validate.
23 % — Territoire du harnais. Linters, formateurs, CI. Le mecanisme est deterministe, mais la profondeur de verification reste en surface. Ils ne capturent pas la correction comportementale, mais imposent structure et style, elevant la qualite de generation de l’IA.
20 % — Territoire humain. Adequation metier, UX, direction architecturale.

Reins Engineering ne remplace pas le harnais. Il le chevauche.

Harnais (determinisme de surface)   23 %
+ Cliquet (determinisme comportemental)   57 %
──────────────────────────────────
                                    80 %

Les humains se concentrent sur les 20 % restants.

Pourquoi les plus gros modeles ne sont pas la reponse

« GPT-6 va tout corriger. »

Non. Le probleme n’est pas l’intelligence du modele — c’est le medium. Le code comme medium ne distingue pas les decisions de l’implementation. N’importe quel modele lisant du code voit les decisions et les details melanges dans le meme texte.

Un modele local de 4,5B parametres (Gemma4) avec un feedback deterministe + un contexte d’exemples edite les SSOT sans erreur. Un modele frontier editant du code brut produit de la derive. La difference est la structure, pas l’intelligence.

Ne changez pas le modele. Ajoutez un contrat.

Preuves

yongol est l’implementation de Reins Engineering. Il valide de maniere croisee la coherence de 10 specifications declaratives (SSOT) avec 287 regles et genere du code.

Benchmark ZenFlow — un SaaS d’automatisation de workflows multi-tenant. 32 endpoints, 14 tables, 47 requetes Hurl. 11/11 etapes reussies. L’ajout de fonctionnalites n’a pas ralenti le processus. Les tests existants ne se sont jamais casses.

Un backend fonctionnel a ete genere avec succes par un modele local de 4,5B parametres. Cout : 0 $. Hors ligne. Reins comble le fosse que la taille du modele laisse.

Pas d’automatisation de la revue par IA — mais automatisation de la revue par le code

L’approche dominante de l’industrie est l’automatisation de la revue par IA. Un LLM genere du code, un autre LLM le revoit. Un ivrogne demandant a son ami ivre « Je suis saoul ? ». Le taux de capitulation par sycophancy des modeles frontier est de 58 %. Le taux de faux positifs du LLM-as-Judge est de 36 %. Multipliez une generation probabiliste par une verification probabiliste et la precision se degrade.

Reins Engineering est une automatisation de la revue par le code. Le LLM genere, le code deterministe verifie. validate ne flatte pas. go test n’hallucine pas. La mesure de couverture ne ment pas. Pass, c’est pass. Fail, c’est fail.

Revue par IA :     LLM → verification LLM → flatterie → faux pass → derive
Revue par code :   LLM → verification code → faits → pass/fail → convergence

A une epoque ou les agents IA generent des dizaines de lignes par seconde, les humains ne peuvent pas lire tout le code. Mais deleguer la revue a l’IA signifie que la flatterie remplace la verification. Quand le code prend en charge les parties mecaniquement verifiables, les humains peuvent se concentrer uniquement sur les decisions que les machines ne peuvent pas juger — adequation metier, UX, direction architecturale.

La revue humaine ne tombe pas a zero. La douleur de la revue humaine est reduite. Ce que le code peut verifier, le code le fait. Ce que seuls les humains peuvent verifier, les humains le font.

Un harnais sans renes n’est qu’une cloture

L’IA est deja assez puissante. Ce qui manque, c’est la direction.

Construisez des clotures plus hautes et l’agent derivera plus vite a l’interieur. Tenez les renes et l’agent court vers la destination.

Reins Engineering — une verification deterministe structuree pour les agents IA.

Convergence independante

5 projets ayant converge independamment vers le meme principe :

episteme — Un plan de controle cognitif pour agents IA par un chercheur de l’UIUC. Force la creation d’une Reasoning Surface au niveau du systeme de fichiers avant toute action irreversible. Meme principe que le ratchet, implementation differente.
MagLab — Un pipeline de recherche en physique par un chercheur en spintronique du KAIST. “LLMs only reason and plan. They do not compute numbers, fabricate citations, or generate figure data.” Les outils deterministes produisent toutes les sorties numeriques.
Manifesto — MEL pour definir de maniere declarative les transitions d’etat frontend. “Agent proposes, World verifies.” L’agent ne propose que l’intention ; les transitions d’etat sont verifiees de maniere deterministe.
NEKOWORK — Porte de securite scannant les diffs de code IA avec des regles deterministes avant le merge. Fonctionne quelle que soit la source. Le LLM ne juge pas.
oh-my-kamisama — Un conductor multi-CLI qui orchestre Claude, Codex et Gemini. Il lit le git diff reel plutot que les affirmations des workers (« diffs beat claims ») et ne declare la tache terminee qu’apres le passage des tests du projet. Chaque execution est conservee sur disque comme un artefact auditable — pas un chat qui disparait.

En resume : La generation peut etre probabiliste. La verification doit etre deterministe.

References

Cursino, D. et al. (2026). “Speed at the Cost of Quality? The Impact of AI Coding on Software.” MSR 2026. arxiv.org/abs/2511.04427
Google Cloud (2025). DORA Report 2025. cloud.google.com
Wang, Z. et al. (2026). “TDAD: Test-Driven Agentic Development.” ACM AIWare 2026. arxiv.org/abs/2603.17973
Karpathy, A. (2026). “From Vibe Coding to Agentic Engineering.” thenewstack.io
Deque Systems (2021). “Automated Testing Study…” deque.com
Anthropic (2026). “Demystifying Evals for AI Agents.” anthropic.com

Historique des modifications

2026-05-23 : Publication initiale
2026-05-27 : Ajout de la section « Convergence independante » (episteme, MagLab, Manifesto, NEKOWORK)
2026-05-28 : Section « 80 : 20 » — Harnais (23 %) + Cliquet (57 %) = 80 %, donnees empiriques Deque
2026-05-31 : Ajout d’oh-my-kamisama a la Convergence independante