C'est un travail de titan : comment l'IA maintient notre code conforme aux standards
View all articlesMaxime Gréau
Principal Software Engineer
Chainguard
Maxime Gréau Principal Software Engineer
Comment une flotte d'agents IA maintient des centaines de modules conformes aux standards — et fusionne automatiquement les modifications sans risque.

Maintenir un vaste monorepo conforme aux standards n'évolue pas aussi bien qu'on le souhaiterait à grande échelle. Les directives existent — conventions de gestion des erreurs, bibliothèques approuvées, épinglage des workflows GitHub Actions — et nos ingénieurs les connaissent bien. Mais chaque standard doit tout de même être maintenu à jour à mesure qu'il évolue et appliqué à des centaines de modules à chaque modification. À cette échelle, aucune équipe ne peut suivre le rythme manuellement : la documentation est à la traîne par rapport au code, une convention dérive, un workflow déroge aux règles dans un recoin auquel personne n'a prêté attention cette semaine.
Alors, plutôt que de consacrer du temps d'ingénierie à réappliquer manuellement les mêmes standards, nous avons conçu un système pour effectuer cette tâche à notre place. Chaque standard prend la forme d'un artefact lisible par une machine, et une flotte d'agents reposant sur DriftlessAF — notre framework de réconciliation agentique — veille en continu à ce que le codebase converge vers ces standards.
Au cours des 8 dernières semaines, sur l'ensemble de nos dépôts, ce système a ouvert plus de 4 700 pull requests de mise en conformité et a fusionné automatiquement 75 % de celles jugées à faible risque, sans aucune intervention humaine. Cet article explique son fonctionnement et montre pourquoi sa fiabilité ne repose pas sur une confiance accrue envers l'IA, mais sur le fait de ne jamais la laisser fusionner seule : chaque fusion automatique exige un consensus entre le jugement de l'IA et des vérifications déterministes.

Rédigez le standard une fois. Appliquez-le partout.
Le changement semble minime dans sa formulation, mais il est majeur dans ses effets : un standard n'est pas un paragraphe dans un document, c'est un artefact qu'un agent peut charger. Vous le créez une seule fois, et il fonctionne dans deux directions. Il examine le nouveau code à son arrivée, en vérifiant chaque modification entrante par rapport au standard avant sa fusion. Et il balaye le codebase existant, proposant un correctif dès qu'un module s'est écarté de la norme. Un seul artefact créé, appliqué en continu à chaque modification intégrée et à chaque module déjà présent.

