← Retour au blog
AiEnviron 8 min de lecture

Le relecteur de code d'Alibaba applique d'abord des règles déterministes et interroge le modèle ensuite

Publié le 14 nov. 2026
Le relecteur de code d'Alibaba applique d'abord des règles déterministes et interroge le modèle ensuite

Un agent de code généraliste à qui l'on demande de relire un gros changeset se comporte comme une personne chargée de corriger un livre pour vendredi. Elle commence avec application, trouve son rythme, et quelque part au chapitre quatre, elle se met à survoler. Résultat : une revue qui couvre sérieusement le premier tiers du diff, mentionne deux choses au milieu et déclare le reste propre.

Open Code Review, qu'Alibaba a ouvert ce mois-ci après deux ans d'usage interne et qui approche les 51,000 étoiles sur GitHub, part d'un constat : cet échec tient à l'architecture, et retoucher le prompt n'y changera rien.

Trois échecs que l'équipe nomme

Le README est d'une franchise rare sur ce qui cloche dans l'approche agent généraliste.

La couverture incomplète vient en premier. Sur les gros changesets, l'agent relit certains fichiers et en oublie d'autres, et rien dans une boucle pilotée par le langage ne garantit que chaque fichier sera examiné.

La dérive de position vient ensuite. Les problèmes signalés ne correspondent souvent pas à l'emplacement réel du code, les numéros de ligne et les références de fichier glissent. Quiconque a essayé d'appliquer les commentaires d'un agent connaît ça : le commentaire a raison sur le bug et tort sur l'endroit.

La qualité instable vient en troisième. Les compétences en langage naturel sont difficiles à déboguer, et la qualité de revue bouge nettement avec de petites variations de prompt. L'outil devient impossible à certifier et difficile à placer dans un garde-fou.

Le diagnostic en une phrase : une architecture purement pilotée par le langage n'impose aucune contrainte dure au processus.

Ce qu'il a sorti du modèle

La conception répartit le travail. Tout ce qui ne doit pas se tromper est confié à du code ordinaire. Tout ce qui demande du jugement va à l'agent.

La sélection des fichiers est déterministe. Le code décide quels fichiers entrent dans le périmètre et lesquels sont écartés, donc rien d'important n'est sauté pour une raison que le modèle ne saurait expliquer.

Le regroupement est déterministe. Les fichiers liés forment une seule unité de revue, et l'exemple du README est le bon : `message_en.properties` et `message_zh.properties` vont ensemble, parce qu'une clé ajoutée d'un côté et oubliée de l'autre est exactement le bug qu'un relecteur fichier par fichier manque. Chaque lot tourne comme un sous-agent au contexte isolé, ce qui explique la stabilité sur les changesets géants et le parallélisme sans coordination.

La correspondance des règles est déterministe. Les règles sont associées aux caractéristiques de chaque fichier via un moteur de templates, au lieu d'être décrites en prose avec l'espoir que le modèle s'en souvienne. L'avantage annoncé : l'attention du modèle reste sur les règles applicables, sans parcourir un manuel entier.

Deux modules vivent entièrement hors de l'agent : l'un positionne les commentaires, l'autre les réexamine. Les deux existent parce qu'un modèle qui écrit un commentaire n'est pas fiable sur l'endroit où il atterrit, et lui faire vérifier son propre placement marche mieux en passe séparée qu'en instruction dans le prompt principal.

L'agent garde les parties qui demandent une décision : quel contexte aller chercher, quels outils appeler, comment formuler un constat. Son jeu d'outils a été distillé à partir de traces d'appels de production chez Alibaba, distributions de fréquence et taux de répétition compris, une base plus empirique que l'habituelle supposition sur ce dont un relecteur aurait besoin.

Les chiffres, et le compromis qu'ils contiennent

Le benchmark s'appelle AACR-Bench : 50 dépôts open source populaires, 200 pull requests réelles, 10 langages de programmation, plus de 80 ingénieurs seniors et 1,505 problèmes annotés comme référence.

Face à un agent généraliste utilisant le même modèle sous-jacent, Alibaba annonce une précision et un F1 nettement supérieurs, environ un neuvième des tokens et une exécution plus rapide. Le rappel est plus faible.

Cette dernière proposition est la phrase la plus honnête du README, et elle change à qui l'outil s'adresse.

