Il y a une raison pour laquelle certaines personnes semblent constamment livrer les meilleurs logiciels, écrire un contenu incroyable ou générer des images époustouflantes…
Ils ont adopté la boucle d'évaluation, tandis que toi…
Tu as essayé de meilleurs prompts, tu es passé au modèle le plus cher, tu as écrit des instructions plus longues, tu as activé la mémoire, tu as construit des fichiers de contexte de la taille d’un roman… et le déchet revient toujours.
Il revient parce que tu continues à réparer la couche qui n’a jamais été cassée.
Le déchet n’est pas un problème de prompt, c’est un problème de système, de la même façon qu’une usine qui livre des pièces défectueuses n’a pas un problème d’ouvriers, mais un problème de contrôle qualité : personne ne vérifie la sortie avant qu’elle ne quitte le bâtiment.
Voici donc le plan : à la fin de cette lecture, tu auras une boucle d’évaluation fonctionnelle tournant dans Hermes, l’agent open-source, qui notera chaque sortie selon ton standard avant de l’expédier, surveillera ta sortie en direct après expédition, et transformera chaque échec en un nouveau test pour que le plancher de qualité monte tout seul.
Nous le construisons ensemble, pièce par pièce, et le bénéfice est concret : une sortie propre à laquelle tu peux faire confiance sans devoir la relire à minuit, un chiffre de qualité que tu peux réellement consulter, et un déchet qui est attrapé à la sortie, pas par ton public.
Voici ce que tu obtiendras :
- La vraie raison pour laquelle les meilleurs prompts, les modèles plus gros et la mémoire ne tuent jamais définitivement le déchet, et la seule couche qui le fait réellement.
- Les deux endroits où le déchet se cache dans ton travail : ta sortie de contenu et ta sortie produit, et pourquoi la solution est identique pour les deux.
- Ce qu’est une boucle d’évaluation en langage clair : la couche qualité que très peu de gens utilisent quotidiennement, et la raison pour laquelle personne ne t’a jamais dit d’en construire une.
- Un référentiel de qualité que tu peux mettre en place cette semaine, pour le contenu et pour le produit : exactement quoi mesurer et à quoi ressemble un « bon » résultat sous forme de chiffre lisible.
- La construction exacte, étape par étape, pour câbler toute cette boucle dans Hermes en utilisant les pièces qu’il te fournit déjà : compétences, mémoire, cron et boutons d’approbation, pour que la porte fonctionne sans toi.
Si tu es venu ici pour « les 5 prompts qui réparent le slop IA », ce n’est pas cet article. Ceux-là existent et ne marchent pas. Voici la version qui fonctionne.
Tu as tout essayé sauf l’essentiel
Un petit tour de ce que tu as déjà fait :
Tu as réécrit le prompt, trois fois, quatre fois. Tu as ajouté des exemples, ajouté une persona, ajouté une liste de « à ne pas faire » longue d’un kilomètre.
Tu es passé au modèle de pointe, payé 5x par token, et les sorties sont devenues plus confiantes sans devenir moins génériques.
Tu as activé la mémoire, construit un fichier de contexte, nourri l’agent de ta voix de marque, de ton travail passé, de ton guide de style.
Et chacun de ces gestes t’a acheté quelques bonnes générations, puis le déchet est revenu.
Chacun de ces gestes est une correction côté entrée. Tu continues à affiner ce qui génère, tout en ignorant ce qui devrait attraper. Un meilleur fusil tiré dans le noir ne touche toujours rien.
Le déchet est un problème côté sortie. Ce n’est pas que le modèle ne peut pas produire du bon travail, c’est que tu n’as aucun moyen de distinguer le bon du mauvais avant qu’il n’atteigne quelqu’un d’important.
Il n’y a pas de boucle d’évaluation, pas de référentiel qualité, pas de tableau de bord. Tu ajustes à l’aveugle. Tu changes un prompt et tu sens que c’est mieux, mais sentir n’est pas mesurer, et une sensation n’attrape pas la mauvaise exécution cachée dans les 50 générations suivantes.
Alors tu te blâmes toi-même, ou ton prompt, ou la configuration de ton agent, ou ton ingénierie de contexte, alors que la pièce manquante est toute une couche du travail avec l’IA qu’on ne t’a jamais montrée. À la fin de cet article, cette couche tournera sur ta propre machine dans Hermes.
Pourquoi de meilleurs prompts ne peuvent pas résoudre ça (et pourquoi tout le monde continue d’essayer quand même)
Un prompt est une hypothèse. La sortie est le résultat. Et une évaluation est la seule chose qui ferme la boucle entre les deux.
Sans cette boucle, tu devines pour toujours : tu ajustes l’hypothèse, tu regardes un résultat, tu déclares victoire, et tu ne découvres jamais que le même prompt produit des déchets 30 % du temps parce que tu n’as regardé qu’une seule sortie.
Le modèle est non déterministe. Le même prompt exécuté deux fois donne deux réponses différentes. Cela signifie que même un prompt parfait produit du déchet sur un certain pourcentage d’exécutions, et tu ne sais pas lesquelles jusqu’à ce qu’un client ou un utilisateur les ait sous les yeux.
Donc un prompt parfait n’est pas une garantie de qualité, c’est un lancer de pièce légèrement meilleur. Et tu expédies chaque lancer.
La raison pour laquelle tout le monde continue de se tourner vers les prompts est simple : le prompt est le seul levier que tu peux réellement voir. Tu peux l’éditer, et l’éditer donne l’impression de contrôler.
La mesure est invisible. Personne ne te vend un cours là-dessus. Personne ne publie un fil viral intitulé « La suite d’évaluation qui a décuplé ma production ». Alors toute la conversation reste bloquée sur le seul levier qui ne peut pas résoudre le problème tout seul.
Les gens dont la sortie IA est constamment propre ne sont pas meilleurs que toi en prompting. Ils ont juste un second levier que tu n’as pas : ils mesurent chaque sortie par rapport à un standard avant de l’expédier, et c’est cette mesure qui rend leur prompting magique.
Les deux endroits où vit le déchet
Le déchet se cache exactement à deux endroits, et presque tout le monde n’en regarde qu’un.
Endroit 1 : ta sortie de contenu
Les tweets, les articles, les e-mails, les pages d’atterrissage, les posts. Tout ce que tu génères avec l’IA et publies sous ton nom.
Ici, le déchet ressemble à un travail techniquement correct mais totalement creux. Il sonne comme tous les autres comptes IA sur le fil. Correct à l’extérieur, vide à l’intérieur.
Il meurt en public et tu ne peux pas expliquer pourquoi, parce que chaque pièce individuelle semblait correcte au moment où tu as appuyé sur « envoyer ».
Endroit 2 : ta sortie produit
La fonctionnalité IA que tu as livrée, l’agent, le chatbot, le répondeur support, le pipeline d’extraction, ce que tes utilisateurs touchent réellement.
Ici, le déchet ressemble à une mauvaise réponse donnée avec une totale confiance, un nombre halluciné, un payload JSON cassé, un ton qui ne correspond pas à la marque, une sortie géniale en démo et qui s’est dégradée silencieusement trois déploiements plus tard.
Il ne meurt pas en public, il se propage en silence. Chaque utilisateur reçoit une expérience légèrement pire, et la plupart ne te le disent jamais. Ils partent simplement.
Ce sont la même maladie avec le même remède.
Le déchet de contenu et le déchet produit sont tous deux des sorties IA non mesurées qui vont directement au public sans aucune porte entre les deux.
La seule différence, ce sont les enjeux et la visibilité : le déchet de contenu t’embarrasse bruyamment, le déchet produit te saigne silencieusement. Et la boucle que nous construisons dans Hermes note les deux avec la même compétence, pour que tu puisses gérer un seul système de qualité sur tout ce que tu génères, plutôt que deux.
Ce qu’est réellement une boucle d’évaluation
Une boucle d’évaluation est un test reproductible qui note ta sortie IA par rapport à un standard, automatiquement, à chaque fois, avant qu’elle ne soit expédiée et après.
C’est tout. C’est l’affaire. Et c’est la couche que presque personne construisant avec l’IA n’a.
générer la sortie
la noter par rapport à un référentiel que tu as défini
attraper les exécutions qui tombent sous la ligne
corriger ce qui échoue
re-noter, et ne laisser passer que la sortie conforme
Les ingénieurs logiciels ont ça depuis toujours, ça s’appelle les tests. Tu n’expédierais jamais du code sans tests en espérant que ça marche en production. Pourtant, c’est exactement comme ça que toute l’industrie expédie la sortie IA aujourd’hui : directement du modèle à l’utilisateur, sur une impulsion et une prière.
La raison pour laquelle presque personne n’a de boucle d’évaluation est démographique. Les gens qui construisent avec l’IA aujourd’hui viennent du contenu, de la vente, du produit, de la création d’entreprise, pas de l’ingénierie. Donc « écrire des tests pour ta sortie » n’a jamais fait partie de la boîte à outils. Les évaluations sont perçues comme une infrastructure pour les « vrais » ingénieurs, et ceux qui en ont le plus besoin pensent qu’ils n’ont pas le droit d’en vouloir une.
Considère ça comme des tests unitaires pour le non-déterministe. Tu ne testes pas si le code s’exécute, tu testes si la sortie est bonne, et tu le fais sur suffisamment de cas pour qu’une mauvaise exécution ne puisse pas se cacher.
Une boucle d’évaluation fonctionne à trois endroits, et la construction à venir les mettra tous les trois :
- Avant d’expédier : exécute ton nouveau prompt ou modèle sur un ensemble de cas sauvegardés et confirme qu’il ne s’est pas dégradé. C’est le test de régression. C’est ainsi que tu empêches un changement qui résout une chose et en casse silencieusement trois autres.
- À l’exécution : note la sortie au fur et à mesure qu’elle est générée et laisse la logique conditionnelle attraper les échecs avant qu’ils n’atteignent l’utilisateur. C’est la barrière de sécurité.
- En production : note un échantillon des exécutions réelles en continu pour voir la qualité se dégrader le jour où ça commence, pas la semaine où un client se plaint.
Tu peux mettre en place le premier dans un tableur, mais faire fonctionner les trois en continu sans que cela devienne un second travail, c’est toute la raison pour laquelle nous mettons ça dans un agent.
Le moment où la qualité devient un chiffre, le déchet cesse d’être une sensation persistante pour devenir un bug que tu peux corriger. Tu ne peux pas déboguer une impression. Tu peux déboguer un score qui est passé de 0,82 à 0,61.
Le référentiel : les trois parties que tu vas construire
Un référentiel a trois parties, et ce sont les mêmes trois parties que tu notes du contenu ou un produit :
cas de test : des entrées réelles associées à ce à quoi ressemble une bonne sortie (ta vérité terrain)
métriques : comment transformer une sortie en score, idéalement de 0 à 1
un seuil : la ligne en dessous de laquelle rien n’est expédié
Construis ces trois éléments et tu as une porte qualité. Saute l’un d’eux et tu n’as qu’un vœu. Le reste de cette section montre ce qui va dans chaque partie, puis nous câblons le tout dans Hermes.
Pour le contenu, tes cas de test sont ton étalon-or
Prends 20 à 50 de tes meilleures pièces : les cartons, les posts qui ont été mis en favoris, les articles derrière lesquels tu mettrais tout ton nom. Voilà à quoi ressemble le « bon ». Tu n’inventes pas un standard, tu extrais celui que tu as déjà atteint lors de tes meilleurs jours.
Pour le contenu, ta métrique est une grille d’évaluation
Un score ne vaut que par la grille qui le sous-tend. Alors encode ce que tu crois réellement qui rend le travail bon. Pour le contenu, je note chaque pièce sur quatre critères :
- Il explique comment faire quelque chose de spécifique, pas une ambiance, une action que le lecteur peut entreprendre demain.
- N’importe qui dans le public peut le suivre, pas de mur de jargon, pas de jargons d’initiés.
- Il est structuré, reproductible, étape par étape, pas seulement inspirant.
- Il est nouveau : le lecteur ne savait pas qu’on pouvait faire ça.
Le méta-critère au-dessus des quatre : quelqu’un mettrait-il ceci en favori pour revenir l’implémenter plus tard ? Si la réponse est non, c’est du déchet, peu importe la propreté de la prose.
L’astuce, c’est la grille. Une grille vague (« est-ce que c’est bon et engageant ? ») produit un score vague. Une grille spécifique (« est-ce que ça contient au moins un modèle ou un playbook copiable ? ») produit un score auquel tu peux faire confiance. Le juge n’hérite de ton goût que si tu écris réellement ton goût.
Pour le produit, tes cas de test viennent de tes logs
Prends les entrées réelles que ta fonctionnalité voit, de tes logs, de sessions utilisateur réelles, pas des trois exemples de parcours heureux que tu as testés le jour du lancement. Les cas qui te cassent sont les cas bizarres, et les cas bizarres vivent dans tes logs.
Pour le produit, ta métrique correspond à la tâche
Pour chaque entrée, définis à quoi ressemble une sortie correcte. Puis fais correspondre la métrique à la tâche : correspondance exacte quand il y a une seule étiquette correcte, un validateur quand la structure doit tenir, similarité sémantique plus un juge quand la sortie est ouverte. La métrique doit juste renvoyer un nombre, car un nombre est la seule chose sur laquelle tu peux mettre un seuil.
Pour les deux, le seuil est la ligne que tu maintiens
0,7 est un point de départ raisonnable. Tout ce qui est en dessous de 0,7 est retravaillé ou tué avant d’être expédié, sans exception. Le seuil ne fonctionne que si tu ne laisses jamais passer un 0,6 parce que tu l’aimes bien. Tout l’intérêt est de retirer l’ego de fin de soirée de la décision.
Voilà le référentiel. Maintenant, nous le faisons tourner tout seul.
Construire la boucle dans Hermes
Hermes n’a pas de bouton « évaluations ». Il n’y a pas de tableau de bord appelé « qualité » où tu cliques sur « activer la protection anti-déchet ».
Ce qu’Hermes te donne à la place est mieux : les pièces brutes d’une boucle d’évaluation sous forme de primitives que tu assembles une fois et que tu possèdes ensuite.
Des compétences qu’il écrit pour lui-même et réutilise, une mémoire persistante qui grandit à travers les sessions, un cron intégré qui livre sur n’importe quelle plateforme, des boutons d’approbation dans Slack, et une habitude d’auto-amélioration ancrée dans le noyau.
Hermes se présente comme « l’agent qui grandit avec toi », et cette croissance est exactement la boucle que nous construisons.
Alors câblons-la, en six mouvements.
Mouvement 1 : installe Hermes là où il peut te joindre
Installe-le et connecte-le à Telegram. C’est plus important que ça en a l’air, car la porte ne fonctionne que si elle peut t’interrompre. Hermes fonctionne sur plus de 20 canaux et envoie des boutons d’approbation natifs dans Slack et Telegram, pour que l’agent puisse travailler en arrière-plan et te taper sur l’épaule quand une décision t’appartient.
Mouvement 2 : charge ton étalon-or dans la mémoire
Hermes a une mémoire persistante qui grandit à travers les sessions avec un rappel complet inter-sessions. Les 20 à 50 meilleures pièces de ton référentiel y vont une fois et y restent. C’est la partie qui est normalement dispersée dans des captures d’écran et de vieux brouillons. Ici, c’est la mémoire à long terme de l’agent, interrogeable, la vérité terrain contre laquelle tes scores sont mesurés.
Mouvement 3 : transforme ta grille d’évaluation en compétence de juge
C’est le cœur du système. Tu dis à Hermes une fois, en anglais simple, de créer une compétence qui prend une sortie plus ta grille et retourne un score de 0 à 1 par critère avec une raison d’une ligne. C’est le « LLM en tant que juge » : un agent qui note ton LLM. Et un modèle avec une grille précise est un critique plus cohérent que toi, car il n’a pas d’ego dans la pièce et n’est pas attaché à la phrase dont tu es secrètement fier.
La raison pour laquelle ça vit comme une compétence et non comme un prompt unique, c’est que les compétences de Hermes sont une mémoire procédurale : l’agent les écrit, les conserve et les réutilise. Tu codes ton goût une seule fois et il note chaque sortie pour toujours. Et les compétences se cumulent : nous avons trouvé que les agents avec plus de 20 compétences auto-créées terminent des tâches similaires 40 % plus vite parce qu’ils arrêtent de redécouvrir le processus. Ton juge devient plus précis à mesure qu’il tourne.
Mouvement 4 : fais de la suite une compétence, pas un tableur
Tes cas de test plus les fonctions métriques deviennent une compétence que Hermes possède et versionne. La bibliothèque de métriques est ce dont la tâche a besoin : correspondance exacte pour la classification, regex pour l’extraction, validateurs JSON et clé-valeur pour la structure, similarité sémantique pour la sortie générative.
Ta compétence de juge pour les trucs ouverts. Hermes écrit lui-même le code de notation : tu décris la tâche et il construit la métrique. Le tout réside dans un seul endroit que l’agent possède, au lieu d’un tableur que tu perdras.
Mouvement 5 : verrouille l’expédition avec des tests de régression et un bouton d’approbation
C’est l’habitude au plus fort levier dans tout le système, et celle que personne ne continue à faire à la main. Alors nous la confions à l’agent. Câble-la pour que tout changement – un nouveau prompt, un modèle échangé, un pipeline modifié – déclenche la suite. Hermes réexécute chaque cas, calcule le delta de score par rapport à la référence, et au lieu d’expédier silencieusement, il te pingue dans Slack : « Scores passés de 0,81 à 0,74, deux cas ont régressé. Approuver ? » Et il n’avance que quand tu appuies sur le bouton.
Tu peux le verrouiller sur ce travail avec /goal, qui maintient l’agent sur un objectif à travers les tours. Et pour quelque chose de plus gros, son kanban multi-agent peut décomposer l’exécution, noter en parallèle et planifier. Ainsi la porte est un processus permanent, pas une chose dont tu te souviens de lancer.
Mouvement 6 : surveille la production avec un cron et ferme la boucle
Hermes a un cron intégré qui livre sur n’importe quelle plateforme. Tu planifies un job qui échantillonne les exécutions réelles, les note avec la même compétence de juge, et t’envoie un message direct dès que la ligne descend. Tu attrapes la dégradation le jour où elle commence, pas la semaine où un client se plaint. « Le score d’évaluation a chuté » est un problème sur lequel tu peux agir. « Un client avait l’air énervé » n’en est pas un.
Vient ensuite la partie qui fait que tout se cumule : quand tu signales une mauvaise sortie avec un pouce vers le bas dans Slack, Hermes la réécrit dans la compétence de suite comme un nouveau cas de test. Cette exécution ratée devient une vérification permanente. Et comme l’auto-amélioration est ce qu’est Hermes, pas une fonctionnalité ajoutée sur le côté, la suite se renforce chaque semaine toute seule. Le plancher monte pendant que tu dors.
À quoi ressemble le « bon » une fois que ça tourne, concrètement :
- Un contenu en dessous de 0,7 sur ta grille n’est jamais expédié.
- Un changement produit qui fait descendre une métrique sous la référence bloque le déploiement jusqu’à ce que tu l’approuves.
- La ligne de score en production reste stable ou monte. Le jour où elle descend, Hermes te pingue, pas la semaine où le taux d’attrition apparaît.
La partie que personne ne veut entendre
La raison pour laquelle ta sortie IA est incohérente, ce n’est pas que tu es mauvais en prompting. Et ce n’est pas que le modèle n’est pas encore assez intelligent.
C’est que tu fais fonctionner une étape de génération sans étape qualité. Tu as construit la moitié d’un système et tu blâmes la moitié qui fonctionne.
La solution n’est pas un meilleur prompt, c’est une couche manquante : définir ce qu’est le « bon », le transformer en chiffre, noter chaque sortie par rapport à ça, bloquer tout ce qui tombe sous la ligne, et fermer la boucle pour que le plancher monte chaque semaine. Et maintenant, cette couche n’est plus un projet « un jour », c’est six mouvements dans un agent qui tourne sur ta propre machine.
Fais ça, et le déchet cesse d’être une chose qui t’arrive au hasard et devient une chose que tu attrapes à la sortie, à chaque fois, exactement comme une vraie usine attrape un défaut avant qu’il n’atteigne un client.
Le prompt n’a jamais été le système.
La boucle d’évaluation est le système. Hermes est là où elle tourne. Et maintenant, tu l’as.