Une flotte d'agents spécialisés : reviewer, skillfixer, autofixer, loganalyzer, judge
Nous exploitons de nombreux agents spécialisés, chacun ayant précisément une mission et une définition de ce qui est achevé. Un reviewer détecte les infractions par rapport aux standards chargés, et un skillfixer les corrige. Lorsqu'une modification casse la CI, un autofixer distinct la répare, en s'appuyant sur un LogAnalyzer qui extrait la cause première de logs de build bruités. Un judge évalue ce travail hors ligne, ce qui nous permet de détecter toute régression dans un standard ou un prompt. Et le bot de confiance attribue un score pour évaluer le niveau de sécurité d'une pull request finalisée avant sa fusion. C'est ce signal qui permet d'intégrer les modifications à faible risque sans intervention humaine. Des réconciliateurs assurent leur coordination.
Partie 1 — Les Skills : un standard exécutable
L'artefact sous lequel nous encodons chaque standard est un Skill. C'est ainsi qu'un agent sait ce que signifie « correct » avant d'examiner ou de corriger le moindre code.
Qu'est-ce qu'un Skill, et pourquoi ce n'est pas simplement un prompt ?
Un Skill est un ensemble d'instructions structurées qu'un agent charge à la demande. Il respecte la spécification ouverte agentskills.io, et sa structure est délibérément simple : un nom, une description qui sert de déclencheur, un corps d'instructions directes avec des exemples concrets de ce qu'il faut faire et ne pas faire, et des fichiers de référence facultatifs pour les détails plus précis. Voici l'essentiel de l'un des nôtres, go-standards :
---
name: go-standards
description: Enforces Go conventions for this repository. Use when writing,
reviewing, or fixing Go code — syntax preferences, library choices,
error handling, and package design.
---
# Go Standards
## Error wrapping
Always wrap errors with context using %w. Never discard the original error.
Correct:
return fmt.Errorf("read config %q: %w", path, err)
Wrong:
return errors.New("failed to read config")
**Audit:** grep for `errors.New` in code paths that already hold an `err`.
Ce qui en fait bien plus qu'un simple prompt ingénieux, c'est son mode de chargement. Les Skills utilisent la divulgation progressive : l'agent ne voit au départ que le nom et la description de chaque compétence (environ une centaine de tokens chacun) et ne lit les instructions complètes que lorsqu'un Skill est pertinent, ainsi que les fichiers de référence plus approfondis uniquement si nécessaire. Il n'extrait donc les conventions Go que lorsqu'il analyse du Go, les règles de renforcement GitHub Actions lorsqu'il examine un workflow, les modèles de revue de sécurité lorsqu'il traite du code d'authentification, et rien d'autre.
Et go-standards n'est qu'un Skill parmi d'autres — gha-standards pour l'épinglage et la gestion des permissions des workflows, go-security-review pour les schémas qu'un ingénieur en sécurité recherche. Différents types d'exigences — style, sécurité de la CI, posture de sécurité —, une même forme d'artefact, appliquée par les mêmes agents. Standardiser un nouveau domaine revient à écrire un nouveau Skill, et non à concevoir un nouvel outil.
Les Skills sont du code : versionnés, relus et testés par évaluation
Nous traitons un Skill avec la même rigueur que le code applicatif qu'il régit. Un standard appliqué automatiquement à des centaines de modules se doit d'être irréprochable ; ainsi, toute modification apportée à un Skill passe par les mêmes étapes de pull request, de revue et de CI que n'importe quel autre changement. Il existe même un Skill pour cela : skill-authoring formalise ce qu'est un bon Skill, et le reviewer l'utilise pour vérifier chaque nouveau fichier SKILL.md de la même manière qu'il inspecte du code Go.
Cette CI accomplit deux choses :
Vérification | Ce qu'elle valide | Ce qu'elle intercepte |
Conformité à la spécification | Le contrat technique — un frontmatter valide, une description contenant une véritable clause de déclenchement, une structure de répertoires cohérente, un corps respectant la limite de lignes. | Un Skill qui ne se charge pas ou ne se déclenche pas. |
Évaluations de référence (« golden evals ») | Que le Skill fonctionne — face à des fichiers comportant des violations connues, l'agent reviewer doté de ce Skill signale exactement les bonnes lignes et reste silencieux face à un code propre. | Un Skill qui se déclenche mais effectue une mauvaise revue. |
L'évaluation de cette seconde ligne est effectuée par un agent — notre Judge — qui note le résultat produit par le reviewer par rapport au résultat attendu.
Cette deuxième ligne est la plus importante. Une évaluation est un cas de test comportemental : un fichier comportant des problèmes connus, associé à la revue qu'un agent correct devrait générer. Les évaluations sont précisément ce qui nous permet d'accorder notre confiance à un agent, car les agents sont non déterministes. Une même compétence (Skill) peut produire des revues légèrement différentes d'une exécution à l'autre. C'est aussi pourquoi une poignée de cas ne suffit pas : dans une suite de quatre cas, un seul échec intermittent fait chuter la compétence sous son seuil de réussite, et le score ne permet pas de distinguer une véritable régression d'une exécution malchanceuse. Nous conservons au moins dix cas par compétence, afin que le seuil reflète si la compétence fonctionne réellement, plutôt que les aléas d'une exécution donnée.
Les compétences résident dans un référentiel unique servant de source de vérité, et lorsqu'une modification y est apportée, un flux de travail automatisé la déploie sur tous les autres dépôts et bots qui l'utilisent. Ce qui s'exécute en production correspond exactement à ce que nous avons revu et testé, jamais à une copie obsolète.
Appliquer les compétences en continu — les agents réviseur et correcteur
Une compétence n'agit que lorsqu'un agent l'applique, et le bot qui applique les nôtres est skillup — un réconciliateur qui surveille la base de code et, lorsqu'un fichier pertinent est modifié, exécute successivement deux agents. L'agent réviseur charge les compétences qui correspondent aux fichiers modifiés et signale les observations ancrées sur des lignes précises, publiées sous la forme d'une exécution de vérification (Check Run) GitHub. L'agent correcteur (skillfixer) va plus loin : il produit la modification conforme et ouvre une pull request.
C'est un changement de paradigme dans la façon de concevoir la revue de code. Au lieu d'appliquer manuellement le même jugement PR après PR, vous rédigez une politique unique qui capture l'esprit de ces revues, et le système l'applique partout. C'est la seule façon de faire passer ce genre de travail à l'échelle.
Partie 2 — La boucle d'agents : intégrer les mises à jour à l'échelle
La partie 1 a permis de rendre un standard rédigé suffisamment fiable pour être appliqué partout. Voici la seconde moitié du problème : appliquer et intégrer ces modifications au rythme du dépôt. Deux conditions doivent être remplies : le mécanisme qui ouvre les PR doit pouvoir fonctionner indéfiniment en toute sécurité, et celui qui les fusionne doit mériter une confiance absolue.
Garantir la convergence de la base de code, à chaque modification
DriftlessAF nous fournit des réconciliateurs, et c'est le moteur que nous mettons au service du problème des standards. Un réconciliateur fonctionne par niveau d'état : il ne se déclenche pas une seule fois sur un événement en espérant que cela a fonctionné — il vérifie en permanence si la base de code correspond à l'état souhaité et comble l'écart lorsque ce n'est pas le cas. Appliquée aux standards, la question n'est pas « quelqu'un a-t-il enfreint les go-standards dans cette PR ? », mais « chaque module respecte-t-il toujours les go-standards ? ». Cette question est posée en continu, à chaque modification.
C'est ce qui rend le système pérenne, plutôt qu'un simple script à exécution unique. Si une tentative de correction se heurte à un appel de modèle instable ou à un délai d'attente dépassé, rien n'est perdu ; la passe suivante réconcilie le même écart. Si quelqu'un réintroduit une convention que nous avions déjà nettoyée, la passe suivante la détecte de la même manière que la première fois. Les standards continuent d'évoluer, le code continue de changer, et le réconciliateur continue simplement de faire converger les deux.
Nous obtenons ce résultat sur l'ensemble du parc car le mécanisme sous-jacent est le même. skillup (le réviseur et skillfixer qui applique les standards), autofix (le correcteur qui répare l'intégration continue cassée, en s'appuyant sur un agent LogAnalyzer pour lire les journaux) et le bot de confiance sont tous des réconciliateurs construits sur le même socle ; ainsi, la durabilité, les nouvelles tentatives et le contrôle de la concurrence sont résolus une fois pour toutes et réutilisés. Chacun d'eux compose un ou plusieurs agents derrière un service unique. Un seul modèle, de multiples applications.

