<?xml version="1.0" encoding="UTF-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="fr">
    <title>Meta Lambda</title>
    <subtitle>Cédric Brancourt, architecte logiciel indépendant.</subtitle>
    <link rel="self" type="application/atom+xml" href="https://meta-lambda.com/atom.xml"/>
    <link rel="alternate" type="text/html" href="https://meta-lambda.com"/>
    <generator uri="https://www.getzola.org/">Zola</generator>
    <updated>2026-11-02T10:00:00+00:00</updated>
    <id>https://meta-lambda.com/atom.xml</id>
    <entry xml:lang="fr">
        <title>La qualité à l&#x27;ère agentique : un outillage sur mesure</title>
        <published>2026-11-02T10:00:00+00:00</published>
        <updated>2026-11-02T10:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://meta-lambda.com/un-outillage-sur-mesure/"/>
        <id>https://meta-lambda.com/un-outillage-sur-mesure/</id>
        
        <content type="html" xml:base="https://meta-lambda.com/un-outillage-sur-mesure/">&lt;p&gt;Quand un agent écrit le code, d&#x27;où vient la confiance ?&lt;&#x2F;p&gt;
&lt;p&gt;Pas de la relecture de chaque diff, en tout cas. Au rythme où un agent produit, on ne fait plus que ça, et on finit par valider sans lire.
Pas non plus d&#x27;une pile de documents rédigés avant la première ligne de code. Il faut les relire aussi, et ils vieillissent dès le lendemain.&lt;&#x2F;p&gt;
&lt;p&gt;Ma réponse est un outillage construit au fil de mes projets : &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;Electron-libre&#x2F;cardinal&quot;&gt;Cardinal&lt;&#x2F;a&gt;. (Un outil pour Claude… Claudia Cardinale. Je n&#x27;ai pas pu m&#x27;en empêcher.)&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;cardinal-logo.svg&quot; alt=&quot;Le logo de Cardinal : une rose des vents dont la pointe nord est en or, à côté du nom cardinal et de la devise « set the course for your agents ».&quot;&gt;
  &lt;figcaption&gt;Une rose des vents, le nord en or : fixer le cap de vos agents.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;p&gt;Et ma conviction : &lt;strong&gt;un outillage taillé sur mesure pour le projet sert mieux que le prêt-à-porter d&#x27;un framework générique.&lt;&#x2F;strong&gt;