La précision, c'est la part de vrais problèmes parmi ceux signalés. Le rappel, la part de défauts réels qui sont trouvés. Un relecteur réglé sur la précision parle peu et tombe juste. Un relecteur réglé sur le rappel fait du bruit et trouve davantage.

Pour un garde-fou CI sur un dépôt actif, la précision est la bonne cible. Un bot qui commente quarante fois sur une pull request contenant onze vrais problèmes est mis en sourdine en une semaine, et un bot muet a un rappel nul, quel que soit son score au benchmark. L'équipe a fait le compromis qui garde l'outil allumé.

Pour un audit de sécurité sur du code inconnu, le compromis est mauvais. On veut le relecteur bruyant. D'où `ocr scan`, un mode séparé qui relit des fichiers entiers au lieu d'un diff, et d'où la lecture de la priorité à la précision comme une affirmation sur les pull requests, pas comme un verdict sur la revue de code en général.

L'installer

L'outil est un CLI nommé `ocr`.

npm install -g @alibaba-group/open-code-review
ocr config provider
ocr config model

La configuration passe par le choix du fournisseur, la saisie de la clé et un test de connectivité. Ensuite, depuis un dépôt :

ocr review                                    # staged, unstaged, untracked
ocr review --from main --to feature-branch    # merge-base range
ocr review --commit abc123
ocr scan --path internal/agent                # whole files, no git history needed
ocr review --format json --output result.json

Les revues longues peuvent être interrompues et reprises avec `ocr session list` et `--resume`, ce qui compte dès qu'on pointe l'outil vers un monorepo. Il existe une visionneuse de session dans le navigateur pour rejouer une revue et marquer les commentaires comme corrigés ou ignorés.

La décision de conception que je trouve la plus intéressante est le mode delegation. En mode par défaut, OCR appelle lui-même le modèle avec sa propre configuration de fournisseur, distincte de votre abonnement Claude Code. En mode delegation, OCR fait toujours la sélection des fichiers et la résolution des règles, et confie la revue réelle au modèle et à l'authentification de votre agent de code. Pas de clé API séparée.

C'est une lecture nette de l'endroit où se trouve la valeur. L'échafaudage est le produit. Le modèle est une marchandise que vous payez peut-être déjà.

Pourquoi cela dépasse la revue de code

Retirez le décor, et l'architecture est une réponse générale à un problème général : les modèles de langage sont peu fiables pour un travail exhaustif, ordonné et précis en position sur de grandes entrées, et fiables pour juger dans un contexte borné.

Tous les pipelines de contenu que j'ai vus échouer ont échoué de la même façon. Un agent chargé de vérifier vingt visuels produit sur la conformité de marque en contrôle onze et rédige un résumé confiant. Un agent chargé de localiser quarante chaînes en saute quatre et annonce un succès. La défaillance porte sur la couverture, et la couverture est précisément ce qu'apporte une couche déterministe.

Le schéma à reprendre, c'est la séparation : énumérer dans le code, juger dans le modèle, puis vérifier à nouveau la position de la sortie dans le code. Alibaba l'a appliqué aux diffs. Les mêmes trois étapes valent pour un dossier d'assets générés, un lot de pages traduites ou un tableur de déclarations.

Il y a un coût, et c'est la raison pour laquelle la plupart des équipes ne le font pas. L'échafaudage déterministe s'écrit domaine par domaine. Les règles de regroupement pour des fichiers properties Java ne servent à rien sur un dossier de visuels produit, et le module de réflexion qui corrige le placement des commentaires n'a pas d'équivalent dans un pipeline de traduction. L'ingénierie ne se transfère pas. Le schéma, si.

Ce que je vais surveiller

Deux choses sur le prochain trimestre.

Le jeu de règles restera-t-il à jour. Un moteur de règles à templates est stable justement parce qu'il est explicite, et les règles explicites vieillissent. La règle qui attrape un motif de NPE dans du code Java 17 peut être du bruit dans du Java 25. La stabilité obtenue par le codage en dur a une facture de maintenance.

Et la priorité à la précision tiendra-t-elle hors du code d'Alibaba. Un relecteur réglé sur dix ans de conventions internes paraîtra affûté sur ces conventions. La question ouverte, et la communauté y répondra vite, est son comportement sur du code écrit par des gens qui n'ont jamais lu le même guide de style.

Articles associés