Quand la CI échoue, l'agent correcteur la répare — et uniquement ce qui est cassé
Les réconciliateurs ouvrent de nombreuses PR, et certaines d'entre elles cassent la CI. C'est là qu'intervient l'autofixer — l'agent correcteur de notre bot autofix. Il part des vérifications en échec et des fichiers modifiés, puis mène l'enquête à partir de là, comme le ferait un humain.
Son premier réflexe est généralement d'examiner les journaux. Mais les journaux de CI représentent des milliers de lignes de sortie de build, de bavardage de tests et de bruit du compilateur, et l'erreur réelle se résume à quelques lignes quelque part au milieu. Le correcteur ne les lit donc pas directement. Il appelle l'agent LogAnalyzer en tant qu'outil, et tout le rôle du LogAnalyzer consiste à transformer ce pavé de texte en une ou deux causes profondes structurées : un type d'erreur, un message, un fichier et une ligne, la commande en échec et un extrait de contexte expliquant pourquoi c'est important. La plupart du temps, une règle simple fait l'affaire : les erreurs situées juste avant un code de sortie non nul en sont généralement la cause. L'objectif est de faire émerger la ou les deux erreurs qui comptent réellement.
{
"summary": "Build failed: reference to a function that was renamed.",
"failures": [
{
"type": "build",
"severity": "error",
"error_message": "undefined: validateConfig",
"location": { "file_path": "config/loader.go", "line": 42 },
"failing_command": "go build ./...",
"context": [
{
"content": "config/loader.go:42:9: undefined: validateConfig",
"why_relevant": "Last error before `go build` exited non-zero; validateConfig was renamed to validate."
}
]
}
]
}
Une fois la cause profonde identifiée, le correcteur lit les fichiers concernés, détermine la solution et implémente la modification. Il ne répare que ce qui est cassé. Il ne refactorise pas le code qui fonctionne, « n'améliore » pas les éléments qu'il remarque en cours de route et préserve le style existant.
Le correcteur renvoie le contenu complet des fichiers, un message de commit au format Conventional Commits et un court post-mortem. Il indique ce qui a aidé, ce qui a fait obstacle et ce qui manquait. Nous réinjectons ce post-mortem dans les invites (prompts), de sorte qu'une catégorie d'échec qui pose problème à l'agent aujourd'hui soit mieux gérée le mois prochain.
La pièce maîtresse — le bot de confiance évalue la sécurité de la fusion
À eux deux, ces agents génèrent bien plus de PR correctes qu'une personne ne peut en examiner et en fusionner manuellement. Pour absorber ce volume, nous avons besoin d'un moyen fiable d'identifier les modifications suffisamment sûres pour être fusionnées sans qu'un humain ait à relire chaque ligne.
Nous avons donc conçu le bot de confiance : un réconciliateur dont le seul rôle est de répondre à une question : dans quelle mesure cette PR peut-elle être fusionnée en toute sécurité avec une revue humaine minimale ? Ce bot attribue à chaque PR le niveau élevé, moyen ou faible. Cette étiquette s'appuie sur plusieurs vérifications indépendantes, afin qu'aucune d'entre elles — en particulier pas le LLM — ne puisse à elle seule faire passer une modification risquée au niveau élevé.
Le score combine une poignée de signaux déterministes et peu coûteux sur la modification — sa taille, le nombre de fichiers touchés, le niveau de risque des chemins d'accès — avec un signal issu du LLM qui lit le diff et évalue l'intention, la cohérence et la proportionnalité par rapport aux standards de la partie 1. Les signaux déterministes représentent l'essentiel du poids. Le modèle est l'élément individuel le plus lourd, mais il représente toujours moins de la moitié du total. Suffisamment pour faire varier une note à la hausse ou à la baisse, mais jamais assez pour décider seul.
Deux choix garantissent que la note peut servir de critère de validation en toute sécurité. Certains chemins ne peuvent jamais obtenir une note élevée. Toute modification touchant des zones sensibles comme l'infrastructure de production ou l'authentification est plafonnée et continue d'être soumise à une revue humaine, quel que soit l'avis du modèle. De plus, le bot est conservateur : en cas de doute, il attribue une note plus basse, car un niveau élevé attribué à tort par excès de confiance coûte bien plus cher qu'un niveau faible attribué par excès de prudence. Chaque évaluation est également auditable. Chaque PR bénéficie d'une ventilation des signaux qui ont influencé sa note, de sorte que le score n'est jamais une boîte noire.
La boucle s'auto-calibre — les retours arrière instruisent le système
Un système de notation statique dérive avec le temps. Le bot de confiance conserve donc une mémoire — un index vectoriel (RAG) des PR passées et, surtout, de ce qu'elles sont devenues : fusionnées, fermées ou annulées (revert). Avant d'évaluer une nouvelle PR, il extrait les PR passées les plus similaires. Il les transmet au réviseur LLM comme points d'ancrage de calibrage, offrant au modèle un précédent concret sur la manière dont le dépôt a réellement traité des modifications de ce type.
Les retours arrière (reverts) sont ici les plus importants. Lorsqu'une nouvelle modification ressemble à une précédente qui a été annulée, le réviseur le constate (ainsi que la raison enregistrée) et attribue une note inférieure à la nouvelle PR. L'exemple négatif joue son rôle.
C'est là que les humains bouclent la boucle. Lorsqu'un ingénieur annule une PR fusionnée automatiquement et en explique la raison, le bot relie le retour arrière à l'original et enregistre cette raison aux côtés du résultat négatif. Un retour arrière explicité apporte le plus de signal : le réviseur voit à la fois qu'une modification similaire a été annulée et pourquoi. Un retour arrière sans motif reste comptabilisé comme un élément négatif, mais c'est l'explication qui permet réellement d'améliorer les évaluations futures.
Le seul acteur qui fusionne est déterministe
Voici la limite que nous ne franchissons jamais : le score de confiance est consultatif. Le bot qui effectue la fusion est un bot approbateur distinct et déterministe — pas de modèle, pas de jugement, uniquement des règles de politique. Et son déclenchement est conditionné par deux critères qui doivent impérativement être réunis :
Une note
élevéeliée au SHA exact du commit. C'est là toute la subtilité. L'étiquette de niveau est persistante — elle reste sur la PR au fil des nouveaux pushs jusqu'à ce que le bot la réévalue — donc une étiquette seule pourrait permettre à une note calculée pour un ancien commit valide de cautionner un nouveau commit défaillant. Au lieu de cela, la note est également publiée sous la forme d'une exécution de vérification (check run) sur le commit de tête. Une exécution de vérification est circonscrite au SHA pour lequel elle a été créée ; un nouveau commit n'a pas de note tant que le bot ne l'a pas réévalué. Une note obsolète ne peut matériellement pas laisser passer un commit défaillant.Toutes les vérifications de CI requises sont au vert sur ce même commit.
Ce n'est que lorsque ces deux conditions sont remplies que l'approbateur fusionne.
Un standard est rédigé et testé une seule fois, les agents l'appliquent et évaluent le résultat, et une politique déterministe procède à la fusion. L'IA se charge du jugement ; la fusion elle-même n'est qu'un contrôle portant sur un SHA de commit et une CI au vert. C'est ce qui permet à l'ensemble de la boucle de tourner sans intervention humaine obligatoire.
Ce que cela donne en production : les chiffres
Au cours des 8 dernières semaines, sur l'ensemble de nos dépôts, skillup a ouvert 4 746 pull requests de correction de standards. Le bot de confiance — que nous avons déployé au milieu de cette période — en a évalué 3 044 jusqu'à présent ; seules celles à faible risque sont éligibles à la fusion automatique. Sur 1 117 d'entre elles, il en a jugé 840 (75,2 %) comme étant à faible risque et les a fusionnées sans aucune intervention humaine.