Voici ce que fait Cardinal. (Comment il s&#x27;est construit avec lui-même, et ce que ses mesures en disent, c&#x27;est l&#x27;objet d&#x27;un &lt;a href=&quot;&#x2F;le-cordonnier-bien-chausse&#x2F;&quot;&gt;second article&lt;&#x2F;a&gt;.)&lt;&#x2F;p&gt;
&lt;h2 id=&quot;au-commencement-etait-le-copier-coller&quot;&gt;Au commencement était le copier-coller&lt;&#x2F;h2&gt;
&lt;p&gt;Au départ, il n&#x27;y avait pas d&#x27;outil. Juste des instructions, des procédures et des &lt;em&gt;hooks&lt;&#x2F;em&gt; (des scripts que Claude Code exécute autour des actions de l&#x27;agent), recopiés d&#x27;un projet à l&#x27;autre.
Chaque amélioration devait être reportée à la main dans les autres projets, en adaptant les chemins et les formulations. (Le genre de corvée qu&#x27;on remet toujours à demain.)&lt;&#x2F;p&gt;
&lt;p&gt;La première étape de Cardinal a donc été de tout regrouper dans un dépôt, avec un petit binaire Rust qui synchronise les projets.&lt;&#x2F;p&gt;
&lt;p&gt;Un framework part d&#x27;une méthode et vous demande de l&#x27;adopter.
Cardinal, lui, part de problèmes observés : chaque règle existe parce que quelque chose a mal tourné.
L&#x27;agent a signé un commit « Co-Authored-By: Claude » ? Un hook le refuse.
Il a rendu la main avec des avertissements de &lt;code&gt;clippy&lt;&#x2F;code&gt; ? Un hook le renvoie corriger.
Il a commité sans revue ? Le commit est refusé.&lt;&#x2F;p&gt;
&lt;p&gt;Rien de révolutionnaire, et c&#x27;est voulu.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;le-signal-plutot-que-la-paperasse&quot;&gt;Le signal plutôt que la paperasse&lt;&#x2F;h2&gt;
&lt;p&gt;La plupart des outils de &lt;em&gt;Spec Driven Development&lt;&#x2F;em&gt; soignent ce que l&#x27;agent reçoit : des documents de conception, rédigés avant le code.
Cardinal soigne ce que l&#x27;agent observe : des signaux qui lui disent s&#x27;il a réussi.&lt;&#x2F;p&gt;
&lt;p&gt;Je l&#x27;écrivais dans &lt;a href=&quot;&#x2F;agentic-coding-ingenierie-obligatoire&#x2F;&quot;&gt;L&#x27;agentic coding ne réinvente pas l&#x27;ingénierie logicielle&lt;&#x2F;a&gt; : un agent est une boucle, et la boucle ne vaut que par ce qu&#x27;elle observe.
Donnez à un agent une spec moyenne et un bon signal, il finira par converger. Donnez-lui une spec parfaite et aucun signal, il vous livrera quelque chose de plausible. Plausible, pas juste.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;cardinal-entree-retour.svg&quot; alt=&quot;À gauche, une pile de documents rédigés avant le code et donnés à l&#x27;agent : beaucoup à relire, rien qui vérifie. À droite, l&#x27;agent agit et reçoit à chaque action un signal des tests, du linter, des specs et de la revue.&quot;&gt;
  &lt;figcaption&gt;Soigner l&#x27;entrée, ou soigner le retour.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;p&gt;Pour produire ces signaux, pas besoin d&#x27;inventer une méthode. Cardinal reprend des pratiques que tout développeur connaît :&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Une issue par changement&lt;&#x2F;strong&gt; : un fichier Markdown que l&#x27;agent complète (compréhension, plan, suivi de chaque livrable).&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Le TDD&lt;&#x2F;strong&gt; : le test d&#x27;abord, et l&#x27;agent consigne son échec avant d&#x27;écrire le code.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Le formatage et le linter&lt;&#x2F;strong&gt; : après chaque modification pour l&#x27;un, avant que l&#x27;agent rende la main pour l&#x27;autre.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;La revue de code&lt;&#x2F;strong&gt; : faite par un modèle, exigée par un hook git &lt;code&gt;pre-commit&lt;&#x2F;code&gt;. Pas de revue enregistrée, pas de commit.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Les ADR&lt;&#x2F;strong&gt; : le &lt;em&gt;pourquoi&lt;&#x2F;em&gt; des choix, que l&#x27;agent lit avant de toucher au code concerné.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;p&gt;La différence, c&#x27;est que ces contrôles ne sont pas des consignes que l&#x27;agent pourrait oublier après quelques heures de session. Ce sont des programmes qui bloquent, des &lt;em&gt;gates&lt;&#x2F;em&gt;.
Ils restent muets quand tout passe et compacts quand ils échouent : leur sortie est faite pour être lue par un modèle.&lt;&#x2F;p&gt;
&lt;p&gt;Autre principe, peut-être le plus structurant : une session, une issue.
L&#x27;agent ne garde en contexte que son issue, isolé des autres travaux en cours. (Le développeur qu&#x27;on n&#x27;interrompt jamais. Le rêve !)
Et comme il consigne dans l&#x27;issue sa compréhension, son plan, ses décisions et le suivi de chaque livrable, rien ne se perd quand la session se termine. Les sessions suivantes repartent de ces documents, et de l&#x27;intention qui les a motivés.&lt;&#x2F;p&gt;
&lt;p&gt;Ça rejoint ce que décrit &lt;a href=&quot;https:&#x2F;&#x2F;claude.com&#x2F;fr&#x2F;resources&#x2F;articles&#x2F;building-agents-when-to-fold-subagents-into-your-main-agent-loop&quot;&gt;Diane Sarkis (Anthropic)&lt;&#x2F;a&gt; : une seule boucle d&#x27;agent, avec des &lt;em&gt;skills&lt;&#x2F;em&gt; et des outils chargés à la demande, fait souvent mieux qu&#x27;une armée de sous-agents qui se renvoient des résumés, où l&#x27;information se perd.
Cardinal fait le même pari. L&#x27;isolement vient du découpage en issues, pas de la délégation, et garder un sous-agent seulement là où une mesure le justifie est même un jalon de sa feuille de route.&lt;&#x2F;p&gt;
&lt;p&gt;Reste les specs, là où l&#x27;approche diffère le plus.
Pas de spec par fonctionnalité, qu&#x27;on cesse de lire une fois livrée : Cardinal en tient une par capacité (« la gate de revue », « la synchronisation »…), amendée par chaque issue qui la change.
Chaque exigence porte un identifiant et ne contient qu&#x27;une seule obligation :&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;markdown&quot; style=&quot;background-color:#282828;color:#fdf4c1aa;&quot; class=&quot;language-markdown &quot;&gt;&lt;code class=&quot;language-markdown&quot; data-lang=&quot;markdown&quot;&gt;&lt;span&gt;- &lt;&#x2F;span&gt;&lt;span style=&quot;font-weight:bold;color:#fdf4c1aa;&quot;&gt;**LNG-1**&lt;&#x2F;span&gt;&lt;span&gt; (deterministic) The hook must exit 0 and print nothing
&lt;&#x2F;span&gt;&lt;span&gt;  when the event sets `stop_hook_active`.
&lt;&#x2F;span&gt;&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Le test qui la prouve la cite :&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;rust&quot; style=&quot;background-color:#282828;color:#fdf4c1aa;&quot; class=&quot;language-rust &quot;&gt;&lt;code class=&quot;language-rust&quot; data-lang=&quot;rust&quot;&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;&#x2F;&#x2F; spec: LNG-1
&lt;&#x2F;span&gt;&lt;span&gt;#[&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;test&lt;&#x2F;span&gt;&lt;span&gt;]
&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;fn &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;the_hook_lets_go_once_it_sent_the_agent_back&lt;&#x2F;span&gt;&lt;span&gt;() {
&lt;&#x2F;span&gt;&lt;span&gt;    &lt;&#x2F;span&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;&#x2F;&#x2F; ...
&lt;&#x2F;span&gt;&lt;span&gt;}
&lt;&#x2F;span&gt;&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Un contrôle échoue si une exigence acceptée n&#x27;est citée par aucun test. Un autre signale les formulations floues (« should », « etc. », « fast »…) avant la validation.
Ce qu&#x27;aucun test ne peut prouver n&#x27;entre pas dans la spec, et ce qui n&#x27;est pas spécifié relève de la liberté d&#x27;implémentation. On l&#x27;assume.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;la-spec-est-le-code-source-le-llm-est-le-compilateur&quot;&gt;La spec est le code source, le LLM est le compilateur&lt;&#x2F;h2&gt;
&lt;p&gt;Pendant des décennies, la chaîne a été : code source, assembleur, binaire. Qui relit encore l&#x27;assembleur produit par son compilateur ?
Avec un agent, la chaîne devient : issue, spec, code. Alors à quoi bon tout relire ?&lt;&#x2F;p&gt;
&lt;p&gt;L&#x27;analogie a une faille, et il faut la regarder en face.
Si on ne relit plus l&#x27;assembleur, c&#x27;est parce que le compilateur est digne de confiance : il est déterministe, il préserve la sémantique, et des suites de validation le vérifient depuis des décennies.
Un LLM n&#x27;offre aucune de ces garanties. La confiance doit donc venir d&#x27;ailleurs : d&#x27;une vérification à chaque « compilation ».&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;cardinal-compilateur.svg&quot; alt=&quot;Hier : code source, compilateur, assembleur, binaire, et l&#x27;humain relit le code source. Avec un agent : issue, spec, LLM plus vérifications, code, et l&#x27;humain valide la spec.&quot;&gt;
  &lt;figcaption&gt;La relecture ne disparaît pas : elle change de place.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;p&gt;D&#x27;où ma réponse : &lt;strong&gt;on cesse de relire le code quand la vérification est assez forte pour remplacer la lecture.&lt;&#x2F;strong&gt;
La relecture remonte vers la spec, que l&#x27;humain valide, et elle est automatisée pour le code.
Au passage, une spec dont chaque exigence est prouvée par un test sert à la fois de cahier de recette et de documentation à jour. Et comme elle décrit un comportement plutôt qu&#x27;une architecture, elle permet en principe de réimplémenter le logiciel autrement.&lt;&#x2F;p&gt;
&lt;p&gt;En principe. Car les limites existent :&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Les vérifications ne sont pas indépendantes&lt;&#x2F;strong&gt; : la revue est faite par un modèle, les tests par l&#x27;agent lui-même, et deux modèles ont tendance à se tromper de la même façon. C&#x27;est pourquoi &lt;a href=&quot;&#x2F;agentic-coding-ingenierie-obligatoire&#x2F;&quot;&gt;je relis les tests avant le code&lt;&#x2F;a&gt;.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Une spec est incomplète, le code ne l&#x27;est jamais&lt;&#x2F;strong&gt; : ce que la spec ne dit pas (un message d&#x27;erreur, un ordre de sortie), le modèle le décide arbitrairement. Et la &lt;a href=&quot;https:&#x2F;&#x2F;www.hyrumslaw.com&#x2F;&quot;&gt;loi de Hyrum&lt;&#x2F;a&gt; (Hyrum Wright, Google) nous rappelle que des utilisateurs finiront par en dépendre.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Le comportement ne couvre pas tout&lt;&#x2F;strong&gt; : performance, sécurité, maintenabilité échappent à une spec comportementale. Le code critique restera lu, comme on relit encore l&#x27;assembleur pour optimiser ou auditer.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Réimplémenter suppose des tests boîte noire&lt;&#x2F;strong&gt; : un test unitaire Rust ne prouve rien pour une version en Go. Cardinal prouve donc de plus en plus ses exigences à la frontière du binaire, sans en faire un dogme quand un tel test serait lent ou fragile.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;h2 id=&quot;juste-assez-de-controle&quot;&gt;Juste assez de contrôle&lt;&#x2F;h2&gt;
&lt;p&gt;Ce que j&#x27;apprécie le plus au quotidien, c&#x27;est le dosage. Assez de contrôle pour être rassuré, assez d&#x27;autonomie pour ne pas tomber dans la microgestion.&lt;&#x2F;p&gt;
&lt;p&gt;Le secret : placer les arrêts humains selon le risque, pas selon les phases.
L&#x27;agent prépare dans l&#x27;issue sa compréhension, la spec et le plan, puis s&#x27;arrête une seule fois pour validation.
Ses questions arrivent dans un tableau numéroté, avec des options et sa recommandation. On répond &lt;code&gt;1 a, 2 c&lt;&#x2F;code&gt;, ou &lt;code&gt;ok&lt;&#x2F;code&gt; pour tout accepter.
Ensuite, il passe en mode autonome et enchaîne les livrables.
Ce que l&#x27;autonomie ne lève jamais : la revue de chaque livrable, une revue approfondie de l&#x27;ensemble, et l&#x27;interdiction de publier (&lt;code&gt;git push&lt;&#x2F;code&gt;), de supprimer ou de réécrire l&#x27;historique sans mon accord.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;cardinal-flow.svg&quot; alt=&quot;Le parcours d&#x27;une issue : préparation, un seul arrêt de validation humaine, puis en mode autonome, livrable après livrable, test rouge, code, test vert, revue et commit, jusqu&#x27;à la clôture.&quot;&gt;
  &lt;figcaption&gt;Un seul arrêt humain, puis des garde-fous qui ne se lèvent jamais.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;p&gt;Autrement dit, &lt;strong&gt;la confiance vient des garde-fous exécutés, pas des validations répétées.&lt;&#x2F;strong&gt;&lt;&#x2F;p&gt;
&lt;p&gt;Deuxième ingrédient, moins visible : des rapports courts.
Une règle chargée dans chaque session impose des tableaux et des listes, sans récit des étapes, sans répéter ce que le diff montre déjà.
L&#x27;attention humaine est la ressource la plus rare de la boucle. Un rapport de quarante lignes à chaque livrable, on finit par le valider sans le lire. Autant dire qu&#x27;on ne contrôle plus rien.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;spec-kit-et-consorts&quot;&gt;Spec-kit et consorts&lt;&#x2F;h2&gt;
&lt;p&gt;Le &lt;em&gt;Spec Driven Development&lt;&#x2F;em&gt; a ses outils, et les frameworks génériques répondent à d&#x27;autres situations que la mienne :&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;github&#x2F;spec-kit&quot;&gt;spec-kit&lt;&#x2F;a&gt;&lt;&#x2F;strong&gt; : une demi-douzaine de documents par fonctionnalité avant le code (spec, plan, modèle de données, contrats d&#x27;API, tâches), pensé pour une équipe et un projet neuf. Dans son flux de base, rien ne relie la spec aux tests.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;Fission-AI&#x2F;OpenSpec&quot;&gt;OpenSpec&lt;&#x2F;a&gt;&lt;&#x2F;strong&gt; : des specs vivantes et un dossier par changement. Le plus proche de Cardinal, mais aucune gate ne bloque l&#x27;agent, et rien ne relie les specs aux tests.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;https:&#x2F;&#x2F;kiro.dev&#x2F;&quot;&gt;Kiro&lt;&#x2F;a&gt;&lt;&#x2F;strong&gt; : un IDE avec exigences, conception, tâches et hooks. Le même esprit, dans un environnement fermé.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;bmad-code-org&#x2F;BMAD-METHOD&quot;&gt;BMAD&lt;&#x2F;a&gt;&lt;&#x2F;strong&gt; : une équipe agile simulée par des personas. L&#x27;organisation est reproduite, la cérémonie aussi.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;obra&#x2F;superpowers&quot;&gt;Superpowers&lt;&#x2F;a&gt;&lt;&#x2F;strong&gt; : un plugin Claude Code (TDD, plans, sous-agents, revue), proche dans le comportement, mais où tout passe par des consignes.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;p&gt;J&#x27;ai quand même emprunté une idée à spec-kit : quand l&#x27;agent rédige une spec, il doit écrire &lt;code&gt;[NEEDS CLARIFICATION: …]&lt;&#x2F;code&gt; là où il serait tenté de deviner.
Le sur-mesure, c&#x27;est aussi ça : prendre ce qui résout un problème rencontré, et laisser le reste.&lt;&#x2F;p&gt;
&lt;p&gt;Autre choix délibéré : Cardinal ne cible que Claude Code.
Prendre en charge tous les agents du marché, c&#x27;est se limiter à ce qu&#x27;ils ont en commun : des fichiers Markdown et des consignes. Le syndrome du couteau suisse, qui fait tout, et rien très bien.
En visant un seul agent, Cardinal peut s&#x27;appuyer sur ses hooks, qui refusent au lieu de conseiller.&lt;&#x2F;p&gt;
&lt;p&gt;Il a aussi ses limites. Il est né chez un développeur seul, sur des outils en Rust.
Depuis sa version 1.0, il trace les specs dans les tests de n&#x27;importe quel langage, lance le linter et le formateur que le projet déclare, et laisse plusieurs personnes travailler sans se marcher dessus. Mais aucun projet ne l&#x27;utilise encore en équipe : c&#x27;est la contre-épreuve qui manque.
Et il ne remplace pas le jugement : ses mesures ne valent que par la personne qui les lit.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;ce-que-ca-change-pour-vos-equipes&quot;&gt;Ce que ça change pour vos équipes&lt;&#x2F;h2&gt;
&lt;p&gt;Ce que montre Cardinal ne tient pas à Cardinal.
La qualité, à l&#x27;ère agentique, reste celle qu&#x27;on connaît : des tests fiables, des revues, des décisions écrites, des changements petits.
Ce qui change, c&#x27;est qu&#x27;il faut l&#x27;outiller pour qu&#x27;un agent la respecte sans qu&#x27;un humain le surveille, et la &lt;a href=&quot;&#x2F;le-cordonnier-bien-chausse&#x2F;&quot;&gt;mesurer&lt;&#x2F;a&gt; pour savoir si l&#x27;outillage tient ses promesses.&lt;&#x2F;p&gt;
&lt;p&gt;Cardinal n&#x27;est donc pas fait pour être adopté tel quel. Il est taillé pour mes projets ; le vôtre ressemblera à vos projets, à vos risques et à votre équipe.
Vous donner Cardinal, ce serait vous donner un poisson. Et le proverbe est connu :&lt;&#x2F;p&gt;
&lt;blockquote&gt;
&lt;p&gt;Donne un poisson à un homme, il mangera un jour. Apprends-lui à pêcher, il mangera toute sa vie.
— Proverbe&lt;&#x2F;p&gt;
&lt;&#x2F;blockquote&gt;
&lt;p&gt;Vos agents produisent vite, mais vous hésitez à leur faire confiance ?
Vos développeurs passent leurs journées à relire du code généré, ou ont cessé de le relire ?
C&#x27;est ce que je vous aide à résoudre : livrer mieux avec des agents, sans perdre la main, et avec des développeurs à l&#x27;aise.&lt;&#x2F;p&gt;
&lt;p&gt;On part de vos projets et de vos incidents réels, et l&#x27;outillage suit.
Je reste le temps que votre équipe sache pêcher seule.&lt;&#x2F;p&gt;
&lt;p&gt;Si le sujet vous parle, &lt;a href=&quot;&#x2F;contact&#x2F;&quot;&gt;écrivez-moi&lt;&#x2F;a&gt; !&lt;&#x2F;p&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;&lt;em&gt;Sources : &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;github&#x2F;spec-kit&quot;&gt;GitHub spec-kit&lt;&#x2F;a&gt; et sa &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;github&#x2F;spec-kit&#x2F;blob&#x2F;main&#x2F;spec-driven.md&quot;&gt;méthode&lt;&#x2F;a&gt; · &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;Fission-AI&#x2F;OpenSpec&quot;&gt;OpenSpec&lt;&#x2F;a&gt; · &lt;a href=&quot;https:&#x2F;&#x2F;kiro.dev&#x2F;&quot;&gt;Kiro&lt;&#x2F;a&gt; · &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;bmad-code-org&#x2F;BMAD-METHOD&quot;&gt;BMAD-METHOD&lt;&#x2F;a&gt; · &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;obra&#x2F;superpowers&quot;&gt;Superpowers&lt;&#x2F;a&gt; · Diane Sarkis, &lt;a href=&quot;https:&#x2F;&#x2F;claude.com&#x2F;fr&#x2F;resources&#x2F;articles&#x2F;building-agents-when-to-fold-subagents-into-your-main-agent-loop&quot;&gt;Building agents: when to fold subagents into your main agent loop&lt;&#x2F;a&gt; · Hyrum Wright, &lt;a href=&quot;https:&#x2F;&#x2F;www.hyrumslaw.com&#x2F;&quot;&gt;Hyrum&#x27;s Law&lt;&#x2F;a&gt; · &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;Electron-libre&#x2F;cardinal&quot;&gt;Cardinal&lt;&#x2F;a&gt;&lt;&#x2F;em&gt;&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="fr">
        <title>Le cordonnier bien chaussé : un outillage d&#x27;agent qui se mesure lui-même</title>
        <published>2026-11-02T09:00:00+00:00</published>
        <updated>2026-11-02T09:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://meta-lambda.com/le-cordonnier-bien-chausse/"/>
        <id>https://meta-lambda.com/le-cordonnier-bien-chausse/</id>
        
        <content type="html" xml:base="https://meta-lambda.com/le-cordonnier-bien-chausse/">&lt;p&gt;Un outillage pour agents de code tient-il ses promesses ?&lt;&#x2F;p&gt;
&lt;p&gt;Dans &lt;a href=&quot;&#x2F;un-outillage-sur-mesure&#x2F;&quot;&gt;La qualité à l&#x27;ère agentique : un outillage sur mesure&lt;&#x2F;a&gt;, je présentais &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;Electron-libre&#x2F;cardinal&quot;&gt;Cardinal&lt;&#x2F;a&gt;, l&#x27;outillage que j&#x27;ai construit pour faire travailler des agents sur mes projets : des specs reliées aux tests, des &lt;em&gt;gates&lt;&#x2F;em&gt; (des contrôles qui bloquent au lieu de conseiller), un seul arrêt de validation humaine.&lt;&#x2F;p&gt;
&lt;p&gt;Reste une question qu&#x27;on pose rarement à ce genre d&#x27;outil : est-ce que ça marche vraiment ?
Les règles qu&#x27;on donne à un agent sont le plus souvent validées « au feeling ». (J&#x27;en parlais dans &lt;a href=&quot;&#x2F;agentic-coding-ingenierie-obligatoire&#x2F;&quot;&gt;L&#x27;agentic coding ne réinvente pas l&#x27;ingénierie logicielle&lt;&#x2F;a&gt;.)&lt;&#x2F;p&gt;
&lt;p&gt;Cardinal, lui, se mesure. Et il a été construit avec lui-même, ce qui ne gâche rien.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;cardinal-mark.svg&quot; alt=&quot;L&#x27;emblème de Cardinal : une rose des vents dans un cercle, la pointe nord en or, les trois autres en gris clair.&quot; style=&quot;width: 160px&quot;&gt;
  &lt;figcaption&gt;Un seul point en or : le cap.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;h2 id=&quot;construit-avec-lui-meme&quot;&gt;Construit avec lui-même&lt;&#x2F;h2&gt;
&lt;p&gt;On dit que les cordonniers sont les plus mal chaussés. Cardinal, lui, a été construit avec Cardinal : chaque issue est passée par sa procédure, et chaque commit par sa propre &lt;em&gt;gate&lt;&#x2F;em&gt; de revue.
En une semaine, du 24 au 30 octobre : 121 issues closes et déjà une version 1.1 avec son &lt;em&gt;changelog&lt;&#x2F;em&gt;.
Le travail à venir a même sa feuille de route, découpée en jalons qui deviennent des issues le moment venu.&lt;&#x2F;p&gt;
&lt;p&gt;Cette récursion a un effet précieux : &lt;strong&gt;l&#x27;outil révèle ses propres défauts en servant.&lt;&#x2F;strong&gt;&lt;&#x2F;p&gt;
&lt;p&gt;Un jour, la &lt;em&gt;gate&lt;&#x2F;em&gt; de revue refuse un commit qui ne touchait que des issues. Un fichier de spec inconnu venait d&#x27;apparaître dans le répertoire de travail : le brouillon d&#x27;une autre session, lancée en parallèle… dans le même répertoire. Ça commence bien.
En remontant le fil, l&#x27;agent constate que, sur 188 sessions de traitement d&#x27;issue dans cinq projets, aucune n&#x27;avait jamais utilisé les &lt;em&gt;worktrees&lt;&#x2F;em&gt; (des copies de travail séparées du dépôt) prévus pour le travail en parallèle.
La fonctionnalité existait, sa spec aussi. Rien ne conduisait l&#x27;agent à s&#x27;en servir.&lt;&#x2F;p&gt;
&lt;p&gt;La première correction a confié à l&#x27;agent la création du worktree. L&#x27;usage a vite montré que Claude Code y bloque alors des dizaines de commandes ordinaires.
On a fini à l&#x27;opposé de la piste de départ : c&#x27;est l&#x27;humain qui ouvre le worktree, et seulement pour du travail parallèle.&lt;&#x2F;p&gt;
&lt;p&gt;La récursion a aussi un revers : elle renforce les biais.
Un outil construit en se développant lui-même devient excellent… pour développer des outils en Rust qui se vérifient eux-mêmes.
Mes autres projets, dont &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;Electron-libre&#x2F;RetroDoc&quot;&gt;RetroDoc&lt;&#x2F;a&gt;, servent de contre-épreuve, mais ce sont encore des projets à moi.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;deux-boucles&quot;&gt;Deux boucles&lt;&#x2F;h2&gt;
&lt;p&gt;Cardinal fait tourner deux boucles.
La boucle interne tourne à chaque livrable : test rouge puis vert, linter, contrôle des specs, revue. Elle améliore le code.
La boucle externe tourne à chaque version de l&#x27;outil : des programmes lisent les journaux des sessions Claude Code et l&#x27;historique git, puis mesurent mes interventions, les règles enfreintes, les remarques de revue, les correctifs après clôture. Elle améliore l&#x27;outil.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;cardinal-deux-boucles.svg&quot; alt=&quot;Au centre, la boucle interne : test, code, revue, commit. Autour, la boucle externe : sessions de travail, journaux et historique git, mesures, nouvelle version de l&#x27;outil.&quot;&gt;
  &lt;figcaption&gt;Deux boucles : l&#x27;une améliore le code, l&#x27;autre améliore l&#x27;outil.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;p&gt;Un exemple : la médiane, par session, des messages que je tape, selon la version de Cardinal en service.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;cardinal-messages.svg&quot; alt=&quot;Médiane par session des messages tapés, pour dix versions successives de Cardinal du 24 au 30 octobre, de 10 à 41 sessions chacune. Simples validations : 1, 3, puis 2 à chaque version. Autres messages : 5, 3, puis 1 à chaque version sauf une à 2. Le mode autonome arrive avec la deuxième version, les rapports courts et le passage de Sonnet à Opus avec la troisième.&quot;&gt;
  &lt;figcaption&gt;Moins de corrections et de relances, mais le modèle a changé en cours de route.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;p&gt;Les validations augmentent un peu, ce qui est attendu avec l&#x27;arrêt de validation unique. Les autres messages (corrections, relances, précisions) passent de 5 à 1, et y restent sur les huit versions suivantes, à une exception près.
Pas de quoi crier victoire pour autant. La première baisse est arrivée avec le mode autonome, quand les sessions tournaient encore surtout sur Sonnet. La seconde coïncide avec le passage à Opus : impossible de dire ce qui revient aux rapports courts.
Et cela mesure mes interventions, pas la qualité du code livré. Un indice, pas une preuve.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;mesurer-sans-viser-un-chiffre&quot;&gt;Mesurer sans viser un chiffre&lt;&#x2F;h2&gt;
&lt;p&gt;Mesurer expose à un &lt;a href=&quot;https:&#x2F;&#x2F;fr.wikipedia.org&#x2F;wiki&#x2F;Loi_de_Goodhart&quot;&gt;piège&lt;&#x2F;a&gt; que l&#x27;économiste Charles Goodhart avait repéré dès 1975, et que l&#x27;anthropologue Marilyn Strathern a résumé ainsi :&lt;&#x2F;p&gt;
&lt;blockquote&gt;
&lt;p&gt;When a measure becomes a target, it ceases to be a good measure.
— Marilyn Strathern, &lt;a href=&quot;https:&#x2F;&#x2F;econpapers.repec.org&#x2F;RePEc:cup:eurrev:v:5:y:1997:i:03:p:305-321_00&quot;&gt;&lt;em&gt;‘Improving ratings’: audit in the British University system&lt;&#x2F;em&gt;&lt;&#x2F;a&gt;, European Review, 1997&lt;&#x2F;p&gt;
&lt;&#x2F;blockquote&gt;
&lt;p&gt;J&#x27;y suis tombé deux fois.&lt;&#x2F;p&gt;
&lt;p&gt;La première, avec la &lt;em&gt;gate&lt;&#x2F;em&gt; de revue. Chaque revue de son &lt;em&gt;hook&lt;&#x2F;em&gt; (un script que Claude Code exécute autour des actions de l&#x27;agent) trouvait une commande shell qui lui échappait, et chacune devenait une exigence. En deux jours, environ un tiers des issues closes jusque-là lui étaient consacrées.
Une décision d&#x27;architecture y a mis un terme : les &lt;em&gt;gates&lt;&#x2F;em&gt; attrapent les erreurs d&#x27;un agent coopératif, pas les contournements délibérés.&lt;&#x2F;p&gt;
&lt;p&gt;La seconde, avec les preuves à la frontière. Un avertissement signalait les exigences prouvées seulement par des tests internes, et l&#x27;agent s&#x27;est mis à écrire des tests de bout en bout, longs et fragiles, pour le faire taire.
Il ne trichait pas : il optimisait ce qu&#x27;on lui montrait. L&#x27;avertissement est resté une indication, pas une cible à ramener à zéro.&lt;&#x2F;p&gt;
&lt;p&gt;L&#x27;évaluation, elle, ne transforme jamais un chiffre en verdict « réussi » ou « échoué ».
Chaque changement de l&#x27;outil peut annoncer l&#x27;effet qu&#x27;il attend, et le rapport dit s&#x27;il l&#x27;a eu, ou s&#x27;il ne peut pas conclure parce que le modèle ou les projets ont changé entre-temps. Les deux verdicts enregistrés à ce jour sont d&#x27;ailleurs… « non concluants ».
C&#x27;est la limite d&#x27;une mesure qui observe sans contrôler. Prochaine étape, déjà sur la feuille de route : rejouer un même jeu de tâches avec deux variantes de l&#x27;outil, pour passer de l&#x27;observation à l&#x27;expérience.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;des-chiffres-pas-toujours-flatteurs&quot;&gt;Des chiffres pas toujours flatteurs&lt;&#x2F;h2&gt;
&lt;p&gt;Et c&#x27;est tant mieux.
Sur Cardinal lui-même, les premières issues mesurées ont été suivies d&#x27;une dizaine de commits de correction chacune, les plus récentes de moins d&#x27;un.
Belle courbe ! Sauf que les plus récentes ont eu quelques jours de moins pour révéler leurs défauts. On jugera dans un mois.&lt;&#x2F;p&gt;
&lt;p&gt;La mesure sert aussi à enterrer une bonne idée.
Un &lt;em&gt;hook&lt;&#x2F;em&gt; devait rappeler à l&#x27;agent de répondre dans ma langue entre deux actions, pas seulement à la fin de son tour. Ses tests passaient tous.
Mesuré en session réelle, le rappel n&#x27;arrivait presque jamais : Claude Code déclenche le &lt;em&gt;hook&lt;&#x2F;em&gt; avant d&#x27;avoir écrit le texte qu&#x27;il devait juger. Des tests verts, et aucun effet. On l&#x27;a retiré.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;creuser-le-tunnel-par-les-deux-bouts&quot;&gt;Creuser le tunnel par les deux bouts&lt;&#x2F;h2&gt;
&lt;p&gt;Reste un cas que Cardinal traite mal : le code existant.
Une capacité qui n&#x27;a jamais été modifiée par une issue n&#x27;a pas de spec, et la procédure qui en déduit une du code ne peut énoncer que ce qui est déjà testé.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;Electron-libre&#x2F;RetroDoc&quot;&gt;RetroDoc&lt;&#x2F;a&gt; creuse dans l&#x27;autre sens. Il part d&#x27;un dépôt existant et en reconstruit la documentation fonctionnelle, chaque étape citant le code qui la justifie. (C&#x27;est ma réponse à &lt;a href=&quot;&#x2F;la-dette-de-documentation&#x2F;&quot;&gt;la dette de documentation&lt;&#x2F;a&gt;.)&lt;&#x2F;p&gt;
&lt;p&gt;RetroDoc remonte du code vers le comportement. Cardinal descend de l&#x27;intention vers le code, en documentant en chemin.
Les deux se rejoignent sur les specs de comportement. Les relier reste une perspective, mais le chemin est tracé : récupérer la connaissance perdue, puis cesser de la perdre.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;cardinal-tunnel.svg&quot; alt=&quot;Un tunnel creusé par les deux bouts : Cardinal part de l&#x27;intention, RetroDoc part du code existant, et les deux galeries convergent vers les specs de comportement sans être encore reliées.&quot;&gt;
  &lt;figcaption&gt;Deux galeries, un même point de rencontre : les specs.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;h2 id=&quot;et-chez-vous&quot;&gt;Et chez vous ?&lt;&#x2F;h2&gt;
&lt;p&gt;À quoi sert cette boucle, au fond ? À augmenter la confiance qu&#x27;on peut accorder à l&#x27;agent.
Par des preuves qui se renforcent, et par des mesures qui disent s&#x27;il dérape moins.&lt;&#x2F;p&gt;
&lt;p&gt;Pas besoin de Cardinal pour s&#x27;y mettre. Vos agents laissent déjà des journaux de session, et votre dépôt garde l&#x27;historique de ce qu&#x27;ils ont livré : il suffit de commencer à les lire.
(Et si vous voulez de l&#x27;aide pour outiller vos équipes, c&#x27;est &lt;a href=&quot;&#x2F;un-outillage-sur-mesure&#x2F;#ce-que-ca-change-pour-vos-equipes&quot;&gt;par ici&lt;&#x2F;a&gt;.)&lt;&#x2F;p&gt;
&lt;p&gt;L&#x27;équipe Applied AI d&#x27;Anthropic ne dit pas autre chose quand elle conseille, pour faire évoluer un agent, de :&lt;&#x2F;p&gt;
&lt;blockquote&gt;
&lt;p&gt;measure, change one thing at a time, and keep what holds up.
— Diane Sarkis, &lt;em&gt;&lt;a href=&quot;https:&#x2F;&#x2F;claude.com&#x2F;fr&#x2F;resources&#x2F;articles&#x2F;building-agents-when-to-fold-subagents-into-your-main-agent-loop&quot;&gt;Building agents: when to fold subagents into your main agent loop&lt;&#x2F;a&gt;&lt;&#x2F;em&gt;&lt;&#x2F;p&gt;
&lt;&#x2F;blockquote&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;&lt;em&gt;Sources : &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;Electron-libre&#x2F;cardinal&quot;&gt;Cardinal&lt;&#x2F;a&gt; · &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;Electron-libre&#x2F;RetroDoc&quot;&gt;RetroDoc&lt;&#x2F;a&gt; · &lt;a href=&quot;https:&#x2F;&#x2F;fr.wikipedia.org&#x2F;wiki&#x2F;Loi_de_Goodhart&quot;&gt;Loi de Goodhart&lt;&#x2F;a&gt; · Diane Sarkis, &lt;a href=&quot;https:&#x2F;&#x2F;claude.com&#x2F;fr&#x2F;resources&#x2F;articles&#x2F;building-agents-when-to-fold-subagents-into-your-main-agent-loop&quot;&gt;Building agents: when to fold subagents into your main agent loop&lt;&#x2F;a&gt;&lt;&#x2F;em&gt;&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="fr">
        <title>Intégrer l&#x27;IA sans jeter l&#x27;argent par la fenêtre de contexte</title>
        <published>2026-10-12T00:00:00+00:00</published>
        <updated>2026-10-12T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://meta-lambda.com/integrer-ia-sans-jeter-argent-fenetre-contexte/"/>
        <id>https://meta-lambda.com/integrer-ia-sans-jeter-argent-fenetre-contexte/</id>
        
        <content type="html" xml:base="https://meta-lambda.com/integrer-ia-sans-jeter-argent-fenetre-contexte/">&lt;p&gt;Dans un &lt;em&gt;pipeline&lt;&#x2F;em&gt; qui enchaîne des appels à un LLM, l&#x27;étape qui fait le plus d&#x27;appels n&#x27;est pas forcément celle qui coûte le plus cher.
Et chaque jeton envoyé dans la fenêtre de contexte a un coût : en argent chez un fournisseur d&#x27;API, en latence, et en calcul, donc indirectement en énergie.
Ce coût grimpe vite avec la taille des données.&lt;&#x2F;p&gt;
&lt;p&gt;Or une partie de cette dépense peut être évitée : des contenus renvoyés à l&#x27;identique, des étapes rejouées, des questions que du code aurait réglées seul.&lt;&#x2F;p&gt;
&lt;p&gt;Repérer et supprimer ce gaspillage n&#x27;est pas une affaire de bonnes intentions : la frugalité est de l&#x27;ingénierie de performance, avec les mêmes réflexes que d&#x27;habitude.
Voici ceux que j&#x27;ai retenus en développant &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;Electron-libre&#x2F;RetroDoc&quot;&gt;RetroDoc&lt;&#x2F;a&gt;, un outil qui reconstruit la documentation d&#x27;un dépôt Git à partir de son code (j&#x27;en parlais dans &lt;a href=&quot;&#x2F;la-dette-de-documentation&#x2F;&quot;&gt;La dette de documentation&lt;&#x2F;a&gt;).
Les principes valent pour d&#x27;autres projets de ce genre, mais les gains que je cite dépendent de mon projet, de mon modèle et de mes données : RetroDoc ne sert qu&#x27;à les illustrer.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;avant-d-optimiser-trouvez-ce-qui-pese-vraiment&quot;&gt;Avant d&#x27;optimiser, trouvez ce qui pèse vraiment&lt;&#x2F;h2&gt;
&lt;p&gt;Ne vous fiez pas à l&#x27;intuition.
Appels, jetons et temps ne se répartissent pas de la même façon entre les étapes d&#x27;un &lt;em&gt;pipeline&lt;&#x2F;em&gt;, et on est toujours tenté de s&#x27;attaquer à celle qui fait le plus d&#x27;appels.&lt;&#x2F;p&gt;
&lt;p&gt;Chez moi, une étape de résumé fait 45 à 55 % des appels sur une application d&#x27;environ 180 fichiers. La cible idéale !
Sauf que ses &lt;em&gt;prompts&lt;&#x2F;em&gt; sont petits : elle ne pèse que 9 à 17 % du temps.
L&#x27;essentiel se passe dans une autre étape : 61 % du temps en local (72,6 minutes sur 118,4), 72 % avec DeepSeek.
La supprimer aurait économisé des appels, pas des heures.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;frugalite-mesure.svg&quot; alt=&quot;Deux étapes d&#x27;un pipeline : le résumé des fichiers fait 49 % des appels mais 17 % du temps, les use cases font 39 % des appels mais 72 % du temps.&quot;&gt;
  &lt;figcaption&gt;Le nombre d&#x27;appels ne dit pas où passe le temps.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;p&gt;Knuth le disait déjà en 1974, bien avant les LLM :&lt;&#x2F;p&gt;
&lt;blockquote&gt;
&lt;p&gt;It is often a mistake to make a priori judgments about what parts of a program are really critical, since the universal experience of programmers who have been using measurement tools has been that their intuitive guesses fail.
— Donald Knuth, &lt;em&gt;Structured Programming with go to Statements&lt;&#x2F;em&gt;&lt;&#x2F;p&gt;
&lt;&#x2F;blockquote&gt;
&lt;p&gt;Pour ne pas avoir à deviner, faites afficher cette répartition à chaque exécution : un récapitulatif des appels, des jetons et du temps, étape par étape et modèle par modèle.
Si votre fournisseur les expose, séparez les jetons d&#x27;entrée des jetons de sortie (ils ne pèsent pas pareil), repérez ceux qu&#x27;un cache de &lt;em&gt;prompt&lt;&#x2F;em&gt; a déjà traités, et comptez à part les appels échoués ou rejoués.
Une étape peut en effet consommer beaucoup de jetons sans être lente, ou l&#x27;inverse.&lt;&#x2F;p&gt;
&lt;p&gt;Deux précautions rendent ce récapitulatif fiable.
Ne comptez que les jetons que le serveur rapporte, sans les estimer à partir du nombre de caractères, quitte à signaler que le total est sous-estimé.
Et si vous affichez un prix, datez-le : les tarifs changent plus vite que votre code, et une seule grille ne vaut pas pour plusieurs modèles.
À défaut, donnez au moins les volumes de jetons, qui permettent de le calculer.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;reutilisez-ce-qui-est-deja-fait&quot;&gt;Réutilisez ce qui est déjà fait&lt;&#x2F;h2&gt;
&lt;p&gt;Si les données qu&#x27;un traitement reçoit n&#x27;ont pas changé depuis la dernière exécution, inutile de rappeler le modèle : on réutilise le résultat déjà obtenu.
Associez à chaque résultat une clé calculée sur ce dont il dépend (le contenu des documents lus, le modèle utilisé, la version du &lt;em&gt;prompt&lt;&#x2F;em&gt;) et sautez ce qui est à jour.
La clé doit couvrir tout ce qui peut changer le résultat : selon votre système, cela peut inclure aussi les paramètres de génération ou le format de sortie attendu.&lt;&#x2F;p&gt;
&lt;p&gt;Enregistrez après chaque appel, pas à la fin : une exécution interrompue reprend alors où elle s&#x27;était arrêtée, au lieu de jeter le travail déjà fait.&lt;&#x2F;p&gt;
&lt;p&gt;Un cache n&#x27;est utile que si ses clés sont stables.
Dans mon cas, une étape intermédiaire n&#x27;était pas déterministe : ses identifiants changeaient à chaque exécution, toutes les clés en aval aussi, et une relance « sans changement » refaisait tout. Le tonneau des Danaïdes !
Cherchez ce qui, dans votre &lt;em&gt;pipeline&lt;&#x2F;em&gt;, rend vos clés instables, et décidez à l&#x27;avance ce qui invalide le cache : si changer un &lt;em&gt;prompt&lt;&#x2F;em&gt; ne le vide pas, vous servirez de vieux résultats sans le savoir.
Et gardez en tête qu&#x27;avec un modèle non déterministe, réutiliser le cache, c&#x27;est accepter la réponse de la première génération : une mauvaise réponse reste figée tant que l&#x27;entrée ne change pas, ou que vous ne videz pas le cache.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;frugalite-cache.svg&quot; alt=&quot;Une clé calculée sur le contenu, le modèle et la version du prompt. Si elle a déjà été vue, le résultat est réutilisé sans appel ; sinon on appelle le modèle et on enregistre.&quot;&gt;
  &lt;figcaption&gt;Un cache n&#x27;économise que si sa clé est stable.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;h2 id=&quot;lisez-chaque-document-une-seule-fois&quot;&gt;Lisez chaque document une seule fois&lt;&#x2F;h2&gt;
&lt;p&gt;Dans un &lt;em&gt;pipeline&lt;&#x2F;em&gt; à plusieurs étapes (extraction, classification, résumé, vérification), le même document finit souvent dans plusieurs &lt;em&gt;prompts&lt;&#x2F;em&gt;, un par question.
Le modèle relit donc plusieurs fois le même texte.&lt;&#x2F;p&gt;
&lt;p&gt;Deux remèdes.
Poser les questions ensemble dans un seul appel, avec une réponse structurée qui les couvre toutes.
Ou garder le contenu commun en tête de &lt;em&gt;prompt&lt;&#x2F;em&gt; et profiter du cache de &lt;em&gt;prompt&lt;&#x2F;em&gt; si votre fournisseur en propose (il évite de retraiter un début de &lt;em&gt;prompt&lt;&#x2F;em&gt; déjà envoyé).
Ils n&#x27;ont pas les mêmes gains : le premier change la façon d&#x27;interroger le modèle, le second dépend de ce que votre fournisseur propose et facture.&lt;&#x2F;p&gt;
&lt;p&gt;Pour savoir si le jeu en vaut la chandelle, mesurez d&#x27;abord le recouvrement : un petit script qui compte, pour chaque étape, les documents qu&#x27;elle lit, et ce que les étapes ont en commun.
Chez moi, deux étapes de RetroDoc lisaient les mêmes fichiers : 36 % des caractères qu&#x27;elles lisaient portaient sur des fichiers lus deux fois.
En les fusionnant, j&#x27;ai supprimé un tiers des appels et des jetons sur une application réelle.&lt;&#x2F;p&gt;
&lt;p&gt;Mais fusionner n&#x27;est pas gratuit pour la qualité.
L&#x27;ordre des questions compte : en plaçant la question sur les entités en premier, le modèle ne retrouvait plus qu&#x27;un seul point d&#x27;entrée de l&#x27;application (route, commande…) sur une quinzaine.
Et sur une petite bibliothèque de neuf fichiers, la lecture fusionnée retrouvait moins de points d&#x27;entrée que les deux lectures séparées.
Gardez donc l&#x27;ancien chemin disponible, et comparez.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;reservez-le-modele-a-ce-qui-est-ambigu&quot;&gt;Réservez le modèle à ce qui est ambigu&lt;&#x2F;h2&gt;
&lt;p&gt;Si du code peut répondre avec certitude, qu&#x27;il réponde.
Beaucoup de contrôles qu&#x27;on délègue à un LLM relèvent de la vérification mécanique : la source citée existe-t-elle, la valeur annoncée apparaît-elle dans le texte, le JSON respecte-t-il son schéma, le chemin existe-t-il ?
Passez chaque réponse du modèle par ces contrôles, et ne le rappelez que pour les cas douteux.
Un tel contrôle ne doit valider que ce qu&#x27;il peut établir mécaniquement : il conclut « valide », « invalide » ou « indéterminé », et ce dernier cas part au modèle.&lt;&#x2F;p&gt;
&lt;p&gt;Chez moi, chaque étape d&#x27;un &lt;em&gt;use case&lt;&#x2F;em&gt; (un scénario fonctionnel décrit pas à pas) cite les lignes de code qui la justifient, et les faire vérifier par un LLM représentait un appel sur cinq.
Une simple recherche de texte règle une bonne part des cas : le contrôle vérifie que les lignes citées existent et que les noms mentionnés par l&#x27;étape s&#x27;y trouvent, et n&#x27;envoie au modèle que le reste.&lt;&#x2F;p&gt;
&lt;p&gt;Sur une petite bibliothèque, 80 % des étapes passent seules.
Mais un &lt;em&gt;use case&lt;&#x2F;em&gt; n&#x27;est réglé que si toutes ses étapes passent : 6 sur 13, ce qui ramène cette vérification de 8 à 4 appels.
Sur une application plus grande et plus dynamique, seule la moitié des étapes passent seules, et le reste part encore au modèle.
Le gain dépend donc de votre code : annoncez le résultat moyen, pas celui de votre meilleur cas.&lt;&#x2F;p&gt;
&lt;p&gt;Ce contrôle a aussi sa limite : trouver un nom dans le code ne prouve pas que la fonction fait ce que la documentation lui attribue.
Ses scores sont donc un peu optimistes (quand on demande aussi son avis au modèle, il est plus sévère), et on fait relire un échantillon par le modèle pour garder la mesure honnête.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;frugalite-controles.svg&quot; alt=&quot;Deux barres : sur une petite bibliothèque, 80 % des étapes sont validées par les contrôles seuls et 20 % partent au modèle ; sur linkding, environ 50 % et 50 %.&quot;&gt;
  &lt;figcaption&gt;Part des étapes réglées sans appel au modèle.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;p&gt;Le cas « indéterminé » est le plus facile à oublier.
Mon contrôle comptait d&#x27;abord comme valide une affirmation qui ne nommait rien de vérifiable, puisque rien ne la contredisait : 93 % de réussite, ramenés à 80 % après correction.
Un thermomètre qui affiche toujours 37 °C ne signale jamais de fièvre.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;produisez-une-fois-consultez-autant-que-vous-voulez&quot;&gt;Produisez une fois, consultez autant que vous voulez&lt;&#x2F;h2&gt;
&lt;p&gt;Séparez la production de la consommation.
Si le résultat d&#x27;un traitement lourd sert à de nombreuses questions, exposez-le par un chemin de lecture léger (fichiers statiques, index, API en lecture seule) plutôt que de reposer la question au modèle à chaque fois.
Le travail se fait une fois, à la génération.&lt;&#x2F;p&gt;
&lt;p&gt;Dans mon cas, les documents générés sont servis aux agents de code par un serveur en lecture seule, sans clé d&#x27;API ni modèle : une recherche lexicale écrite à la main suffit, sans &lt;em&gt;embeddings&lt;&#x2F;em&gt; tant qu&#x27;on n&#x27;a pas montré qu&#x27;elle échoue sur le vocabulaire du domaine.
Pour le montrer, testez-la sur quelques questions représentatives, avec les synonymes et les formulations indirectes que vos utilisateurs emploieront vraiment, et n&#x27;ajoutez des &lt;em&gt;embeddings&lt;&#x2F;em&gt; que si elle échoue de façon durable.
Les réponses sont déterministes.
Elles préviennent aussi quand un fichier cité a été modifié depuis la génération : un résultat produit une fois peut devenir faux, et le lecteur doit le savoir.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;laissez-l-utilisateur-plafonner-et-dites-ce-qui-reste-dehors&quot;&gt;Laissez l&#x27;utilisateur plafonner, et dites ce qui reste dehors&lt;&#x2F;h2&gt;
&lt;p&gt;Un &lt;em&gt;pipeline&lt;&#x2F;em&gt; LLM doit pouvoir être borné : un plafond sur le nombre de documents, un échantillon pour les vérifications lourdes, une estimation affichée avant de lancer.
Savoir « ça va faire 300 appels » avant de commencer change la décision de lancer ou non.&lt;&#x2F;p&gt;
&lt;p&gt;Mais la limite doit rester un choix visible.
Chez moi, l&#x27;utilisateur peut limiter l&#x27;analyse aux N fichiers les mieux classés, et le rapport liste tout ce qui n&#x27;a pas été analysé.
Attention : plafonner le périmètre ne plafonne pas le travail demandé au modèle, car un fichier long demande plus d&#x27;appels qu&#x27;un fichier court.
Je n&#x27;ai que le plafond de périmètre et l&#x27;estimation avant lancement ; si votre budget est une contrainte ferme, plafonnez aussi les appels ou les jetons.&lt;&#x2F;p&gt;
&lt;p&gt;J&#x27;ai refusé un plafond automatique : abandonner des entrées sans le dire fausse le résultat, et masquerait ici de la dette de documentation, exactement ce que l&#x27;outil doit révéler.
Une borne silencieuse est une dégradation, pas une optimisation.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;mesurez-avant-d-activer-une-optimisation&quot;&gt;Mesurez avant d&#x27;activer une optimisation&lt;&#x2F;h2&gt;
&lt;p&gt;C&#x27;est le conseil qui m&#x27;a le plus servi.
Une optimisation dont on ne connaît pas l&#x27;effet sur le résultat n&#x27;en est pas encore une : un &lt;em&gt;prompt&lt;&#x2F;em&gt; plus court ou un appel en moins qui dégrade silencieusement le résultat déplace le problème, il ne le supprime pas.
Mesurez donc la qualité en même temps que le gain, avec une référence si vous en avez une, et sur plusieurs exécutions, car la variance d&#x27;un LLM peut être aussi grande que l&#x27;effet que vous cherchez.&lt;&#x2F;p&gt;
&lt;p&gt;Un exemple.
Pour alléger les &lt;em&gt;prompts&lt;&#x2F;em&gt;, j&#x27;ai essayé de ne montrer au modèle que la signature et les premières lignes de chaque méthode, au lieu du code complet.
Résultat : des &lt;em&gt;prompts&lt;&#x2F;em&gt; 42 % plus petits. Sur le papier, c&#x27;est un gain net.&lt;&#x2F;p&gt;
&lt;p&gt;Mais en regardant aussi le résultat, le tableau change : le modèle retrouve moins d&#x27;entités (les objets métier du code, comme un utilisateur ou une commande), 77 à 94 par exécution contre 103 à 132 avec le code complet, dans les trois exécutions.
Sans cette seconde mesure, j&#x27;aurais activé l&#x27;optimisation par défaut et perdu de l&#x27;information sans m&#x27;en apercevoir.
Elle reste donc une option, et c&#x27;est un avantage : chaque projet règle le curseur selon ses moyens, la qualité de ses données, la puissance de son modèle, le temps dont il dispose.
Un projet aux données propres et au modèle puissant n&#x27;a pas les mêmes besoins qu&#x27;un projet qui tourne sur un petit modèle local.&lt;&#x2F;p&gt;
&lt;p&gt;La suite logique est de mesurer ce qu&#x27;on perd exactement : compter des entités donne une quantité, pas une qualité.
Avec une liste annotée à la main, on peut calculer la précision (ce que le modèle a trouvé est-il juste ?) et le rappel (a-t-il trouvé tout ce qu&#x27;on attendait ?).&lt;&#x2F;p&gt;
&lt;p&gt;J&#x27;ai appliqué la même démarche à une autre approche, qui réduit de 55 % le nombre d&#x27;appels sur une grosse application mais donne de moins bons résultats sur une petite.
Là aussi, c&#x27;est un réglage plutôt qu&#x27;un choix imposé : à chacun de l&#x27;adapter à la taille de son projet.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;frugalite-gain-perte.svg&quot; alt=&quot;À gauche, les prompts passent de 100 % à 58 % de leur taille. À droite, les entités retrouvées passent de 103-132 à 77-94 selon les exécutions.&quot;&gt;
  &lt;figcaption&gt;Un gain de 42 % sur les prompts, et une perte dans le résultat.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;p&gt;Ces chiffres viennent d&#x27;un modèle local, de peu de dépôts et de trois exécutions par réglage : ils valent pour mon projet, pas forcément pour le vôtre.
C&#x27;est précisément pourquoi il faut les mesurer chez soi.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;concevoir-juste-ce-qu-il-faut&quot;&gt;Concevoir juste ce qu&#x27;il faut&lt;&#x2F;h2&gt;
&lt;p&gt;Rien de spectaculaire là-dedans : des compteurs, des clés de cache stables, des contrôles qui évitent un appel, des limites choisies par l&#x27;utilisateur, et l&#x27;habitude de noter ce qu&#x27;on a mesuré avec ce qu&#x27;on n&#x27;a pas pu mesurer.
Chaque appel évité est un choix qu&#x27;on peut justifier, et chaque appel gardé aussi.&lt;&#x2F;p&gt;
&lt;blockquote&gt;
&lt;p&gt;Il semble que la perfection soit atteinte non quand il n&#x27;y a plus rien à ajouter, mais quand il n&#x27;y a plus rien à retrancher.
— Antoine de Saint-Exupéry, &lt;em&gt;Terre des hommes&lt;&#x2F;em&gt;&lt;&#x2F;p&gt;
&lt;&#x2F;blockquote&gt;
&lt;p&gt;À condition de savoir ce qu&#x27;on retranche. Sans mesure, on coupe à l&#x27;aveugle.&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="fr">
        <title>Ne demandez pas au LLM ce qu&#x27;un parseur sait vérifier</title>
        <published>2026-10-12T00:00:00+00:00</published>
        <updated>2026-10-12T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://meta-lambda.com/ne-demandez-pas-au-llm-ce-quun-parseur-sait-verifier/"/>
        <id>https://meta-lambda.com/ne-demandez-pas-au-llm-ce-quun-parseur-sait-verifier/</id>
        
        <content type="html" xml:base="https://meta-lambda.com/ne-demandez-pas-au-llm-ce-quun-parseur-sait-verifier/">&lt;p&gt;&lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;Electron-libre&#x2F;RetroDoc&quot;&gt;RetroDoc&lt;&#x2F;a&gt; lit un dépôt Git et en reconstruit la documentation fonctionnelle : des domaines, des fonctionnalités, des cas d&#x27;usage décrits étape par étape. (Le contexte est dans &lt;a href=&quot;&#x2F;la-dette-de-documentation&#x2F;&quot;&gt;La dette de documentation&lt;&#x2F;a&gt;.)&lt;&#x2F;p&gt;
&lt;p&gt;Un problème s&#x27;impose vite : &lt;strong&gt;comment savoir si ce que le LLM a écrit est vrai ?&lt;&#x2F;strong&gt; Une documentation fausse est pire que pas de documentation, parce qu&#x27;on s&#x27;y fie.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;chaque-etape-cite-son-code&quot;&gt;Chaque étape cite son code&lt;&#x2F;h2&gt;
&lt;p&gt;La première décision est de rendre l&#x27;affirmation vérifiable. Chaque étape d&#x27;un cas d&#x27;usage doit citer les lignes de code qui la justifient :&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;text&quot; style=&quot;background-color:#282828;color:#fdf4c1aa;&quot; class=&quot;language-text &quot;&gt;&lt;code class=&quot;language-text&quot; data-lang=&quot;text&quot;&gt;&lt;span&gt;Étape 2 — Le système crée la facture
&lt;&#x2F;span&gt;&lt;span&gt;  action      : appelle create_invoice
&lt;&#x2F;span&gt;&lt;span&gt;  source_refs : a.rs, lignes 1 à 1
&lt;&#x2F;span&gt;&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Cette étape fait deux promesses : le fichier &lt;code&gt;a.rs&lt;&#x2F;code&gt; a une ligne 1, et on y trouve &lt;code&gt;create_invoice&lt;&#x2F;code&gt;. Reste à les contrôler.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;premiere-reponse-demander-au-llm&quot;&gt;Première réponse : demander au LLM&lt;&#x2F;h2&gt;
&lt;p&gt;C&#x27;est ce que j&#x27;ai fait d&#x27;abord. Une passe dédiée demande à un modèle, pour chaque étape, un verdict (soutenue, partielle, non soutenue) au vu du code cité. Ça fonctionne, et ça a un défaut de coût : cette passe représente environ &lt;strong&gt;un appel sur cinq&lt;&#x2F;strong&gt; d&#x27;une exécution (8 sur 28 sur un petit dépôt, 72 sur 320 sur un dépôt plus gros).&lt;&#x2F;p&gt;
&lt;p&gt;Surtout, on paie un modèle pour un travail qui n&#x27;en demande pas : les deux promesses ci-dessus se vérifient avec une simple recherche de texte.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;ce-qu-un-programme-peut-etablir&quot;&gt;Ce qu&#x27;un programme peut établir&lt;&#x2F;h2&gt;
&lt;p&gt;Le contrôle (&lt;code&gt;confidence&#x2F;checks.rs&lt;&#x2F;code&gt;, un fichier d&#x27;environ 100 lignes) range chaque étape dans l&#x27;une de quatre catégories (cinq cas ci-dessous) :&lt;&#x2F;p&gt;
&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;Étape&lt;&#x2F;th&gt;&lt;th&gt;Verdict&lt;&#x2F;th&gt;&lt;th&gt;Pourquoi&lt;&#x2F;th&gt;&lt;th&gt;Appel au LLM&lt;&#x2F;th&gt;&lt;&#x2F;tr&gt;&lt;&#x2F;thead&gt;&lt;tbody&gt;
&lt;tr&gt;&lt;td&gt;appelle &lt;code&gt;create_invoice&lt;&#x2F;code&gt;, cite &lt;code&gt;a.rs:1&lt;&#x2F;code&gt;&lt;&#x2F;td&gt;&lt;td&gt;&lt;strong&gt;valide&lt;&#x2F;strong&gt;&lt;&#x2F;td&gt;&lt;td&gt;le nom est bien à la ligne citée&lt;&#x2F;td&gt;&lt;td&gt;non&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;appelle &lt;code&gt;create_invoice&lt;&#x2F;code&gt;, cite &lt;code&gt;a.rs:2&lt;&#x2F;code&gt;&lt;&#x2F;td&gt;&lt;td&gt;&lt;strong&gt;douteuse&lt;&#x2F;strong&gt;&lt;&#x2F;td&gt;&lt;td&gt;le nom existe dans le fichier, mais pas à la ligne citée&lt;&#x2F;td&gt;&lt;td&gt;oui&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;« envoie la commande en cuisine », cite &lt;code&gt;a.rs:1&lt;&#x2F;code&gt;&lt;&#x2F;td&gt;&lt;td&gt;&lt;strong&gt;douteuse&lt;&#x2F;strong&gt;&lt;&#x2F;td&gt;&lt;td&gt;rien de vérifiable dans le texte&lt;&#x2F;td&gt;&lt;td&gt;oui&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;cite &lt;code&gt;a.rs:40&lt;&#x2F;code&gt;, le fichier a 3 lignes&lt;&#x2F;td&gt;&lt;td&gt;&lt;strong&gt;cassée&lt;&#x2F;strong&gt;&lt;&#x2F;td&gt;&lt;td&gt;la citation est fausse, c&#x27;est un fait&lt;&#x2F;td&gt;&lt;td&gt;non&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;ne cite aucun code&lt;&#x2F;td&gt;&lt;td&gt;&lt;strong&gt;sans appui&lt;&#x2F;strong&gt;&lt;&#x2F;td&gt;&lt;td&gt;plafonnée à 0,25&lt;&#x2F;td&gt;&lt;td&gt;non&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;&#x2F;tbody&gt;&lt;&#x2F;table&gt;
&lt;p&gt;Les « noms » que l&#x27;étape promet sont extraits du texte par une heuristique volontairement simple : ce qui est entre accents graves, les &lt;code&gt;snake_case&lt;&#x2F;code&gt;, les &lt;code&gt;CamelCase&lt;&#x2F;code&gt;, les appels de la forme &lt;code&gt;foo(&lt;&#x2F;code&gt;. Les mots ordinaires, même en majuscules, sont de la prose. Les entités métier, elles, viennent du glossaire déjà construit.&lt;&#x2F;p&gt;
&lt;p&gt;Le cœur du contrôle, simplifié :&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;rust&quot; style=&quot;background-color:#282828;color:#fdf4c1aa;&quot; class=&quot;language-rust &quot;&gt;&lt;code class=&quot;language-rust&quot; data-lang=&quot;rust&quot;&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;&#x2F;&#x2F; l&amp;#39;étape nomme des identifiants : sont-ils aux lignes citées ?
&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;if let &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fabd2f;&quot;&gt;Some&lt;&#x2F;span&gt;&lt;span&gt;(missing) &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;=&lt;&#x2F;span&gt;&lt;span&gt; named.&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fabd2f;&quot;&gt;iter&lt;&#x2F;span&gt;&lt;span&gt;().&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fabd2f;&quot;&gt;find&lt;&#x2F;span&gt;&lt;span&gt;(|&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;id&lt;&#x2F;span&gt;&lt;span&gt;| &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;!&lt;&#x2F;span&gt;&lt;span&gt;cited.&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fabd2f;&quot;&gt;contains&lt;&#x2F;span&gt;&lt;span&gt;(&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;&amp;amp;&lt;&#x2F;span&gt;&lt;span&gt;id.&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fabd2f;&quot;&gt;to_lowercase&lt;&#x2F;span&gt;&lt;span&gt;())) {
&lt;&#x2F;span&gt;&lt;span&gt;    &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;return &lt;&#x2F;span&gt;&lt;span&gt;StepCheck::Doubtful(&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fabd2f;&quot;&gt;format!&lt;&#x2F;span&gt;&lt;span&gt;(&lt;&#x2F;span&gt;&lt;span style=&quot;color:#b8bb26;&quot;&gt;&amp;quot;`&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;{missing}&lt;&#x2F;span&gt;&lt;span style=&quot;color:#b8bb26;&quot;&gt;` is not at the cited lines&amp;quot;&lt;&#x2F;span&gt;&lt;span&gt;));
&lt;&#x2F;span&gt;&lt;span&gt;}
&lt;&#x2F;span&gt;&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Seules les étapes douteuses coûtent un appel : les lignes 2 et 3 du tableau. La deuxième est la plus intéressante. Le nom est dans le fichier, donc le code ne peut pas dire si l&#x27;étape est fausse ou si le modèle s&#x27;est simplement trompé de ligne. Là, il faut du jugement, et c&#x27;est précisément ce qu&#x27;on veut acheter au LLM. La troisième est douteuse pour une autre raison, que le paragraphe suivant détaille.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;le-piege-un-controle-qui-ne-sait-pas-dire-je-ne-sais-pas&quot;&gt;Le piège : un contrôle qui ne sait pas dire « je ne sais pas »&lt;&#x2F;h2&gt;
&lt;p&gt;Ma première version du contrôle donnait un résultat superbe : 93 % des étapes valides, 69 % des cas d&#x27;usage réglés sans modèle, 3 appels au lieu de 8. C&#x27;était trop beau, et en relisant le code j&#x27;ai trouvé pourquoi : la troisième ligne du tableau était comptée comme valide. L&#x27;étape « envoie la commande en cuisine » ne nomme aucun identifiant, mais les lignes qu&#x27;elle cite existent, donc le contrôle ne trouvait rien à lui reprocher.&lt;&#x2F;p&gt;
&lt;p&gt;Mais l&#x27;absence de contradiction n&#x27;est pas une preuve. Une étape qui ne dit rien de vérifiable est invérifiable, donc douteuse. Une fois corrigé, le résultat est tombé à 80 % d&#x27;étapes valides et 46 % de cas d&#x27;usage réglés, et la passe fait 4 appels sur 8 possibles au lieu des 3 annoncés. C&#x27;est moins flatteur, mais c&#x27;est la vraie valeur.&lt;&#x2F;p&gt;
&lt;p&gt;Même mésaventure ailleurs dans le projet, avec un contrôle encore plus facile à tromper.&lt;&#x2F;p&gt;
&lt;p&gt;RetroDoc doit découper les gros fichiers pour les faire lire par morceaux : envoyé d&#x27;un bloc, un contrôleur de 34 Ko et 65 actions ne donnait que 9 points d&#x27;entrée, le modèle tronquait ou dépassait sa limite de sortie. Pour que chaque morceau s&#x27;arrête sur une frontière naturelle, il faut savoir où commence une fonction ou une classe, et cela dépend du langage. Je n&#x27;avais pas envie d&#x27;écrire et de maintenir un découpeur par langage, avec le risque de tomber sur un langage que je n&#x27;avais pas prévu.&lt;&#x2F;p&gt;
&lt;p&gt;J&#x27;ai donc délégué ce savoir au LLM. Il reconnaît le langage d&#x27;un projet sans difficulté : on lui demande une expression régulière qui reconnaît le début d&#x27;une définition dans ce langage, et le découpeur coupe avant la dernière ligne qui correspond. Un seul appel remplace n&#x27;importe quel nombre de découpeurs écrits à la main.&lt;&#x2F;p&gt;
&lt;p&gt;Une regex produite par un modèle reste une hypothèse. Je l&#x27;ai donc mesurée avant de l&#x27;utiliser : elle est appliquée aux 20 plus gros fichiers du même type, et la mesure est la part des lignes de définition qu&#x27;elle reconnaît. Sous 90 %, le modèle reçoit jusqu&#x27;à trois demandes de correction, avec les erreurs de compilation de la regex. Sous 50 %, on abandonne et on découpe sur les lignes vides.&lt;&#x2F;p&gt;
&lt;p&gt;Le piège est venu d&#x27;une regex JavaScript terminée par un &lt;code&gt;|&lt;&#x2F;code&gt;. En syntaxe de regex, c&#x27;est une alternative vide, qui correspond à toutes les lignes. Elle reconnaissait donc forcément toutes les lignes de définition, et ma mesure affichait 100 %. Le contrôle ne pouvait pas échouer. J&#x27;ai ajouté une borne dans l&#x27;autre sens : une expression qui correspond à plus de 40 % des lignes d&#x27;un fichier est rejetée comme trop large.&lt;&#x2F;p&gt;
&lt;p&gt;Sur le contrôleur de test, le découpage fait passer de 9 à 37 points d&#x27;entrée. Depuis, tree-sitter, un vrai parseur, a remplacé ce mécanisme pour cinq langages (Ruby, Rust, JavaScript, TypeScript, Python). La regex proposée par le LLM reste en service pour tous les autres, avec ses contrôles.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;ce-que-ca-donne-et-ce-que-ca-ne-prouve-pas&quot;&gt;Ce que ça donne, et ce que ça ne prouve pas&lt;&#x2F;h2&gt;
&lt;p&gt;Sur une petite bibliothèque Ruby (13 cas d&#x27;usage, 75 étapes, modèle local), après correction :&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;80 % des étapes passent seules, 20 % partent au modèle, aucune n&#x27;est cassée ;&lt;&#x2F;li&gt;
&lt;li&gt;6 cas d&#x27;usage sur 13 sont réglés sans aucun appel, du même côté du seuil d&#x27;alerte de 50 % que l&#x27;avis complet du modèle, dans les 6 cas ;&lt;&#x2F;li&gt;
&lt;li&gt;la passe fait 4 appels au lieu de 8.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;p&gt;Sur &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;sissbruecker&#x2F;linkding&quot;&gt;linkding&lt;&#x2F;a&gt;, une application Django d&#x27;environ 180 fichiers source, j&#x27;ai rejoué les contrôles sur trois exécutions déjà sauvegardées (sans aucun appel au modèle, ce sont de simples lectures de fichiers). Le résultat est plus modeste :&lt;&#x2F;p&gt;
&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;Exécution&lt;&#x2F;th&gt;&lt;th&gt;Cas d&#x27;usage&lt;&#x2F;th&gt;&lt;th&gt;Étapes valides&lt;&#x2F;th&gt;&lt;th&gt;Étapes douteuses&lt;&#x2F;th&gt;&lt;th&gt;Étapes cassées&lt;&#x2F;th&gt;&lt;&#x2F;tr&gt;&lt;&#x2F;thead&gt;&lt;tbody&gt;
&lt;tr&gt;&lt;td&gt;1&lt;&#x2F;td&gt;&lt;td&gt;345&lt;&#x2F;td&gt;&lt;td&gt;48 %&lt;&#x2F;td&gt;&lt;td&gt;51 %&lt;&#x2F;td&gt;&lt;td&gt;0 %&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;2&lt;&#x2F;td&gt;&lt;td&gt;161&lt;&#x2F;td&gt;&lt;td&gt;55 %&lt;&#x2F;td&gt;&lt;td&gt;45 %&lt;&#x2F;td&gt;&lt;td&gt;0 %&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;3&lt;&#x2F;td&gt;&lt;td&gt;107&lt;&#x2F;td&gt;&lt;td&gt;54 %&lt;&#x2F;td&gt;&lt;td&gt;46 %&lt;&#x2F;td&gt;&lt;td&gt;0 %&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;&#x2F;tbody&gt;&lt;&#x2F;table&gt;
&lt;p&gt;Les contrôles ne remplacent donc qu&#x27;environ la moitié des verdicts, pas les quatre cinquièmes. Je l&#x27;attribue, sans l&#x27;avoir établi, à du code Python plus dynamique et à des étapes qui nomment moins d&#x27;identifiants vérifiables, mais je n&#x27;ai pas décomposé les causes. Ce qui ne bouge pas, c&#x27;est l&#x27;absence d&#x27;étapes cassées : les citations sont bien formées, le modèle de départ ne les invente pas.&lt;&#x2F;p&gt;
&lt;p&gt;Ce que ces mesures ne disent pas encore : les exécutions sur linkding ont été lancées sans passe de confiance, donc je n&#x27;ai pas d&#x27;avis du modèle pour comparer, et je ne sais pas combien de cas d&#x27;usage se règlent sans appel. Sur la petite bibliothèque, quand on demande quand même son avis au modèle, il est systématiquement plus sévère (écart moyen de 0,25) : il note « partielle » là où le code ne montre pas un détail. Les scores obtenus mécaniquement sont donc un peu optimistes. J&#x27;ai gardé une option qui fait relire un échantillon de cas d&#x27;usage validés par le modèle, uniquement pour mesurer cet écart.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;le-principe&quot;&gt;Le principe&lt;&#x2F;h2&gt;
&lt;p&gt;Le LLM propose, le code dispose. Plus précisément :&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;Si un programme peut établir la réponse, il la donne. Le modèle ne traite que ce qui reste réellement ambigu.&lt;&#x2F;li&gt;
&lt;li&gt;Un contrôle doit pouvoir répondre « je ne peux pas conclure », sinon il valide par défaut.&lt;&#x2F;li&gt;
&lt;li&gt;Un contrôle doit pouvoir échouer, et il faut l&#x27;avoir vu échouer.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;p&gt;C&#x27;est le même réflexe que dans mon environnement de développement avec un agent : &lt;a href=&quot;&#x2F;agentic-coding-ingenierie-obligatoire&#x2F;&quot;&gt;il ne peut pas s&#x27;arrêter&lt;&#x2F;a&gt; tant que &lt;code&gt;cargo clippy -- -D warnings&lt;&#x2F;code&gt; n&#x27;est pas propre. Ce n&#x27;est pas lui qui juge que son code est correct, c&#x27;est un outil qui ne se fatigue pas. Ici, le modèle écrit la documentation et c&#x27;est un programme qui vérifie les citations.&lt;&#x2F;p&gt;
&lt;p&gt;Les choix et les mesures de RetroDoc sont consignés dans des &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;Electron-libre&#x2F;RetroDoc&#x2F;tree&#x2F;master&#x2F;docs&#x2F;adr&quot;&gt;ADR publics&lt;&#x2F;a&gt;, notamment les numéros 0007 et 0026 pour ce qui précède.&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="fr">
        <title>L&#x27;agentic coding ne réinvente pas l&#x27;ingénierie logicielle, il la rend obligatoire</title>
        <published>2026-10-05T00:00:00+00:00</published>
        <updated>2026-10-05T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://meta-lambda.com/agentic-coding-ingenierie-obligatoire/"/>
        <id>https://meta-lambda.com/agentic-coding-ingenierie-obligatoire/</id>
        
        <content type="html" xml:base="https://meta-lambda.com/agentic-coding-ingenierie-obligatoire/">&lt;p&gt;Des tests fiables, une architecture explicite, des builds reproductibles, des changements petits et réversibles, une documentation qui sert vraiment.
Je défends ces idées depuis des années, et elles passaient parfois pour du perfectionnisme. (Quand on est poli.)&lt;&#x2F;p&gt;
&lt;p&gt;Avec les agents de code, la discussion est close : ce ne sont plus des préférences d&#x27;équipe, c&#x27;est la condition pour que l&#x27;outil fonctionne.&lt;&#x2F;p&gt;
&lt;p&gt;C&#x27;est ce que je constate sur le terrain, et c&#x27;est ce que raconte aussi la communauté qui utilise ces outils intensivement.
Voici ce qui en ressort, avec les désaccords qui restent ouverts.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;un-agent-c-est-d-abord-une-boucle&quot;&gt;Un agent, c&#x27;est d&#x27;abord une boucle&lt;&#x2F;h2&gt;
&lt;p&gt;Un assistant classique propose du code, on le relit, on le corrige. Un agent agit : il lit le dépôt, lance des commandes, exécute les tests, observe le résultat et corrige. Un modèle qui n&#x27;exécute jamais son code reste dans le plausible. Un agent qui peut vérifier ce qu&#x27;il produit entre dans un cycle d&#x27;hypothèse, d&#x27;action, d&#x27;observation et de correction.&lt;&#x2F;p&gt;
&lt;p&gt;C&#x27;est un peu le rémoulage d&#x27;une lame : on dégrossit, on contrôle le fil, on corrige, et on recommence. Sans contrôle du fil, on affûte à l&#x27;aveugle.&lt;&#x2F;p&gt;
&lt;p&gt;Simon Willison, qui documente ces pratiques sous le nom d&#x27;&lt;em&gt;&lt;a href=&quot;https:&#x2F;&#x2F;simonwillison.net&#x2F;2026&#x2F;Feb&#x2F;23&#x2F;agentic-engineering-patterns&#x2F;&quot;&gt;agentic engineering&lt;&#x2F;a&gt;&lt;&#x2F;em&gt;, en fait le critère qui distingue l&#x27;agent : il exécute le code qu&#x27;il écrit. Le prompt compte toujours, mais la qualité du résultat dépend surtout de ce que l&#x27;agent peut observer.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;agentic-boucle.svg&quot; alt=&quot;Un cycle en quatre étapes : hypothèse, action, observation, correction. L&#x27;observation s&#x27;appuie sur le compilateur, le linter, les tests, les logs, le navigateur et les métriques.&quot;&gt;
  &lt;figcaption&gt;Hypothèse, action, observation, correction : la boucle ne vaut que par ce qu&#x27;elle observe.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;h2 id=&quot;donner-a-l-agent-quelque-chose-a-observer&quot;&gt;Donner à l&#x27;agent quelque chose à observer&lt;&#x2F;h2&gt;
&lt;p&gt;La question à se poser est simple : si l&#x27;agent modifie quelque chose, comment sait-il que ça marche ? Compilateur, tests, logs, navigateur, métriques : plus ces signaux sont fiables et rapides, plus la boucle est efficace.&lt;&#x2F;p&gt;
&lt;p&gt;Un compilateur strict et un linter intransigeant, c&#x27;est du feedback gratuit. Et ils ne se lassent jamais de répéter la même remarque. Sur un projet Rust, trois commandes suffisent à cadrer un agent :&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;bash&quot; style=&quot;background-color:#282828;color:#fdf4c1aa;&quot; class=&quot;language-bash &quot;&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;cargo fmt --check
&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;cargo clippy&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt; --&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt; -D warnings
&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;cargo test
&lt;&#x2F;span&gt;&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Un développeur humain en tire le même bénéfice. Ce qui change, c&#x27;est qu&#x27;un projet sans ce filet ne fait plus seulement perdre du temps à l&#x27;équipe : il rend l&#x27;agent dangereux.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;le-depot-est-une-interface-et-la-documentation-aussi&quot;&gt;Le dépôt est une interface, et la documentation aussi&lt;&#x2F;h2&gt;
&lt;p&gt;Un dépôt a toujours été une interface pour les humains qui arrivent dans l&#x27;équipe. C&#x27;est maintenant aussi une interface pour les agents : comment démarrer, comment lancer les tests, où est la logique métier, quelles conventions comptent vraiment. Un humain compense une documentation médiocre avec son expérience et ses collègues. Un agent, lui, compense avec des suppositions, et avec beaucoup d&#x27;aplomb. (J&#x27;en parlais déjà dans &lt;a href=&quot;&#x2F;la-dette-de-documentation&#x2F;&quot;&gt;La dette de documentation&lt;&#x2F;a&gt;.)&lt;&#x2F;p&gt;
&lt;p&gt;Le fichier d&#x27;instructions (&lt;code&gt;AGENTS.md&lt;&#x2F;code&gt;, &lt;code&gt;CLAUDE.md&lt;&#x2F;code&gt;) illustre bien cette convergence. Une &lt;a href=&quot;https:&#x2F;&#x2F;research.google&#x2F;pubs&#x2F;from-black-box-to-toolbox-human-centered-explainability-in-developer-authored-agent-rules&#x2F;&quot;&gt;étude qualitative de Google&lt;&#x2F;a&gt; auprès de 12 développeurs montre qu&#x27;il joue un double rôle : instructions pour l&#x27;IA et documentation d&#x27;onboarding pour les humains. Elle montre aussi que les 12 valident leurs règles « au feeling », sans évaluation formelle. L&#x27;échantillon est petit, mais cela rejoint la mise en garde de Birgitta Böckeler (Thoughtworks) : le &lt;em&gt;&lt;a href=&quot;https:&#x2F;&#x2F;martinfowler.com&#x2F;articles&#x2F;exploring-gen-ai&#x2F;context-engineering-coding-agents.html&quot;&gt;context engineering&lt;&#x2F;a&gt;&lt;&#x2F;em&gt; n&#x27;a pas de tests unitaires et reste probabiliste. Son conseil : construire ces règles progressivement plutôt que de tout déverser d&#x27;un coup, et ne jamais parler de « garantie » quand on écrit une instruction.&lt;&#x2F;p&gt;
&lt;p&gt;Autrement dit, on retrouve ce qu&#x27;on disait de la documentation humaine : courte, vivante, maintenue.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;ce-qui-compte-doit-etre-verifiable-par-une-machine&quot;&gt;Ce qui compte doit être vérifiable par une machine&lt;&#x2F;h2&gt;
&lt;p&gt;Une règle qui doit toujours être respectée ne devrait pas vivre uniquement dans un fichier Markdown. « Le module &lt;code&gt;billing&lt;&#x2F;code&gt; ne dépend jamais de &lt;code&gt;web&lt;&#x2F;code&gt; » peut s&#x27;écrire dans les instructions, ou faire échouer la CI. Seule la deuxième solution est fiable, pour les agents comme pour les humains pressés un vendredi soir.&lt;&#x2F;p&gt;
&lt;p&gt;L&#x27;idée est ancienne en clean architecture : les règles d&#x27;architecture s&#x27;automatisent. Les agents nous obligent simplement à le faire.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;les-tests-d-abord-mais-sans-ceremonie&quot;&gt;Les tests d&#x27;abord, mais sans cérémonie&lt;&#x2F;h2&gt;
&lt;p&gt;Le TDD&#x2F;BDD fait partie de mon hygiène de développement depuis longtemps. Avec un agent, je n&#x27;y ai pas renoncé, mais j&#x27;ai changé le rythme : beaucoup moins de petits cycles RED&#x2F;GREEN&#x2F;REFACTOR, des cycles plus larges et plus directs. Je continue pourtant à faire écrire les tests en premier, pour trois raisons :&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;c&#x27;est une &lt;strong&gt;reformulation du problème&lt;&#x2F;strong&gt; : le test dit autrement ce que le prompt demandait, et les écarts de compréhension apparaissent tôt ;&lt;&#x2F;li&gt;
&lt;li&gt;cela &lt;strong&gt;évite les trous de couverture&lt;&#x2F;strong&gt; : on n&#x27;écrit pas les tests après coup en fonction de ce que le code fait déjà ;&lt;&#x2F;li&gt;
&lt;li&gt;cela donne à l&#x27;agent un moyen de &lt;strong&gt;vérifier lui-même&lt;&#x2F;strong&gt; son code.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;p&gt;Les avis divergent. Willison recommande le &lt;em&gt;&lt;a href=&quot;https:&#x2F;&#x2F;simonwillison.net&#x2F;guides&#x2F;agentic-engineering-patterns&#x2F;red-green-tdd&#x2F;&quot;&gt;red&#x2F;green TDD&lt;&#x2F;a&gt;&lt;&#x2F;em&gt; : écrire le test, le voir échouer, puis implémenter. Böckeler, à l&#x27;inverse, a &lt;a href=&quot;https:&#x2F;&#x2F;martinfowler.com&#x2F;articles&#x2F;exploring-gen-ai&#x2F;tdd-in-the-agent-loop.html&quot;&gt;mesuré l&#x27;effet&lt;&#x2F;a&gt; sur des tâches simples : pas de différence nette avec ou sans TDD, des solutions sans TDD plutôt mieux classées, et au moins trois fois plus de tokens. Elle a arrêté de demander le test-first à ses agents.&lt;&#x2F;p&gt;
&lt;p&gt;Son raisonnement se tient : le red&#x2F;green ne prouve rien quand c&#x27;est l&#x27;agent qui écrit le test et constate l&#x27;échec, puisque personne ne vérifie que l&#x27;échec a lieu pour la bonne raison. Et une bonne partie des bénéfices du TDD (gérer la peur, avancer à petits pas, subir la friction de la conception) est propre à l&#x27;humain. Son expérience reste réduite (des tâches Python greenfield, une qualité jugée par un modèle), et elle n&#x27;a pas testé le cas où l&#x27;humain écrit lui-même les scénarios. Je n&#x27;y vois donc pas la preuve que j&#x27;ai tort, mais de quoi préciser ce que je garde : pas la cérémonie, ses fonctions.&lt;&#x2F;p&gt;
&lt;p&gt;Sa conclusion rejoint d&#x27;ailleurs mon expérience : mieux vaut surveiller les résultats que dicter la méthode. Elle propose les tests de mutation, qui montrent si un test détecterait réellement une régression, plutôt que d&#x27;imposer un rituel en espérant.&lt;&#x2F;p&gt;
&lt;p&gt;C&#x27;est aussi pourquoi je relis les tests avant le code. Ils sont la partie du diff qui dit ce que le système est censé faire.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;le-vrai-sujet-la-dette-cognitive&quot;&gt;Le vrai sujet : la dette cognitive&lt;&#x2F;h2&gt;
&lt;p&gt;C&#x27;est la partie la plus discutée par les praticiens, et la moins visible dans les guides.&lt;&#x2F;p&gt;
&lt;p&gt;Willison le résume ainsi : &lt;a href=&quot;https:&#x2F;&#x2F;simonwillison.net&#x2F;2026&#x2F;Feb&#x2F;23&#x2F;agentic-engineering-patterns&#x2F;&quot;&gt;écrire du code ne coûte presque plus rien&lt;&#x2F;a&gt;, ce qui bouleverse nos intuitions. Mais la compréhension, elle, n&#x27;est pas devenue gratuite. Un fil &lt;a href=&quot;https:&#x2F;&#x2F;news.ycombinator.com&#x2F;item?id=47196582&quot;&gt;Hacker News&lt;&#x2F;a&gt; décrit des équipes qui reçoivent chaque semaine des quantités de code qui marche à peu près, sans pouvoir le relire sérieusement. Une &lt;a href=&quot;https:&#x2F;&#x2F;arxiv.org&#x2F;pdf&#x2F;2607.10856&quot;&gt;étude qualitative récente&lt;&#x2F;a&gt; parle de « dette de compréhension » : les agents produisent des changements plus vite et en lots plus gros que les relecteurs ne peuvent les inspecter.&lt;&#x2F;p&gt;
&lt;p&gt;Tout le monde n&#x27;est pas d&#x27;accord. Pour certains, « dette cognitive » est un mot-valise qui désigne un workflow mal construit (documentation absente, tests manquants, onboarding raté). Pour d&#x27;autres, le vrai problème est la qualité du code généré, donc la dette technique classique.&lt;&#x2F;p&gt;
&lt;p&gt;Mon avis : les deux ont raison, et c&#x27;est la discussion que j&#x27;ai avec mes clients depuis des années. Une dette cognitive est une dette technique que personne n&#x27;a encore identifiée. Les agents ne changent pas sa nature, seulement la vitesse à laquelle elle s&#x27;accumule.&lt;&#x2F;p&gt;
&lt;p&gt;Addy Osmani (qui travaille sur Claude Code chez Anthropic) donne une image qui fait mouche : avec un agent, le relecteur est souvent « le premier humain à voir ce code », car le raisonnement de l&#x27;agent est jeté une fois le diff produit. Sa piste : capturer l&#x27;intention et les alternatives écartées dans un journal de décisions attaché à la PR. Steve Yegge va dans le même sens avec &lt;a href=&quot;https:&#x2F;&#x2F;steve-yegge.medium.com&#x2F;gas-town-from-clown-show-to-v1-0-c239d9a407ec&quot;&gt;Beads&lt;&#x2F;a&gt;, un journal versionné dans Git qui garde le « pourquoi » des changements (un projet qu&#x27;il promeut lui-même, donc à prendre comme une illustration). Les ADR font la même chose depuis longtemps.&lt;&#x2F;p&gt;
&lt;p&gt;Les remèdes restent donc classiques : des changements petits et liés à une intention claire, des décisions écrites, une revue centrée sur l&#x27;architecture et le comportement, et une règle simple, ne pas fusionner ce qu&#x27;on ne sait pas expliquer.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;la-revue-devient-le-goulot&quot;&gt;La revue devient le goulot&lt;&#x2F;h2&gt;
&lt;p&gt;Avant, écrire coûtait plus cher que lire. Ce rapport s&#x27;inverse. Osmani rassemble des mesures récentes, avec une réserve qu&#x27;il signale lui-même : elles viennent surtout d&#x27;éditeurs d&#x27;outils. GitClear observe environ quatre fois plus de code produit par les utilisateurs quotidiens d&#x27;IA, pour un gain réel d&#x27;environ 12 %. Faros, sur 22 000 développeurs, relève 31 % de PR fusionnées sans aucune revue en plus. Personne n&#x27;a décidé d&#x27;arrêter de relire : le volume a décidé à notre place.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;agentic-goulot-revue.svg&quot; alt=&quot;Beaucoup de changements produits par les agents se heurtent à une capacité de revue humaine inchangée : peu en sortent relus et compris.&quot;&gt;
  &lt;figcaption&gt;Le volume a changé de côté, la capacité de relecture pas.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;p&gt;Ses recommandations ressemblent à du bon sens d&#x27;ingénieur :&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Trier par risque&lt;&#x2F;strong&gt; : un changement de configuration mérite un linter, un chemin de paiement mérite le grand jeu.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Garder les PR petites&lt;&#x2F;strong&gt;, car un diff énorme est refusé ou approuvé sans lecture.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Lire les tests modifiés d&#x27;abord&lt;&#x2F;strong&gt; : un agent peut « réparer » un test en réécrivant l&#x27;assertion pour coller au comportement cassé.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Mettre l&#x27;humain « sur la boucle »&lt;&#x2F;strong&gt; plutôt que « dans la boucle » : échantillonner et auditer, pas lire chaque ligne.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;p&gt;La revue par IA est utile pour dégrossir, mais elle ne remplace pas la compréhension. Quand un modèle relit le code d&#x27;un autre modèle, ils ont tendance à se tromper de la même façon : ce que l&#x27;un ne voit pas, l&#x27;autre ne le voit pas non plus. Son « looks good » est sans doute sincère, il ne vaut pas celui d&#x27;un humain qui a compris.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;tout-doit-pouvoir-se-defaire&quot;&gt;Tout doit pouvoir se défaire&lt;&#x2F;h2&gt;
&lt;p&gt;Pour savoir quelle autonomie laisser à un agent, je me pose une seule question : que se passe-t-il si c&#x27;est faux ? Si la réponse est « je jette la branche », il peut travailler sans surveillance. Si c&#x27;est « une migration est partie en production », certainement pas. La branche dédiée est le minimum, et &lt;code&gt;git worktree&lt;&#x2F;code&gt; va plus loin : chaque agent reçoit son propre répertoire de travail, une paillasse jetable sans risque pour le reste.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;agentic-autonomie.svg&quot; alt=&quot;De gauche à droite, du réversible à l&#x27;irréversible : worktree jetable, branche relue, merge sur main, migration en production. L&#x27;autonomie laissée à l&#x27;agent diminue au fil de l&#x27;échelle.&quot;&gt;
  &lt;figcaption&gt;Plus c&#x27;est difficile à défaire, moins on laisse d&#x27;autonomie.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;p&gt;C&#x27;est ce qui rend le parallélisme possible, mais il a sa limite. Un praticien qui fait tourner trois à cinq agents depuis des mois conclut que la décomposition des tâches compte plus que leur nombre. Des consignes vagues donnent autant d&#x27;interprétations que d&#x27;agents, et deux agents dans le même répertoire finissent par s&#x27;écraser. Le multi-agent sert à paralléliser des problèmes indépendants, pas à remplacer une conception qu&#x27;on n&#x27;a pas faite.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;securite-des-tests-verts-ne-suffisent-pas&quot;&gt;Sécurité : des tests verts ne suffisent pas&lt;&#x2F;h2&gt;
&lt;p&gt;Des chercheurs ont montré que des agents peuvent produire des &lt;a href=&quot;https:&#x2F;&#x2F;research.google&#x2F;pubs&#x2F;when-correct-is-not-safe-can-we-trust-functionally-correct-patches-generated-by-code-agents-2&#x2F;&quot;&gt;patchs qui passent tous les tests tout en contenant une faille&lt;&#x2F;a&gt;, que la faille ait été glissée volontairement par un attaquant ou introduite sans le vouloir. L&#x27;étude porte sur des scénarios précis, mais le principe est général : les tests ne prouvent que ce qu&#x27;ils couvrent.&lt;&#x2F;p&gt;
&lt;p&gt;Willison propose un cadre utile, la &lt;em&gt;lethal trifecta&lt;&#x2F;em&gt;. Un agent qui a accès à des données privées, qui lit du contenu non fiable et qui peut communiquer vers l&#x27;extérieur peut être manipulé par injection de prompt pour exfiltrer ces données. Dès que les trois sont réunis, le risque est structurel. La réponse est celle de tout système sensible : &lt;em&gt;sandbox&lt;&#x2F;em&gt;, permissions minimales, secrets isolés, réseau restreint, journalisation. Et l&#x27;autonomie reste proportionnelle au risque : refactorer une fonction pure ne demande pas les mêmes garde-fous que toucher à l&#x27;authentification.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;agentic-trifecta.svg&quot; alt=&quot;Trois cercles qui se recoupent : données privées, contenu non fiable, communication vers l&#x27;extérieur. Là où ils se rejoignent, une injection de prompt peut exfiltrer les données.&quot;&gt;
  &lt;figcaption&gt;La lethal trifecta : le risque apparaît quand les trois se rejoignent.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;h2 id=&quot;ce-que-ca-dit-de-notre-metier&quot;&gt;Ce que ça dit de notre métier&lt;&#x2F;h2&gt;
&lt;p&gt;Avec les agents, les bonnes pratiques sont restées les mêmes. Ce qui a disparu, c&#x27;est la possibilité de s&#x27;en passer. Une équipe sans tests fiables, sans architecture explicite et sans discipline de revue pouvait survivre avec des humains qui compensent avec leurs petites mains. Avec des agents capables de produire dix fois plus de code, elle accumule dix fois plus vite sa dette.&lt;&#x2F;p&gt;
&lt;p&gt;La bonne question n&#x27;est plus « quel est mon meilleur prompt ? » mais « quel environnement ai-je construit pour que mon agent, et mes collègues, puissent réussir ? ».
Ça ressemble beaucoup plus à de l&#x27;ingénierie qu&#x27;à de la magie.&lt;&#x2F;p&gt;
&lt;p&gt;Boileau le disait déjà, et j&#x27;en parlais dans &lt;a href=&quot;&#x2F;j-ai-une-dette-technique-et-c-est-mon-choix&#x2F;&quot;&gt;J&#x27;ai une dette technique et c&#x27;est mon choix&lt;&#x2F;a&gt; :&lt;&#x2F;p&gt;
&lt;blockquote&gt;
&lt;p&gt;Hâtez-vous lentement, et sans perdre courage,
Vingt fois sur le métier remettez votre ouvrage
— Boileau, &lt;em&gt;L&#x27;Art poétique&lt;&#x2F;em&gt;&lt;&#x2F;p&gt;
&lt;&#x2F;blockquote&gt;
&lt;p&gt;Avec des agents qui vont dix fois plus vite, c&#x27;est devenu un conseil d&#x27;ingénieur.&lt;&#x2F;p&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;&lt;em&gt;Sources : &lt;a href=&quot;https:&#x2F;&#x2F;simonwillison.net&#x2F;guides&#x2F;agentic-engineering-patterns&#x2F;&quot;&gt;Simon Willison, Agentic Engineering Patterns&lt;&#x2F;a&gt; · Birgitta Böckeler, &lt;a href=&quot;https:&#x2F;&#x2F;martinfowler.com&#x2F;articles&#x2F;exploring-gen-ai&#x2F;tdd-in-the-agent-loop.html&quot;&gt;TDD inside the agent loop&lt;&#x2F;a&gt; et &lt;a href=&quot;https:&#x2F;&#x2F;martinfowler.com&#x2F;articles&#x2F;exploring-gen-ai&#x2F;context-engineering-coding-agents.html&quot;&gt;Context Engineering for Coding Agents&lt;&#x2F;a&gt; · Addy Osmani, &lt;a href=&quot;https:&#x2F;&#x2F;addyosmani.com&#x2F;blog&#x2F;agentic-code-review&#x2F;&quot;&gt;Agentic Code Review&lt;&#x2F;a&gt; · Google Research, &lt;a href=&quot;https:&#x2F;&#x2F;research.google&#x2F;pubs&#x2F;from-black-box-to-toolbox-human-centered-explainability-in-developer-authored-agent-rules&#x2F;&quot;&gt;règles d&#x27;agents&lt;&#x2F;a&gt; et &lt;a href=&quot;https:&#x2F;&#x2F;research.google&#x2F;pubs&#x2F;when-correct-is-not-safe-can-we-trust-functionally-correct-patches-generated-by-code-agents-2&#x2F;&quot;&gt;patchs corrects mais vulnérables&lt;&#x2F;a&gt;&lt;&#x2F;em&gt;&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="fr">
        <title>La dette de documentation : le passif caché qui plombe vos projets</title>
        <published>2026-09-28T00:00:00+00:00</published>
        <updated>2026-09-28T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://meta-lambda.com/la-dette-de-documentation/"/>
        <id>https://meta-lambda.com/la-dette-de-documentation/</id>
        
        <content type="html" xml:base="https://meta-lambda.com/la-dette-de-documentation/">&lt;p&gt;Il y a une dette dont on parle beaucoup en 2026 : la dette technique. Refactoring repoussé, tests manquants, architecture qui grince. Mais il existe une dette cousine, tout aussi coûteuse et bien moins visible sur un dashboard de qualité de code : la &lt;strong&gt;dette de documentation&lt;&#x2F;strong&gt;, fonctionnelle autant que technique.&lt;&#x2F;p&gt;
&lt;p&gt;J&#x27;ai vu ce cas de figure se répéter, sous des formes différentes mais avec la même mécanique de fond.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;comment-on-en-arrive-la&quot;&gt;Comment on en arrive là&lt;&#x2F;h2&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;em&gt;« Shipping first time code is like going into debt »&lt;&#x2F;em&gt; — Ward Cunningham, qui a inventé le terme « dette technique » en 1992, posait déjà le problème : livrer du code non mûri, c&#x27;est emprunter. Reste à savoir qui paiera les intérêts, et avec quoi.&lt;&#x2F;p&gt;
&lt;&#x2F;blockquote&gt;
&lt;p&gt;&lt;strong&gt;La solution grandit sans cadrage produit formel.&lt;&#x2F;strong&gt; Une PME lance un MVP, une fonctionnalité en entraîne une autre, un client important demande une exception, puis une autre. Le produit avance à la vitesse du besoin, pas à celle de la documentation. Personne n&#x27;a jamais écrit noir sur blanc &lt;em&gt;pourquoi&lt;&#x2F;em&gt; telle règle métier existe — elle vit uniquement dans la mémoire de ceux qui l&#x27;ont codée, ou pire, uniquement dans le code lui-même, sous forme de &lt;code&gt;if&lt;&#x2F;code&gt; imbriqués sans commentaire.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;Les sachants quittent l&#x27;entreprise.&lt;&#x2F;strong&gt; Et avec eux part la doc fonctionnelle &lt;em&gt;et&lt;&#x2F;em&gt; technique qui n&#x27;a jamais existé ailleurs que dans leur tête. Ce n&#x27;est pas une négligence isolée : c&#x27;est souvent la conséquence directe du premier point. Quand il n&#x27;y a jamais eu de cadrage formel, il n&#x27;y a rien à transmettre au départ d&#x27;un sachant — sinon un debrief de dernière minute, forcément incomplet.&lt;&#x2F;p&gt;
&lt;p&gt;Ce phénomène n&#x27;a rien d&#x27;anecdotique. Selon l&#x27;enquête 2022 de Stack Overflow menée auprès de plus de 70 000 développeurs, 68 % des développeurs tombent au moins une fois par semaine sur une information dont ils ont besoin... mais qui n&#x27;existe nulle part, sauf dans la tête de quelqu&#x27;un d&#x27;autre. Un chiffre qui grimpe à 73 % chez les managers techniques — souvent les plus expérimentés, donc les plus proches du départ.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;dette-doc-silo.svg&quot; alt=&quot;68 % des développeurs et 73 % des managers techniques tombent au moins une fois par semaine sur une information dont ils ont besoin mais qui n&#x27;existe nulle part, sauf dans la tête de quelqu&#x27;un d&#x27;autre.&quot;&gt;
  &lt;figcaption&gt;Une information indispensable, absente de partout sauf d&#x27;une tête.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;h2 id=&quot;les-impacts-au-dela-de-l-inconfort&quot;&gt;Les impacts, au-delà de l&#x27;inconfort&lt;&#x2F;h2&gt;
&lt;p&gt;Le manque de documentation n&#x27;est pas qu&#x27;une gêne pour les nouveaux arrivants. Il a des conséquences concrètes et mesurables :&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Onboarding qui s&#x27;éternise&lt;&#x2F;strong&gt; : un nouveau développeur met des semaines à devenir autonome, en reconstituant par archéologie ce qu&#x27;une doc aurait transmis en heures.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Régressions fonctionnelles&lt;&#x2F;strong&gt; : sans trace des règles métier, on réintroduit des bugs déjà corrigés, ou on casse un comportement qui avait une raison d&#x27;être oubliée depuis longtemps.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Décisions produit à l&#x27;aveugle&lt;&#x2F;strong&gt; : impossible de savoir si une fonctionnalité existe déjà, sous quelle forme, ni pourquoi elle a été conçue ainsi.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Dépendance critique à quelques individus&lt;&#x2F;strong&gt; : le bus factor devient un risque business réel, pas juste une private joke d&#x27;ingénieur.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Un coût qui s&#x27;accumule avec le temps&lt;&#x2F;strong&gt; : chaque fonctionnalité ajoutée sans être documentée alourdit un peu plus la dette suivante — comme des intérêts qui s&#x27;empilent sur un capital jamais remboursé.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;p&gt;Le temps perdu se chiffre facilement. Toujours selon la même enquête, 62 % des développeurs passent plus de 30 minutes par jour à chercher des réponses ou des solutions, et 25 % y consacrent plus d&#x27;une heure — ce qui représente, pour une équipe de 50 développeurs, entre 333 et 651 heures perdues chaque semaine. À l&#x27;échelle macro, le Consortium for Information &amp;amp; Software Quality (CISQ) a estimé, dans son rapport 2022 sur la qualité logicielle aux États-Unis, que la mauvaise qualité logicielle coûtait 2 410 milliards de dollars, dont 1 520 milliards imputables à la seule dette technique. La documentation manquante n&#x27;est évidemment pas l&#x27;unique cause de ce chiffre, mais elle en est un contributeur direct et documenté.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;dette-doc-couts.svg&quot; alt=&quot;62 % des développeurs perdent plus de 30 minutes par jour à chercher des réponses, 25 % plus d&#x27;une heure, soit 333 à 651 heures perdues chaque semaine pour une équipe de 50 développeurs. Sur les 2410 milliards de dollars que coûte la mauvaise qualité logicielle aux États-Unis, 1520 milliards sont imputables à la dette technique.&quot;&gt;
  &lt;figcaption&gt;Le manque de documentation se chiffre, en heures perdues comme en dollars.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;blockquote&gt;
&lt;p&gt;Comme le résume Damian Conway, auteur de &lt;em&gt;Perl Best Practices&lt;&#x2F;em&gt; : &lt;em&gt;« Documentation is a love letter that you write to your future self »&lt;&#x2F;em&gt; — une documentation, c&#x27;est une lettre d&#x27;amour qu&#x27;on s&#x27;écrit à soi-même dans le futur. Faute de l&#x27;avoir écrite, c&#x27;est toute l&#x27;équipe suivante qui en paie l&#x27;absence.&lt;&#x2F;p&gt;
&lt;&#x2F;blockquote&gt;
&lt;h2 id=&quot;meme-a-l-heure-de-l-ia-la-doc-reste-indispensable&quot;&gt;Même à l&#x27;heure de l&#x27;IA, la doc reste indispensable&lt;&#x2F;h2&gt;
&lt;p&gt;On pourrait penser que l&#x27;essor des agents de code change la donne, ou même rend la doc obsolète puisque l&#x27;IA « comprend » le code. C&#x27;est l&#x27;inverse qui se produit.&lt;&#x2F;p&gt;
&lt;p&gt;Un agent de code ou de QA n&#x27;a pas d&#x27;intuition métier. Il ne sait pas &lt;em&gt;pourquoi&lt;&#x2F;em&gt; une règle existe, seulement ce que le code fait littéralement. Une documentation fonctionnelle et technique de qualité, passée en contexte ou indexée en RAG, améliore considérablement l&#x27;efficacité de ces agents : moins d&#x27;hallucinations sur l&#x27;intention métier, des suggestions de code plus pertinentes, une revue de QA capable de distinguer un vrai bug d&#x27;un comportement voulu. La doc n&#x27;a pas perdu de valeur avec l&#x27;IA — elle en a gagné, parce qu&#x27;elle devient la mémoire structurée que l&#x27;agent consulte à chaque tâche.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;retrodoc-reconstruire-la-doc-manquante&quot;&gt;RetroDoc : reconstruire la doc manquante&lt;&#x2F;h2&gt;
&lt;p&gt;J&#x27;interviens régulièrement chez mes clients pour résoudre leurs problèmes de dette technique, mais aussi pour les accompagner dans l&#x27;intégration efficace de l&#x27;IA à leur métier. Et sur le terrain, le constat est sans appel : le manque de documentation ne freine pas seulement leurs équipes, il a un impact direct sur mes propres missions. Chaque heure passée à reconstituer manuellement le contexte fonctionnel d&#x27;une application est une heure en moins pour résoudre le vrai problème.&lt;&#x2F;p&gt;
&lt;p&gt;C&#x27;est ce constat qui m&#x27;a poussé à créer &lt;strong&gt;RetroDoc&lt;&#x2F;strong&gt;, et plus largement une panoplie d&#x27;outils pensés pour ça, en m&#x27;appuyant sur ma longue expérience du développement logiciel et de la dette technique, combinée à mon savoir-faire en intégration d&#x27;IA agentique. RetroDoc s&#x27;appuie sur le code source, l&#x27;historique des tickets et les quelques documents épars encore disponibles pour &lt;strong&gt;reconstruire a posteriori&lt;&#x2F;strong&gt; la documentation fonctionnelle et technique qui n&#x27;a jamais été écrite — ou qui s&#x27;est perdue avec le départ des sachants.&lt;&#x2F;p&gt;
&lt;p&gt;L&#x27;idée n&#x27;est pas de remplacer la discipline de documenter au fil de l&#x27;eau, mais de traiter le passif existant : redonner à une équipe une base de connaissance exploitable, à la fois pour les humains qui rejoignent le projet et pour les agents IA qui vont désormais y travailler à leurs côtés.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;dette-doc-retrodoc.svg&quot; alt=&quot;Code source, historique des tickets et documents épars alimentent RetroDoc, qui reconstruit une base de connaissance exploitable à la fois par les humains et par les agents IA.&quot;&gt;
  &lt;figcaption&gt;RetroDoc reconstruit a posteriori ce qui n&#x27;a jamais été écrit.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;p&gt;Je partagerai l&#x27;avancement de RetroDoc dans un prochain article.&lt;&#x2F;p&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;&lt;em&gt;Sources : &lt;a href=&quot;https:&#x2F;&#x2F;stackoverflow.blog&#x2F;2022&#x2F;06&#x2F;22&#x2F;asked-and-answered-the-results-for-the-2022-developer-survey-are-here&#x2F;&quot;&gt;Stack Overflow Developer Survey 2022&lt;&#x2F;a&gt; · &lt;a href=&quot;https:&#x2F;&#x2F;www.it-cisq.org&#x2F;the-cost-of-poor-quality-software&#x2F;&quot;&gt;CISQ, Cost of Poor Software Quality in the US: A 2022 Report&lt;&#x2F;a&gt;&lt;&#x2F;em&gt;&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="fr">
        <title>Gloire aux Soft Skills !!!</title>
        <published>2026-09-24T00:00:00+00:00</published>
        <updated>2026-09-24T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://meta-lambda.com/gloire-aux-soft-skills/"/>
        <id>https://meta-lambda.com/gloire-aux-soft-skills/</id>
        
        <content type="html" xml:base="https://meta-lambda.com/gloire-aux-soft-skills/">&lt;p&gt;On l&#x27;entend partout en ce moment : le métier de codeur serait en train de mourir. Pour les juniors, c&#x27;est encore plus rude. À quoi bon apprendre à coder quand une IA générative le fait à leur place, souvent mieux, et surtout beaucoup plus vite ?&lt;&#x2F;p&gt;
&lt;p&gt;Résultat, les &lt;em&gt;soft skills&lt;&#x2F;em&gt; ont le vent en poupe. Communication, collaboration, empathie… On les retrouve martelées dans chaque offre d&#x27;emploi et chaque conférence. On pourrait croire qu&#x27;elles ont soudainement pris de la valeur. En réalité, c&#x27;est surtout le code qui en a perdu, et on se raccroche à ce qui reste.&lt;&#x2F;p&gt;
&lt;p&gt;Gloire aux &lt;em&gt;soft skills&lt;&#x2F;em&gt;, donc ! Ou presque.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;le-code-devient-jetable&quot;&gt;Le code devient jetable&lt;&#x2F;h2&gt;
&lt;p&gt;L&#x27;IA générative a changé la donne assez brutalement : écrire du code n&#x27;est plus un acte rare, ni particulièrement précieux.
Une IA en recrache à la chaîne, avec un niveau tout à fait honorable, sur des tâches qui exigeaient un vrai savoir-faire il y a encore deux ou trois ans.&lt;&#x2F;p&gt;
&lt;p&gt;Ajoutez à ça un marché du travail qui se tend (les développeurs le sentent bien sur le terrain), et les candidats cherchent logiquement à se différencier ailleurs. Puisque le code ne suffit plus à faire la différence, on se rabat sur ce que l&#x27;IA ne sait pas encore bien faire : les &lt;em&gt;soft skills&lt;&#x2F;em&gt;.&lt;&#x2F;p&gt;
&lt;p&gt;Plus qu&#x27;une montée en puissance des &lt;em&gt;soft skills&lt;&#x2F;em&gt;, c&#x27;est un repli stratégique face à la dévaluation du code brut.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;soft-skills-devaluation.svg&quot; alt=&quot;Avant l&#x27;IA générative, le code vaut bien plus que les soft skills. Aujourd&#x27;hui, la valeur du code s&#x27;est effondrée, celle des soft skills n&#x27;a pas bougé.&quot;&gt;
  &lt;figcaption&gt;Les soft skills n&#x27;ont pas pris de valeur : c&#x27;est le code qui en a perdu.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;h2 id=&quot;ce-que-ce-glissement-libere&quot;&gt;Ce que ce glissement libère&lt;&#x2F;h2&gt;
&lt;p&gt;Vu comme ça, l&#x27;histoire est un peu triste : celle d&#x27;un métier qui perd son cœur technique. Je crois au contraire que c&#x27;est une bonne nouvelle !&lt;&#x2F;p&gt;
&lt;p&gt;Réduire un développeur à la production de code a toujours été une vision étriquée du métier.
L&#x27;IA générative nous donne l&#x27;occasion de sortir de ce rôle d&#x27;exécutant pour devenir un vrai contributeur à l&#x27;avancée du produit. Un meilleur architecte, un meilleur communicant, quelqu&#x27;un qui pense système plutôt que syntaxe.&lt;&#x2F;p&gt;
&lt;p&gt;Rien de bien neuf d&#x27;ailleurs, le MIT l&#x27;enseignait déjà en 1985 :&lt;&#x2F;p&gt;
&lt;blockquote&gt;
&lt;p&gt;We believe that the essential material to be addressed by a subject at this level is not the syntax of particular programming-language constructs, nor clever algorithms for computing particular functions efficiently, nor even the mathematical analysis of algorithms and the foundations of computing, but rather the techniques used to control the intellectual complexity of large software systems.
— H. Abelson &amp;amp; G. J. Sussman, &lt;a href=&quot;https:&#x2F;&#x2F;mitp-content-server.mit.edu&#x2F;books&#x2F;content&#x2F;sectbyfn&#x2F;books_pres_0&#x2F;6515&#x2F;sicp.zip&#x2F;full-text&#x2F;book&#x2F;book-Z-H-7.html&quot;&gt;préface de &lt;em&gt;Structure and Interpretation of Computer Programs&lt;&#x2F;em&gt;&lt;&#x2F;a&gt;&lt;&#x2F;p&gt;
&lt;&#x2F;blockquote&gt;
&lt;p&gt;Il y a même une dimension managériale qui émerge, et qui me semble sous-estimée.
Orchestrer plusieurs agents IA pour atteindre un résultat, identifier les points forts de chacun, cadrer leur travail, vérifier le rendu… Ça ressemble à s&#x27;y méprendre au quotidien d&#x27;un manager d&#x27;équipe. (La machine à café et les entretiens annuels en moins.)&lt;&#x2F;p&gt;
&lt;p&gt;On ne code plus seul dans son coin : on délègue, on arbitre, on supervise.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;soft-skills-orchestration.svg&quot; alt=&quot;Le développeur au centre, relié à quatre agents IA qu&#x27;il cadre, à qui il délègue, entre lesquels il arbitre et dont il vérifie le rendu.&quot;&gt;
  &lt;figcaption&gt;Orchestrer des agents, c&#x27;est déjà un peu manager une équipe.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;h2 id=&quot;la-fin-d-une-aberration-du-recrutement&quot;&gt;La fin d&#x27;une aberration du recrutement&lt;&#x2F;h2&gt;
&lt;p&gt;Autre effet de bord, plus concret celui-ci : on pourrait enfin en finir avec une absurdité qui traîne dans notre métier depuis toujours. Les intitulés de poste hyper-spécifiques ! « Développeur langage X, framework Y, version Z », qui enferment les profils dans une case technique précise… et périssable.&lt;&#x2F;p&gt;
&lt;p&gt;Si la valeur d&#x27;un développeur se déplace vers l&#x27;architecture, la communication et l&#x27;orchestration, ces intitulés n&#x27;ont plus grand sens.
On devrait voir émerger des profils bien plus transverses, capables de passer d&#x27;une &lt;em&gt;stack&lt;&#x2F;em&gt; à l&#x27;autre sans en faire un drame. Parce que ce qui compte, ce n&#x27;est plus la maîtrise pointue d&#x27;une syntaxe, mais un savoir-faire de fond, transposable.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;soft-skills-profils.svg&quot; alt=&quot;Hier, un développeur enfermé dans des cases emboîtées : langage X, framework Y, version Z. Demain, un profil en T capable de passer d&#x27;une stack à l&#x27;autre.&quot;&gt;
  &lt;figcaption&gt;De la case technique au profil transverse.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;h2 id=&quot;et-la-releve-dans-tout-ca&quot;&gt;Et la relève, dans tout ça ?&lt;&#x2F;h2&gt;
&lt;p&gt;Reste une question qui me tient particulièrement à cœur : qu&#x27;est-ce que tout ça signifie pour la formation des jeunes développeurs ?&lt;&#x2F;p&gt;
&lt;p&gt;Si le code perd sa place centrale, former quelqu&#x27;un uniquement à coder devient une impasse. Montaigne, lui, avait déjà tranché :&lt;&#x2F;p&gt;
&lt;blockquote&gt;
&lt;p&gt;Je voudrois aussi qu&#x27;on fut soigneux de luy choisir un conducteur qui eust plustost la teste bien faicte que bien pleine, et qu&#x27;on y requit tous les deux, mais plus les meurs et l&#x27;entendement que la science.
— Montaigne, &lt;a href=&quot;https:&#x2F;&#x2F;fr.wikisource.org&#x2F;wiki&#x2F;Essais&#x2F;Livre_I&#x2F;Chapitre_26&quot;&gt;&lt;em&gt;Essais&lt;&#x2F;em&gt;, I, 26&lt;&#x2F;a&gt;&lt;&#x2F;p&gt;
&lt;&#x2F;blockquote&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;soft-skills-tetes.svg&quot; alt=&quot;À gauche, une tête encombrée de fragments de syntaxe en vrac. À droite, une tête qui contient un arbre de concepts reliés entre eux.&quot;&gt;
  &lt;figcaption&gt;Une tête bien pleine… ou bien faite.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;p&gt;Il faudra sans doute repenser en profondeur ce qu&#x27;on transmet, et dans quel ordre. Des têtes bien faites, plutôt que bien pleines de syntaxe !&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="fr">
        <title>La dette technique n&#x27;est que la partie émergée</title>
        <published>2026-09-21T00:00:00+00:00</published>
        <updated>2026-09-21T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://meta-lambda.com/dette-technique-et-le-reste/"/>
        <id>https://meta-lambda.com/dette-technique-et-le-reste/</id>
        
        <content type="html" xml:base="https://meta-lambda.com/dette-technique-et-le-reste/">&lt;p&gt;Quand on me mandate en tant que freelance, la demande initiale ressemble presque toujours à la même chose : « l&#x27;équipe n&#x27;arrive pas à produire assez vite, il faut accélérer ». C&#x27;est un cadrage confortable : il pointe vers un problème technique, donc vers une solution technique. Sauf que dans la plupart des missions, ce que je découvre en creusant n&#x27;a que partiellement à voir avec le code.&lt;&#x2F;p&gt;
&lt;p&gt;La dette technique existe, bien sûr. Mais elle n&#x27;est souvent que la partie visible d&#x27;un ensemble plus large : dette organisationnelle, dette de documentation, dette de compétences. Et tant qu&#x27;on ne traite que la première, on ne fait parfois que déplacer le problème, ou pire, l&#x27;aggraver.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;dette-iceberg.svg&quot; alt=&quot;La dette technique, partie émergée d&#x27;un iceberg : dessous se trouvent les dettes organisationnelle, de documentation et de compétences.&quot;&gt;
  &lt;figcaption&gt;La dette technique n&#x27;est que la partie visible du problème.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;p&gt;Je voudrais raconter ici une mission qui illustre bien ce mécanisme, parce qu&#x27;elle m&#x27;a appris quelque chose que je n&#x27;avais pas anticipé : améliorer le code peut, dans certaines conditions, empirer la situation globale d&#x27;une équipe.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;un-goulot-d-etranglement-humain&quot;&gt;Un goulot d&#x27;étranglement humain&lt;&#x2F;h2&gt;
&lt;p&gt;Dès mes premiers entretiens avec les développeurs, quelques heures après mon arrivée, un &lt;em&gt;pattern&lt;&#x2F;em&gt; est apparu clairement : une seule personne assurait toute la QA de l&#x27;application. Toute. Chaque fonctionnalité, chaque correctif, chaque évolution passait par elle avant de pouvoir être livré.&lt;&#x2F;p&gt;
&lt;p&gt;Ce n&#x27;était pas qu&#x27;un problème de capacité. En discutant avec elle, j&#x27;ai perçu une vraie fatigue, un débit de parole élevé, des hésitations, une personne qui se perdait dans ses explications. Je lui ai dit, assez directement, qu&#x27;elle devait se ménager, parce qu&#x27;à ce rythme elle n&#x27;allait pas tenir. C&#x27;est exactement ce qui s&#x27;est passé peu de temps après.&lt;&#x2F;p&gt;
&lt;p&gt;Au-delà de l&#x27;aspect humain, c&#x27;était aussi un risque business direct : cette personne était la seule à connaître l&#x27;application dans son ensemble. Un classique &lt;em&gt;bus factor&lt;&#x2F;em&gt; de un. Si elle s&#x27;arrêtait, ce n&#x27;était pas juste la QA qui s&#x27;arrêtait, c&#x27;était potentiellement l&#x27;activité de l&#x27;entreprise qui se retrouvait menacée.&lt;&#x2F;p&gt;
&lt;p&gt;J&#x27;ai identifié deux priorités immédiates : mettre en place des suites de tests &lt;em&gt;end-to-end&lt;&#x2F;em&gt; pour sécuriser les &lt;em&gt;workflows&lt;&#x2F;em&gt; complexes de l&#x27;application, et lui trouver un binôme pour répartir la connaissance métier. La première action a bien avancé pendant ma mission, même si le périmètre de l&#x27;application était large et que le travail se poursuit encore aujourd&#x27;hui par l&#x27;équipe. La seconde s&#x27;est heurtée à un mur : l&#x27;absence totale de documentation du comportement attendu de l&#x27;application. Sans elle, impossible de former qui que ce soit, développeur comme QA.&lt;&#x2F;p&gt;
&lt;p&gt;Et malgré mon insistance, le binômage n&#x27;a jamais eu lieu pendant ma mission. Je pense que l&#x27;impact réel de cette situation n&#x27;a pas été pleinement mesuré côté client.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;les-effets-en-cascade&quot;&gt;Les effets en cascade&lt;&#x2F;h2&gt;
&lt;p&gt;Ce goulot d&#x27;étranglement ne se contentait pas de ralentir les livraisons, il générait des effets secondaires qui, eux, ressemblaient à s&#x27;y méprendre à de la dette technique classique.&lt;&#x2F;p&gt;
&lt;p&gt;Une fonctionnalité prête attendait parfois longtemps avant d&#x27;être prise en charge par la QA. Pendant ce temps, sa branche vieillissait, et chaque développeur devait la rebaser régulièrement sur &lt;code&gt;master&lt;&#x2F;code&gt; pour ne pas perdre le fil. C&#x27;est un travail invisible, répétitif, qui ne produit aucune valeur, mais qui devient nécessaire uniquement parce que la file d&#x27;attente en aval n&#x27;avance pas. Une dette organisationnelle qui se transforme en charge technique.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;dette-cascade.svg&quot; alt=&quot;Enchaînement : QA saturée, branches qui vieillissent, allers-retours, deadlines qui dérapent, livraisons inabouties, moral de l&#x27;équipe.&quot;&gt;
  &lt;figcaption&gt;Un goulot d&#x27;étranglement unique, et ses effets en chaîne.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;p&gt;Les allers-retours entre développement et QA prenaient eux aussi énormément de temps, ce qui faisait mécaniquement déraper les &lt;em&gt;deadlines&lt;&#x2F;em&gt;. Et en bout de chaîne, la pression du calendrier poussait parfois à livrer des choses qui n&#x27;étaient pas techniquement abouties. Un comble, pour un &lt;em&gt;process&lt;&#x2F;em&gt; censé garantir la qualité.&lt;&#x2F;p&gt;
&lt;p&gt;Cette pression ne restait pas cantonnée à la QA. Elle se diffusait à toute l&#x27;équipe de développement, qui sentait bien que le rythme des livraisons ne suivait pas, sans toujours pouvoir agir dessus. Ce genre de tension continue, même quand elle reste discrète au quotidien, finit par peser sur le moral collectif : le sentiment de courir après un retard qu&#x27;on ne rattrape jamais est usant, bien au-delà de la seule personne en première ligne.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;le-paradoxe-de-l-optimisation-locale&quot;&gt;Le paradoxe de l&#x27;optimisation locale&lt;&#x2F;h2&gt;
&lt;p&gt;Comment un chantier technique qui a parfaitement fonctionné a-t-il pu, au final, aggraver la situation ? C&#x27;est le point que je trouve le plus intéressant, et le plus contre-intuitif, de cette mission.&lt;&#x2F;p&gt;
&lt;p&gt;J&#x27;ai mis en place de la CI&#x2F;CD et des suites de tests automatisés, avec un objectif précis : détecter les défauts en amont, avant qu&#x27;ils n&#x27;atteignent la QA, pour la décharger des livraisons de mauvaise qualité. Sur ce plan-là, ça a très bien fonctionné. Ce n&#x27;est pas la partie technique qui a échoué.&lt;&#x2F;p&gt;
&lt;p&gt;Le problème est venu d&#x27;ailleurs. En fluidifiant le &lt;em&gt;pipeline&lt;&#x2F;em&gt; de développement, ces améliorations ont aussi accéléré le rythme de production. Nous avons ensuite accompagné les développeurs sur l&#x27;usage de l&#x27;IA pour les aider dans leurs tâches. Mais l&#x27;effet net n&#x27;a pas été &lt;em&gt;du meilleur code&lt;&#x2F;em&gt;, il a été &lt;em&gt;plus de code&lt;&#x2F;em&gt;. Plus de fonctionnalités livrées, plus vite, avec une qualité de base qui ne s&#x27;améliorait pas vraiment.&lt;&#x2F;p&gt;
&lt;p&gt;Résultat : encore plus de volume à faire passer par le même goulot d&#x27;étranglement humain, désormais sous une pression accrue. Chaque optimisation locale que j&#x27;apportais au système ne faisait que déplacer la contrainte, et parfois l&#x27;intensifier, plutôt que de résoudre le vrai problème.&lt;&#x2F;p&gt;
&lt;figure&gt;
  &lt;img src=&quot;&#x2F;assets&#x2F;img&#x2F;dette-optimisation-locale.svg&quot; alt=&quot;Avant et après CI&#x2F;CD et IA : la production augmente, la QA garde la même capacité et la file d&#x27;attente grossit.&quot;&gt;
  &lt;figcaption&gt;Accélérer en amont du goulot ne fait qu&#x27;allonger la file d&#x27;attente.&lt;&#x2F;figcaption&gt;
&lt;&#x2F;figure&gt;
&lt;p&gt;Bref, c&#x27;est une illustration assez nette d&#x27;un principe qu&#x27;on retrouve dans la théorie des contraintes : optimiser une étape qui n&#x27;est pas le goulot d&#x27;étranglement du système n&#x27;améliore pas le débit global, ça déplace simplement la pression vers le vrai point de blocage.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;ce-qu-un-freelance-peut-et-ne-peut-pas-resoudre-seul&quot;&gt;Ce qu&#x27;un freelance peut, et ne peut pas, résoudre seul&lt;&#x2F;h2&gt;
&lt;p&gt;Cette mission m&#x27;a laissé une conviction assez claire. La dette technique, un freelance peut la traiter directement : refactoring, tests, CI&#x2F;CD, ce sont des leviers qui dépendent largement de sa propre action. La dette organisationnelle, en revanche, demande une reconnaissance et une volonté qui appartiennent au client. On peut alerter, documenter le risque, proposer des solutions concrètes, mais on ne peut pas décider à la place de l&#x27;entreprise de réorganiser une équipe ou de recruter un binôme.&lt;&#x2F;p&gt;
&lt;p&gt;Ce n&#x27;est pas un constat pessimiste. C&#x27;est plutôt une invitation à élargir le diagnostic dès le départ d&#x27;une mission. Quand on me parle de vitesse de production, je sais d&#x27;expérience qu&#x27;il faut regarder au-delà du code : où est le vrai goulot d&#x27;étranglement, qui porte seul une connaissance critique, quelle documentation manque pour que cette connaissance puisse être transmise.&lt;&#x2F;p&gt;
&lt;p&gt;La dette technique se corrige avec du temps et de la rigueur. La dette organisationnelle, elle, ne se corrige qu&#x27;avec une décision. Et celle-ci n&#x27;appartient jamais au freelance.&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="fr">
        <title>Ports and Adapters at compile-time for Rust</title>
        <published>2023-08-28T15:00:00+00:00</published>
        <updated>2023-08-28T15:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://meta-lambda.com/Ports-and-Adapters-at-compile-time-for-Rust/"/>
        <id>https://meta-lambda.com/Ports-and-Adapters-at-compile-time-for-Rust/</id>
        
        <content type="html" xml:base="https://meta-lambda.com/Ports-and-Adapters-at-compile-time-for-Rust/">&lt;p&gt;Dans &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;Electron-libre&#x2F;Rust-compile-time-port-and-adapter&quot;&gt;ce dépôt&lt;&#x2F;a&gt;, je propose une façon simple et efficace de mettre en œuvre une inversion de dépendances avec Rust.
Plus particulièrement lorsque le besoin est de substituer les dépendances lors de la compilation et d&#x27;éviter le &lt;a href=&quot;https:&#x2F;&#x2F;doc.rust-lang.org&#x2F;reference&#x2F;types&#x2F;trait-object.html&quot;&gt;Dynamic Dispatch&lt;&#x2F;a&gt;.&lt;&#x2F;p&gt;
&lt;p&gt;Très utile pour les tests unitaires et le TDD, mais aussi pour proposer des binaires avec des variantes d&#x27;implémentation.
Par exemple pour livrer un webservice dans 2 versions , une pour Postgres et l&#x27;autre pour SqlLite.&lt;&#x2F;p&gt;
&lt;p&gt;Le code fait appel à la &lt;a href=&quot;https:&#x2F;&#x2F;doc.rust-lang.org&#x2F;reference&#x2F;conditional-compilation.html&quot;&gt;compilation conditionnelle&lt;&#x2F;a&gt;, il est simple et lisible, mais destiné à des développeurs avancés qui ont déjà quelque notions de ces concepts.&lt;&#x2F;p&gt;
&lt;p&gt;J&#x27;insiste cependant sur le fait qu&#x27;il vaut mieux ne pas introduire d&#x27;abstraction tant qu&#x27;elle n&#x27;est pas indispensable, ce serait contre-productif.&lt;&#x2F;p&gt;
&lt;p&gt;Cadeau !!!&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="fr">
        <title>Elixir amqp 1.2 et confirm handler</title>
        <published>2019-05-15T13:25:00+00:00</published>
        <updated>2019-05-15T13:25:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://meta-lambda.com/Elixir-amqp-et-confirm-handler/"/>
        <id>https://meta-lambda.com/Elixir-amqp-et-confirm-handler/</id>
        
        <content type="html" xml:base="https://meta-lambda.com/Elixir-amqp-et-confirm-handler/">&lt;p&gt;RabbitMq permet de recevoir des confirmations de ventilation des messages par l&#x27;&lt;em&gt;exchange&lt;&#x2F;em&gt;.
Le client Elixir, &lt;code&gt;amqp (&amp;gt; 1.2)&lt;&#x2F;code&gt; permet d&#x27;attendre de manière bloquante ces confirmations, mais ne propose pas d&#x27;API pour enregistrer un &lt;em&gt;handler&lt;&#x2F;em&gt;.
Ce qui m&#x27;a donné l&#x27;opportunité de faire cette contribution, qui fait maintenant partie de la version 1.2.&lt;&#x2F;p&gt;
&lt;p&gt;Cet article résume l&#x27;histoire de cette contribution à des fins didactiques.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;le-contexte&quot;&gt;Le contexte&lt;&#x2F;h2&gt;
&lt;p&gt;La fonctionnalité de &lt;a href=&quot;https:&#x2F;&#x2F;www.rabbitmq.com&#x2F;confirms.html#publisher-confirms&quot;&gt;publisher confirm&lt;&#x2F;a&gt; proposée par RabbitMq, permet en sacrifiant un peu de performances, d&#x27;obtenir une confirmation que le message publié à bien été accepté par les queues destinataires.&lt;&#x2F;p&gt;
&lt;p&gt;Imagine que tu publie un message dans le bus AMQP, ce que tu obtiens de manière synchrone lors d&#x27;un &lt;em&gt;publish&lt;&#x2F;em&gt;, c&#x27;est une confirmation que l&#x27;&lt;em&gt;exchange&lt;&#x2F;em&gt; à bien reçu le message.
Cela ne garanti pas que le message est bien ventilé vers les queues enregistrées comme destinataires.&lt;&#x2F;p&gt;
&lt;p&gt;Une option serait d&#x27;utiliser les transactions du protocol &lt;code&gt;AMQP 0-9-1&lt;&#x2F;code&gt;, mais elle ont un énorme impacte sur le débit de messages.&lt;&#x2F;p&gt;
&lt;p&gt;L&#x27;autre option est d&#x27;utiliser une extension du protocole proposée par RabbitMq: &lt;em&gt;publisher confirm&lt;&#x2F;em&gt;.
Cette extension te permet de d&#x27;activer le mode confirmation  pour un &lt;em&gt;channel&lt;&#x2F;em&gt;.&lt;&#x2F;p&gt;
&lt;p&gt;Ce qui a pour effet de reproduire le sémantique de l&#x27;acquittement de message, au niveau de l&#x27;&lt;em&gt;exchange&lt;&#x2F;em&gt;.
Quand celui-ci parvient a router un message, il retourne un message d&#x27;acquittement.&lt;&#x2F;p&gt;
&lt;p&gt;Le paquet Hex &lt;code&gt;amqp &amp;lt; 1.2&lt;&#x2F;code&gt; expose une fonction &lt;code&gt;AMQP.Confirm.select&#x2F;1&lt;&#x2F;code&gt; qui permet de d&#x27;activer les confirmations sur le &lt;em&gt;channel&lt;&#x2F;em&gt;.
Et une suite de fonctions &lt;a href=&quot;https:&#x2F;&#x2F;hexdocs.pm&#x2F;amqp&#x2F;AMQP.Confirm.html#wait_for_confirms&#x2F;2&quot;&gt;&lt;code&gt;wait_for_confirms*(&#x2F;1|&#x2F;2)&lt;&#x2F;code&gt;&lt;&#x2F;a&gt; qui permettent d&#x27;attendre de manière synchrone la confirmation des derniers messages envoyés.&lt;&#x2F;p&gt;
&lt;p&gt;Dans mon système je conserve un état des messages à envoyer, et des messages envoyés avec succès.
Mais je ne souhaite pas bloquer l&#x27;acteur en charge de publier les messages pour valider la confirmation de l&#x27;envoi de ceux-ci. J&#x27;aimerais plutôt exploiter au mieux l&#x27;outillage en déléguant la confirmation de l&#x27;envoi à un autre acteur.&lt;&#x2F;p&gt;
&lt;p&gt;En me documentant sur le fonctionnement du publisher confirm et des recommandations pour RabbitMq, et en lisant le code source d&#x27;autres clients, je me suis rendu compte que plusieurs clients implémentaient un fonction &lt;code&gt;register_confirm_handler&lt;&#x2F;code&gt; et &lt;code&gt;next_publish_seqno&lt;&#x2F;code&gt;.&lt;&#x2F;p&gt;
&lt;p&gt;Ces fonctions permettent respectivement de déclarer un handler pour traiter les confirmations et d&#x27;obtenir l&#x27;identifiant du message publié pour un &lt;em&gt;channel&lt;&#x2F;em&gt;.&lt;&#x2F;p&gt;
&lt;p&gt;C&#x27;est justement ce dont j&#x27;avais besoin.&lt;&#x2F;p&gt;
&lt;p&gt;Le client Elixir s&#x27;appuyant sur le client Erlang, qui lui implémement ces fonctions, il n&#x27;y avait plus qu&#x27;à se pencher pour récolter, permettant de fermer quelque &lt;em&gt;issues&lt;&#x2F;em&gt; au passage.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;le-developpement&quot;&gt;Le développement&lt;&#x2F;h2&gt;
&lt;p&gt;Je vais ré-exposer les fonctions proposée par Erlang, dans la continuité de la &lt;em&gt;codebase&lt;&#x2F;em&gt; actuelle.
Habituellement je consulte donc avec la plus grande précaution les consignes de contribution.
Mais dans le cas présent elles brillaient par leur absence.&lt;&#x2F;p&gt;
&lt;p&gt;Dans ce cas, je m&#x27;imprègne des pratiques des mainteneurs précédents en explorant le code source.&lt;&#x2F;p&gt;
&lt;p&gt;Je trouve que c&#x27;est une étape indispensable, open source, ou pas. Cela contribue à rendre le code homogène et compréhensible.&lt;&#x2F;p&gt;
&lt;p&gt;Ensuite j&#x27;écris un test simple.
Je n&#x27;argumente plus sur la &lt;strong&gt;nécéssité&lt;&#x2F;strong&gt; d&#x27;écrire les tests en premier.&lt;&#x2F;p&gt;
&lt;p&gt;Dans un premier temps le setup.&lt;&#x2F;p&gt;
&lt;p&gt;Il me faut :&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;une &lt;em&gt;connection&lt;&#x2F;em&gt; pour obtenir un &lt;em&gt;channel&lt;&#x2F;em&gt;&lt;&#x2F;li&gt;
&lt;li&gt;un &lt;em&gt;channel&lt;&#x2F;em&gt; pour selectionner le mode confirmation.&lt;&#x2F;li&gt;
&lt;li&gt;un &lt;em&gt;callback&lt;&#x2F;em&gt; pour fermer la &lt;em&gt;connection&lt;&#x2F;em&gt; proprement à la fin du test&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;p&gt;Puisque toute les opérations se font au niveau du &lt;em&gt;channel&lt;&#x2F;em&gt;, je l&#x27;ajoute au contexte qui sera passé en argument du test.&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;elixir&quot; style=&quot;background-color:#282828;color:#fdf4c1aa;&quot; class=&quot;language-elixir &quot;&gt;&lt;code class=&quot;language-elixir&quot; data-lang=&quot;elixir&quot;&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;&#x2F;&#x2F;&lt;&#x2F;span&gt;&lt;span&gt; test&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;&#x2F;&lt;&#x2F;span&gt;&lt;span&gt;confirm.exs
&lt;&#x2F;span&gt;&lt;span&gt;
&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;defmodule &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;ConfirmTest &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;do
&lt;&#x2F;span&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;use &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;ExUnit&lt;&#x2F;span&gt;&lt;span&gt;.&lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Case
&lt;&#x2F;span&gt;&lt;span&gt;
&lt;&#x2F;span&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;alias &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;AMQP&lt;&#x2F;span&gt;&lt;span&gt;.&lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Connection
&lt;&#x2F;span&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;alias &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;AMQP&lt;&#x2F;span&gt;&lt;span&gt;.&lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Channel
&lt;&#x2F;span&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;alias &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;AMQP&lt;&#x2F;span&gt;&lt;span&gt;.&lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Confirm
&lt;&#x2F;span&gt;&lt;span&gt;
&lt;&#x2F;span&gt;&lt;span&gt;  setup &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;do
&lt;&#x2F;span&gt;&lt;span&gt;    {&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:ok&lt;&#x2F;span&gt;&lt;span&gt;, conn} &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;= &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Connection&lt;&#x2F;span&gt;&lt;span&gt;.open
&lt;&#x2F;span&gt;&lt;span&gt;    {&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:ok&lt;&#x2F;span&gt;&lt;span&gt;, chan} &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;= &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Channel&lt;&#x2F;span&gt;&lt;span&gt;.open(conn)
&lt;&#x2F;span&gt;&lt;span&gt;    &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:ok &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;= &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Confirm&lt;&#x2F;span&gt;&lt;span&gt;.select(chan)
&lt;&#x2F;span&gt;&lt;span&gt;    on_exit &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;fn &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;-&amp;gt;
&lt;&#x2F;span&gt;&lt;span&gt;      &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:ok &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;= &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Connection&lt;&#x2F;span&gt;&lt;span&gt;.close(conn)
&lt;&#x2F;span&gt;&lt;span&gt;    &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;end
&lt;&#x2F;span&gt;&lt;span&gt;    {&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:ok&lt;&#x2F;span&gt;&lt;span&gt;, &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;chan:&lt;&#x2F;span&gt;&lt;span&gt; chan}
&lt;&#x2F;span&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;end
&lt;&#x2F;span&gt;&lt;span&gt;  
&lt;&#x2F;span&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;&#x2F;&#x2F; ..&lt;&#x2F;span&gt;&lt;span&gt;.
&lt;&#x2F;span&gt;&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Ensuite le premier test, simple, récupérer le numéro de séquence du message.&lt;&#x2F;p&gt;
&lt;p&gt;En consultant la documentation de RabbitMq et du client Erlang, je comprend que le premier numéro de séquence d&#x27;un channel vide est 1 et que la &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;rabbitmq&#x2F;rabbitmq-erlang-client&#x2F;blob&#x2F;master&#x2F;src&#x2F;amqp_channel.erl#L213&quot;&gt;fonction Erlang&lt;&#x2F;a&gt; attend l&#x27;identifiant du process &lt;em&gt;channel&lt;&#x2F;em&gt; en argument.&lt;&#x2F;p&gt;
&lt;p&gt;Ensuite je décide du nom et module de la fonction, en m&#x27;inspirant des pratiques du code source actuel, qui est de reprendre celui de la fonction Erlang.&lt;&#x2F;p&gt;
&lt;p&gt;Voci le test:&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;elixir&quot; style=&quot;background-color:#282828;color:#fdf4c1aa;&quot; class=&quot;language-elixir &quot;&gt;&lt;code class=&quot;language-elixir&quot; data-lang=&quot;elixir&quot;&gt;&lt;span&gt;  describe &lt;&#x2F;span&gt;&lt;span style=&quot;color:#b8bb26;&quot;&gt;&amp;quot;next_publish_seqno&amp;quot; &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;do
&lt;&#x2F;span&gt;&lt;span&gt;    test &lt;&#x2F;span&gt;&lt;span style=&quot;color:#b8bb26;&quot;&gt;&amp;quot;returns 1 whe no messages where sent&amp;quot;&lt;&#x2F;span&gt;&lt;span&gt;, ctx &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;do
&lt;&#x2F;span&gt;&lt;span&gt;      assert &lt;&#x2F;span&gt;&lt;span style=&quot;color:#d3869b;&quot;&gt;1 &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;== &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Confirm&lt;&#x2F;span&gt;&lt;span&gt;.next_publish_seqno(ctx[&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:chan&lt;&#x2F;span&gt;&lt;span&gt;])
&lt;&#x2F;span&gt;&lt;span&gt;    &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;end
&lt;&#x2F;span&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;end
&lt;&#x2F;span&gt;&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Il ne reste plus qu&#x27;a le lancer pour le regarder échouer, puis écrire le code pour le faire passer.&lt;&#x2F;p&gt;
&lt;p&gt;Dans le module &lt;code&gt;AMQP.Confirm&lt;&#x2F;code&gt;, j&#x27;ajoute une fonction qui:&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;Prend une structure &lt;code&gt;Channel&lt;&#x2F;code&gt; en argument&lt;&#x2F;li&gt;
&lt;li&gt;Appelle la fonction Erlang&lt;&#x2F;li&gt;
&lt;li&gt;Retourne le résultat sous forme d&#x27;entier positif&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;pre data-lang=&quot;elixir&quot; style=&quot;background-color:#282828;color:#fdf4c1aa;&quot; class=&quot;language-elixir &quot;&gt;&lt;code class=&quot;language-elixir&quot; data-lang=&quot;elixir&quot;&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;# lib&#x2F;amqp&#x2F;confirm.ex
&lt;&#x2F;span&gt;&lt;span&gt;
&lt;&#x2F;span&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;@doc &amp;quot;&amp;quot;&amp;quot;
&lt;&#x2F;span&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;  On channel with confirm activated, return the next message sequence number.
&lt;&#x2F;span&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;  To use in combination with `register_handler&#x2F;2`
&lt;&#x2F;span&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;  &amp;quot;&amp;quot;&amp;quot;
&lt;&#x2F;span&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;@&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;spec&lt;&#x2F;span&gt;&lt;span&gt; next_publish_seqno(&lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Channel&lt;&#x2F;span&gt;&lt;span&gt;.t) :: non_neg_integer
&lt;&#x2F;span&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;def &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;next_publish_seqno&lt;&#x2F;span&gt;&lt;span&gt;(%&lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Channel&lt;&#x2F;span&gt;&lt;span&gt;{&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;pid:&lt;&#x2F;span&gt;&lt;span&gt; pid}) &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;do
&lt;&#x2F;span&gt;&lt;span&gt;    &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:amqp_channel&lt;&#x2F;span&gt;&lt;span&gt;.next_publish_seqno(pid&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;**
&lt;&#x2F;span&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;end
&lt;&#x2F;span&gt;&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Ensuite je regarde le test passer, &lt;em&gt;easy&lt;&#x2F;em&gt; :)
Deux points très importants ici:&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;puisqu&#x27;il s&#x27;agit d&#x27;ajouter cette fonction a l&#x27;API publique de la bibliothèque, j&#x27;écris une spécification de sa signature en bonne et due forme.&lt;&#x2F;li&gt;
&lt;li&gt;Pour les mêmes raisons, je me fends d&#x27;une documentation d&#x27;utilisation.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;p&gt;L&#x27;étape suivante c&#x27;est d&#x27;ajouter la fonction qui permet d&#x27;enregistrer un &lt;em&gt;handler&lt;&#x2F;em&gt;.
Tous ce que qui a été dit avant reste vrai (tests, documentation, conventions ...).&lt;&#x2F;p&gt;
&lt;p&gt;La fonction Erlang &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;rabbitmq&#x2F;rabbitmq-erlang-client&#x2F;blob&#x2F;master&#x2F;src&#x2F;amqp_channel.erl#L295&quot;&gt;&lt;code&gt;register_confirm_handler&lt;&#x2F;code&gt;&lt;&#x2F;a&gt; attend en argument les identifiants du &lt;em&gt;channel&lt;&#x2F;em&gt; et du &lt;em&gt;handler&lt;&#x2F;em&gt; et retourne un &lt;code&gt;ok&lt;&#x2F;code&gt;. La documentation précise également que le &lt;em&gt;handler&lt;&#x2F;em&gt; recevra une structure en guise de message &lt;code&gt;#basic.ack{}&lt;&#x2F;code&gt; ou &lt;code&gt;#basic.nack{}&lt;&#x2F;code&gt;.&lt;&#x2F;p&gt;
&lt;p&gt;Ce ne sont pas des structures valides pour Elixir, ce sont des &lt;em&gt;Erlang Records&lt;&#x2F;em&gt;.
Comme la sémantique de confirmation est la même que celle de l&#x27;acquittement de messages par le consommateur, la transposition des Records Erlang vers Elixir existe déjà.&lt;&#x2F;p&gt;
&lt;p&gt;En explorant le fichier &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;Electron-libre&#x2F;amqp&#x2F;blob&#x2F;confirm-handler&#x2F;lib&#x2F;amqp&#x2F;core.ex#L19&quot;&gt;&lt;code&gt;core.ex&lt;&#x2F;code&gt;&lt;&#x2F;a&gt; de la bibliothèque j&#x27;apprends que le process recevra un message &lt;code&gt;:basic_ack&lt;&#x2F;code&gt; ou &lt;code&gt;:basic_nack&lt;&#x2F;code&gt;.
Il sera accompagné d&#x27;un ou plusieurs numéros de séquence. Si il y en a plusieurs, le troisième argument
du message vaudra &lt;code&gt;true&lt;&#x2F;code&gt;.&lt;&#x2F;p&gt;
&lt;p&gt;Cette fois-ci le test consiste à:&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;obtenir le prochain numéro de séquence&lt;&#x2F;li&gt;
&lt;li&gt;envoyer un message&lt;&#x2F;li&gt;
&lt;li&gt;déclarer le module test comme handler de confirmation&lt;&#x2F;li&gt;
&lt;li&gt;s&#x27;assurer que je reçoive bien la confirmation&lt;&#x2F;li&gt;
&lt;li&gt;s&#x27;assurer que la confirmation porte bien numéro de séquence attendu&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;pre data-lang=&quot;elixir&quot; style=&quot;background-color:#282828;color:#fdf4c1aa;&quot; class=&quot;language-elixir &quot;&gt;&lt;code class=&quot;language-elixir&quot; data-lang=&quot;elixir&quot;&gt;&lt;span&gt;  describe &lt;&#x2F;span&gt;&lt;span style=&quot;color:#b8bb26;&quot;&gt;&amp;quot;register_handler&amp;quot; &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;do
&lt;&#x2F;span&gt;&lt;span&gt;    test &lt;&#x2F;span&gt;&lt;span style=&quot;color:#b8bb26;&quot;&gt;&amp;quot;handler receive confirm with message seqno&amp;quot;&lt;&#x2F;span&gt;&lt;span&gt;, ctx &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;do
&lt;&#x2F;span&gt;&lt;span&gt;      seq_no &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;= &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Confirm&lt;&#x2F;span&gt;&lt;span&gt;.next_publish_seqno(ctx[&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:chan&lt;&#x2F;span&gt;&lt;span&gt;])
&lt;&#x2F;span&gt;&lt;span&gt;      &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:ok &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;= &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;AMQP&lt;&#x2F;span&gt;&lt;span&gt;.&lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Basic&lt;&#x2F;span&gt;&lt;span&gt;.publish(ctx[&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:chan&lt;&#x2F;span&gt;&lt;span&gt;], &lt;&#x2F;span&gt;&lt;span style=&quot;color:#b8bb26;&quot;&gt;&amp;quot;&amp;quot;&lt;&#x2F;span&gt;&lt;span&gt;, &lt;&#x2F;span&gt;&lt;span style=&quot;color:#b8bb26;&quot;&gt;&amp;quot;&amp;quot;&lt;&#x2F;span&gt;&lt;span&gt;, &lt;&#x2F;span&gt;&lt;span style=&quot;color:#b8bb26;&quot;&gt;&amp;quot;foo&amp;quot;&lt;&#x2F;span&gt;&lt;span&gt;)
&lt;&#x2F;span&gt;&lt;span&gt;      &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:ok &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;= &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Confirm&lt;&#x2F;span&gt;&lt;span&gt;.register_handler(ctx[&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:chan&lt;&#x2F;span&gt;&lt;span&gt;], self())
&lt;&#x2F;span&gt;&lt;span&gt;      assert_receive {&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:basic_ack&lt;&#x2F;span&gt;&lt;span&gt;, seq_no, &lt;&#x2F;span&gt;&lt;span style=&quot;color:#d3869b;&quot;&gt;false&lt;&#x2F;span&gt;&lt;span&gt;}
&lt;&#x2F;span&gt;&lt;span&gt;      &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:ok &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;= &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Confirm&lt;&#x2F;span&gt;&lt;span&gt;.unregister_handler(ctx[&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:chan&lt;&#x2F;span&gt;&lt;span&gt;])
&lt;&#x2F;span&gt;&lt;span&gt;    &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;end
&lt;&#x2F;span&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;end
&lt;&#x2F;span&gt;&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Faire échouer les tests et passer à l&#x27;implémentation.&lt;&#x2F;p&gt;
&lt;p&gt;La fonction &lt;code&gt;register_handler&lt;&#x2F;code&gt; prend en argument le &lt;em&gt;channel&lt;&#x2F;em&gt; et l&#x27;identifiant du handler.&lt;&#x2F;p&gt;
&lt;p&gt;Elle &lt;em&gt;spawn&lt;&#x2F;em&gt; un &lt;em&gt;process&lt;&#x2F;em&gt; qui va servir d&#x27;&lt;em&gt;adapter&lt;&#x2F;em&gt; entre les messages de Erlang vers Elixir.
Ce &lt;em&gt;process&lt;&#x2F;em&gt; est supervisé ainsi que celui du &lt;em&gt;handler&lt;&#x2F;em&gt; pour &lt;a href=&quot;https:&#x2F;&#x2F;hexdocs.pm&#x2F;elixir&#x2F;Process.html#monitor&#x2F;1&quot;&gt;réagir à la mort des process enfants&lt;&#x2F;a&gt; avec un message &lt;code&gt;{:DOWN}&lt;&#x2F;code&gt;.&lt;&#x2F;p&gt;
&lt;p&gt;Puis appelle la fonction privée &lt;code&gt;handle_confirm&lt;&#x2F;code&gt; qui attend la réception d&#x27;un message Erlang et se charge de le transposer et de l&#x27;envoyer au &lt;em&gt;handler&lt;&#x2F;em&gt;.
Pour finir elle utilise la récursion pour rester à l&#x27;écoute.&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;elixir&quot; style=&quot;background-color:#282828;color:#fdf4c1aa;&quot; class=&quot;language-elixir &quot;&gt;&lt;code class=&quot;language-elixir&quot; data-lang=&quot;elixir&quot;&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;@doc &amp;quot;&amp;quot;&amp;quot;
&lt;&#x2F;span&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;  Register a handler for confirms on channel.
&lt;&#x2F;span&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;  The handler will receive either:
&lt;&#x2F;span&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;  * `{:basic_ack, seqno, multiple}`
&lt;&#x2F;span&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;  * `{:basic_nack, seqno, multiple}`
&lt;&#x2F;span&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;  The `seqno` (delivery_tag) is an integer, the sequence number of the message.
&lt;&#x2F;span&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;  `multiple` is a boolean, when `true` means multiple messages confirm, upto `seqno`.
&lt;&#x2F;span&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;  see https:&#x2F;&#x2F;www.rabbitmq.com&#x2F;confirms.html
&lt;&#x2F;span&gt;&lt;span style=&quot;font-style:italic;color:#928374;&quot;&gt;  &amp;quot;&amp;quot;&amp;quot;
&lt;&#x2F;span&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;@&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;spec&lt;&#x2F;span&gt;&lt;span&gt; register_handler(&lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Channel&lt;&#x2F;span&gt;&lt;span&gt;.t, pid) :: &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:ok
&lt;&#x2F;span&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;def &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;register_handler&lt;&#x2F;span&gt;&lt;span&gt;(%&lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Channel&lt;&#x2F;span&gt;&lt;span&gt;{&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;pid:&lt;&#x2F;span&gt;&lt;span&gt; pid}, handler_pid) &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;do
&lt;&#x2F;span&gt;&lt;span&gt;    adapter_pid &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;=&lt;&#x2F;span&gt;&lt;span&gt; spawn &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;fn &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;-&amp;gt;
&lt;&#x2F;span&gt;&lt;span&gt;      &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Process&lt;&#x2F;span&gt;&lt;span&gt;.flag(&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:trap_exit&lt;&#x2F;span&gt;&lt;span&gt;, &lt;&#x2F;span&gt;&lt;span style=&quot;color:#d3869b;&quot;&gt;true&lt;&#x2F;span&gt;&lt;span&gt;)
&lt;&#x2F;span&gt;&lt;span&gt;      &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Process&lt;&#x2F;span&gt;&lt;span&gt;.monitor(handler_pid)
&lt;&#x2F;span&gt;&lt;span&gt;      &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;Process&lt;&#x2F;span&gt;&lt;span&gt;.monitor(pid)
&lt;&#x2F;span&gt;&lt;span&gt;      handle_confirm(handler_pid)
&lt;&#x2F;span&gt;&lt;span&gt;    &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;end
&lt;&#x2F;span&gt;&lt;span&gt;    &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:amqp_channel&lt;&#x2F;span&gt;&lt;span&gt;.register_confirm_handler(pid, adapter_pid)
&lt;&#x2F;span&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;end
&lt;&#x2F;span&gt;&lt;span&gt;  
&lt;&#x2F;span&gt;&lt;span&gt;   &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;defp &lt;&#x2F;span&gt;&lt;span style=&quot;color:#8ec07c;&quot;&gt;handle_confirm&lt;&#x2F;span&gt;&lt;span&gt;(handler_pid) &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;do
&lt;&#x2F;span&gt;&lt;span&gt;    &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;receive do
&lt;&#x2F;span&gt;&lt;span&gt;      basic_ack(&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;delivery_tag:&lt;&#x2F;span&gt;&lt;span&gt; delivery_tag, &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;multiple:&lt;&#x2F;span&gt;&lt;span&gt; multiple) &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;-&amp;gt;
&lt;&#x2F;span&gt;&lt;span&gt;        send(handler_pid, {&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:basic_ack&lt;&#x2F;span&gt;&lt;span&gt;, delivery_tag, multiple})
&lt;&#x2F;span&gt;&lt;span&gt;        handle_confirm(handler_pid)
&lt;&#x2F;span&gt;&lt;span&gt;
&lt;&#x2F;span&gt;&lt;span&gt;      basic_nack(&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;delivery_tag:&lt;&#x2F;span&gt;&lt;span&gt; delivery_tag, &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;multiple:&lt;&#x2F;span&gt;&lt;span&gt; multiple) &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;-&amp;gt;
&lt;&#x2F;span&gt;&lt;span&gt;        send(handler_pid, {&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:basic_nack&lt;&#x2F;span&gt;&lt;span&gt;, delivery_tag, multiple})
&lt;&#x2F;span&gt;&lt;span&gt;        handle_confirm(handler_pid)
&lt;&#x2F;span&gt;&lt;span&gt;
&lt;&#x2F;span&gt;&lt;span&gt;      {&lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:DOWN&lt;&#x2F;span&gt;&lt;span&gt;, _ref, &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fdf4c1;&quot;&gt;:process&lt;&#x2F;span&gt;&lt;span&gt;, _pid, reason} &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fe8019;&quot;&gt;-&amp;gt;
&lt;&#x2F;span&gt;&lt;span&gt;          &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;exit&lt;&#x2F;span&gt;&lt;span&gt;(reason)
&lt;&#x2F;span&gt;&lt;span&gt;    &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;end
&lt;&#x2F;span&gt;&lt;span&gt;  &lt;&#x2F;span&gt;&lt;span style=&quot;color:#fa5c4b;&quot;&gt;end
&lt;&#x2F;span&gt;&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Les tests passent, il ne reste qu&#x27;à ajouter la fonction &lt;code&gt;unregister_hander&#x2F;1&lt;&#x2F;code&gt;.
Je ne la commenterais pas, car tu n&#x27;y apprendra rien de plus ce qui a été dit plus haut.&lt;&#x2F;p&gt;
&lt;p&gt;Tu trouvera la commit dans son intégralité sur &lt;a href=&quot;https:&#x2F;&#x2F;github.com&#x2F;Electron-libre&#x2F;amqp&#x2F;commit&#x2F;97f7e3f98b179793bd98fb687d59b03a338c9af3&quot;&gt;github&lt;&#x2F;a&gt;.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;pour-finir&quot;&gt;Pour finir&lt;&#x2F;h2&gt;
&lt;p&gt;La PR a été intégrée et fait partie des &lt;em&gt;features&lt;&#x2F;em&gt; de la version 1.2.&lt;&#x2F;p&gt;
&lt;p&gt;Le fait d&#x27;avoir adopté les conventions des mainteneurs du projet leur ont permis d&#x27;enchaîner un &lt;em&gt;refactoring&lt;&#x2F;em&gt; sans en souffrir.&lt;&#x2F;p&gt;
&lt;p&gt;Et finalement je peux traiter les confirmations de manière asynchrone sans avoir à utiliser l&#x27;API du client Erlang dans mon application.&lt;&#x2F;p&gt;
</content>
        
    </entry>
</feed>