Nous nous attendons à ce que ce taux de 75 % continue de progresser, sur les deux tableaux. Le bot de confiance gagne en efficacité à mesure qu'il tourne : il apprend de son propre historique d'évaluation et du devenir des PR qu'il a notées. Les retours arrière apportent le signal le plus fort. Une fusion qui reste en place ne confirme que faiblement la justesse d'une note, mais une fusion automatique annulée est la preuve concrète qu'une modification jugée sûre ne l'était pas. Le bot garde ces cas en mémoire et évalue les modifications similaires avec plus de prudence la fois suivante. Un meilleur calibrage signifie qu'une plus grande part des PR à faible risque peut être fusionnée de manière autonome, et l'objectif à court terme est d'en fusionner 100 % automatiquement. Dans le même temps, nous ajoutons davantage de vérifications déterministes à la CI. Chaque nouvelle vérification capable de garantir une catégorie de modifications permet dès le départ de classer davantage de PR dans la catégorie à faible risque. La part des modifications que la boucle peut intégrer en toute sécurité continue de croître sur ces deux axes.
Au-delà du monorepo et des standards
Nous avons conçu cela pour le monorepo de notre plan de contrôle, mais rien n'y est spécifique à une architecture monorepo. Les mêmes réconciliateurs et agents fonctionnent également sur nos dépôts du plan de données, en leur appliquant les mêmes standards et en fusionnant les modifications sûres de la même manière. Un standard rédigé s'étend à chaque dépôt surveillé par le parc, et pas seulement à un seul.
Et les standards ne représentent qu'une infime partie de ce que réalise le parc. Les trois compétences évoquées dans cet article — go-standards, gha-standards, go-security-review — font partie de près de 100 compétences sur lesquelles s'appuient les agents ; la plupart n'ont aucun rapport avec le style de code. Elles intègrent le packaging à travers une douzaine de langages, la correction de CVE, la création et le test d'images, et bien plus encore. Le réviseur, le correcteur, le LogAnalyzer, le juge et le système de notation de confiance sont des briques de base génériques de DriftlessAF ; à travers la Chainguard Factory, les mêmes composants effectuent l'ensemble de ces tâches. La boucle présentée dans cet article illustre le modèle, non sa limite.
Remerciements
Rien de tout cela n'est le fruit d'une seule personne. Merci à tous les formidables talents de l'ingénierie de Chainguard : Taylor Bloom, Joe Borg, Jonathan Lange, James Rawlings, Matt Moore et bien d'autres, pour leur collaboration sur ces agents — leur développement, leur déploiement et les pipelines de données sous-jacents qui nous permettent de mesurer leur activité. Maintenir notre base de code aux normes sur de multiples dépôts est un travail d'équipe à l'échelle de toute l'ingénierie, et cela ne cesse de s'améliorer grâce aux personnes qui le rendent possible.
Contactez-nous si vous souhaitez en savoir plus sur le fonctionnement de nos agents et sur la façon dont les solutions de Chainguard peuvent vous aider.
Share this article
Articles connexes
ingénierieHelp! I need somebody! --help, not just anybody! Every tool that never had a manual page
ingénierieCI in 2027: Why the future of coding needs instant back-pressure
ingénierieGitHub Actions down? No problem. Green with Chainguard Checks.
ingénierieIt’s a man’s, man’s, man’s world: Every manual page in Chainguard OS, now readable by your agent
ingénierieThis Shit is Hard: Nobody has ever been pwned by Helvetica…or have they?
ingénierieThis Shit is Hard: Building a vulnerability database from private reports