- Accueil
- Centre d'apprentissage
- Qu'est-ce que la revue de code par IA ?
Qu'est-ce que la revue de code par IA ?
Mis à jour le
La revue de code par IA utilise un modèle de langage pour lire un changement de code et signaler bugs, risques et lacunes. Ce qu'elle détecte, ce qu'elle manque, et comment en faire une barrière.
Sur cette page
- Comment fonctionne la revue de code par IA
- Ce que la revue par IA fait bien, et là où elle échoue
- Revue de code par IA et revue de code humaine
- Relire du code écrit par une IA
- Transformer la sortie de la revue en décision
- Comment mettre en place la revue de code par IA
- Comment AI CodeOps s'y prend
- Pour aller plus loin
La revue de code par IA consiste à utiliser un grand modèle de langage pour lire un changement de code, généralement le diff d'une pull request, et y signaler des problèmes : bugs, risques de sécurité, tests manquants et code difficile à maintenir. Elle est rapide, elle s'exécute sur chaque changement, et elle remarque un autre éventail de problèmes que les personnes. Elle lit du texte plutôt qu'un système en cours d'exécution et peut se tromper avec aplomb ; elle fonctionne donc au mieux comme une première passe structurée dont les constats alimentent une barrière et un relecteur humain, et non comme un substitut à l'un ou à l'autre.
Comment fonctionne la revue de code par IA
Un relecteur IA, c'est un prompt, un modèle et un peu de contexte. C'est le contexte qui détermine son utilité.
- Le diff. Les lignes ajoutées et supprimées constituent l'entrée principale. Un relecteur qui ne voit que le diff manque les effets sur le code qu'il ne voit pas.
- Le code environnant. Les meilleurs relecteurs intègrent les fichiers que touche le changement, leurs appelants et les tests associés, dans la limite de la fenêtre de contexte du modèle.
- L'intention. Le ticket, la description de la tâche ou le texte de la pull request indiquent au modèle ce que le changement est censé faire, pour qu'il repère le code qui fait autre chose.
- Les conventions. Les guides de style, les notes d'architecture et les décisions antérieures lui permettent de signaler les écarts par rapport au fonctionnement habituel de la base de code.
La sortie prend deux grandes formes. Certains outils publient des commentaires en texte libre sur des lignes de la pull request, comme un relecteur humain. D'autres renvoient des constats structurés : chaque problème avec un titre, une gravité, une catégorie, un fichier et une ligne, et un correctif recommandé. Le texte libre est agréable à lire. Les constats structurés peuvent être comptés, filtrés, triés et servir à prendre une décision.
La revue varie aussi selon ce que le relecteur est capable de faire. Un prompt unique sur le diff en est la forme la plus simple. Un relecteur agentique peut ouvrir d'autres fichiers, chercher dans le dépôt ou exécuter des outils avant de répondre. Une revue en plusieurs passes exécute plusieurs prompts, par exemple un pour l'exactitude, un pour la sécurité et un pour la couverture de tests, puis fusionne leurs résultats.
Ce que la revue par IA fait bien, et là où elle échoue
La revue par IA mérite sa place par sa constance. Elle lit chaque ligne de chaque changement avec la même attention, y compris la 600e ligne d'un gros refactoring et le changement poussé à la fin d'une longue journée. Elle est efficace pour :
- les erreurs de logique locales : valeurs null non vérifiées, boucles décalées d'une itération (off-by-one), conditions inversées, erreurs non gérées et await manquants ;
- les motifs de sécurité courants : requêtes SQL ou commandes shell construites par concaténation de chaînes, validation des entrées absente, secrets dans le code, désérialisation non sûre et contrôles d'autorisation manquants sur un nouveau point de terminaison ;
- les écarts entre le code et les tests, comme une nouvelle branche qu'aucun test n'exerce ;
- les problèmes de nommage, de duplication et de lisibilité que les personnes cessent de signaler parce qu'ils leur semblent mesquins.
Ses échecs sont prévisibles :
- Aucun contexte métier. Elle ignore qu'un champ est légalement obligatoire, qu'un client dépend d'un comportement étrange, ou que l'équipe a accepté un compromis le trimestre dernier.
- Aucune vue de l'exécution. Elle raisonne sur du texte. Les situations de concurrence (race conditions), les performances sous charge réelle et la configuration qui n'existe qu'en production lui restent en grande partie invisibles.
- Faux positifs. Elle signale des problèmes qui n'existent pas, parfois avec une explication convaincante. Les relecteurs qui en voient trop cessent de lire.
- Non-déterminisme. Le même diff peut produire des constats différents sur deux exécutions.
- Contexte limité. Les effets qui traversent de nombreux fichiers, ou qui se situent loin dans les dépendances, peuvent sortir de ce qu'on lui a fourni.
- Entrées non fiables. Le diff lui-même peut contenir du texte destiné au modèle, comme un commentaire qui affirme au relecteur que le code est sûr. C'est de l'injection de prompt, et un relecteur doit être conçu pour y résister.
Revue de code par IA et revue de code humaine
Les deux sont complémentaires. Chacune couvre un terrain que l'autre traite mal.
| Aspect | Revue de code par IA | Revue de code humaine |
|---|---|---|
| Rapidité | De quelques secondes à quelques minutes, sur chaque changement | De quelques heures à quelques jours, selon les disponibilités |
| Constance | Même profondeur sur chaque ligne et chaque changement | Varie selon la fatigue, la taille du changement et la familiarité |
| Intention et contexte | Seulement ce qui figure dans le prompt et les fichiers fournis | Connaît le produit, les utilisateurs et les décisions passées |
| Jugement de conception | Faible pour juger si c'est bien le changement à faire | Fort, surtout chez les personnes responsables du domaine |
| Connaissance de l'exécution | Aucune au-delà de ce que dit le code | Expérience du comportement du système en production |
| Faux positifs | Fréquents ; nécessitent un tri | Plus rares, mais les avis divergent entre relecteurs |
| Responsabilité | Aucune ; un modèle ne peut pas assumer une décision | Une personne nommée qui a approuvé le changement |
| Partage des connaissances | Faible ; elle n'apprend pas les habitudes de votre équipe | Diffuse la compréhension du code dans l'équipe |
Les deux dernières lignes comptent le plus. La revue est en partie un contrôle, et en partie la façon dont une équipe garde une propriété partagée de son code. La revue par IA peut prendre en charge une grande partie du premier rôle, mais pas du second.
Relire du code écrit par une IA
Lorsque l'auteur est lui-même un agent IA, la revue devient plus importante et un peu différente.
Le volume augmente. Les agents produisent rapidement du code qui fonctionne, et les personnes ne peuvent pas lire chaque ligne de chaque changement avec le même soin. La sortie de la revue doit être hiérarchisée par gravité, pour qu'une personne puisse consacrer son attention aux quelques problèmes qui comptent.
L'indépendance compte. Un modèle à qui l'on demande de vérifier sa propre production a tendance à répéter ses propres hypothèses. Une passe de revue distincte, avec son propre prompt et idéalement exécutée une fois le code écrit plutôt que sur le plan, a plus de chances de détecter ce que l'auteur a manqué.
Ce qui est relu doit être le diff réel. Dans de nombreux workflows d'agents, la planification et la discussion ont lieu avant l'écriture du code. Relire un plan est utile, mais ce n'est pas une revue du changement. Les constats qui décident si le code est livré doivent provenir de la lecture du code qui sera livré.
Transformer la sortie de la revue en décision
Une liste de commentaires n'est qu'un conseil. Pour que la revue par IA fasse partie de votre façon de livrer, sa sortie doit déterminer une décision, et cela exige quelques règles :
- Des constats structurés avec un ensemble fixe de gravités, comme critical, high, medium, low et info, et des catégories comme security, quality ou test coverage.
- Un seuil bloquant. Par exemple, les constats ouverts de gravité high ou critical bloquent le changement.
- Des états de tri. Une personne peut marquer un constat fixed, won't fix, false positive ou duplicate (corrigé, ne sera pas corrigé, faux positif ou doublon), et cette décision est enregistrée avec son nom.
- Rester fermé en cas d'erreur. Si la revue a planté, a dépassé le délai ou a renvoyé quelque chose d'illisible, le changement n'a pas été relu. Une revue manquante ne doit jamais compter comme une revue au vert.
- Une trace. Les constats soulevés, qui les a écartés et pourquoi, conservés avec le changement.
C'est ce qui fait de la revue l'une des entrées d'une barrière qualité.
Comment mettre en place la revue de code par IA
- Choisissez le périmètre. Commencez par les dépôts ou les types de changements où un second lecteur apporte le plus, comme les services qui gèrent de l'argent, l'authentification ou des données personnelles.
- Exigez une sortie structurée. Demandez des constats avec gravité, catégorie, fichier et recommandation, dans un format que vos outils peuvent analyser. Rejetez les réponses qui ne s'analysent pas.
- Fixez la gravité bloquante. Ne soyez strict au départ que sur les constats high et critical. Abaissez le seuil plus tard si le taux de faux positifs le permet.
- Définissez le tri. Décidez qui peut écarter un constat et quels états mettent fin à son effet bloquant. Enregistrez chaque changement d'état.
- Traitez une revue en échec comme un blocage. Les dépassements de délai, les erreurs du modèle et les réponses illisibles retiennent le changement jusqu'à ce que la revue soit relancée.
- Gardez une approbation humaine. La revue par IA éclaire la personne qui approuve. Elle ne la remplace pas, et l'auteur d'un changement ne doit pas l'approuver seul.
- Mesurez et ajustez. Suivez combien de constats sont corrigés et combien sont écartés comme faux positifs. Ajustez les prompts, le contexte et les seuils à partir de ces chiffres, pas d'impressions.
- Conservez la trace. Stockez les constats et les décisions de tri avec le changement, pour qu'un auditeur ou un futur mainteneur puisse voir pourquoi il a été livré.
Comment AI CodeOps s'y prend
AI CodeOps relit en deux couches chaque changement de code produit par ses propres sessions IA. Des agents de revue à l'intérieur du workflow, comme les agents Reviewer et Security Auditor, examinent le changement sous différents angles. Une étape de revue qui suit l'étape d'implémentation du changement s'exécute une fois le code écrit et testé, et reçoit le diff et le résultat de test enregistré. Ensuite, une revue des constats distincte lit le même diff, avec les notes de revue précédentes comme contexte. Seule cette seconde couche produit les constats qui peuvent bloquer le changement. Les étapes d'un workflow s'exécutent l'une après l'autre ; rien n'est décidé par un vote.
La revue des constats doit répondre par un tableau JSON, et chaque élément devient un constat :
[
{
"title": "Coupon code is passed to the pricing query without validation",
"severity": "high",
"category": "security",
"description": "applyCoupon() forwards the raw request value to the discount lookup.",
"recommendation": "Validate length and characters before the lookup and return 400 on a bad code.",
"filePath": "src/api/checkout.ts"
}
]
Une revue enregistre au maximum 12 constats. Un tableau vide signifie que rien n'a été trouvé. Une réponse qui n'est pas un tableau lisible, une revue qui échoue, ou une revue qui manque de temps ou de budget, marque l'exécution comme non relue, et le changement est retenu jusqu'à ce qu'elle soit relancée.
Les constats ouverts de gravité high ou critical, dans les états open, acknowledged ou in progress, bloquent la pull request et la fusion depuis la console. Marquer un constat fixed, won't fix, false positive ou duplicate met fin à son blocage, et le tri est enregistré. Une personne approuve ensuite le changement, et la personne qui a lancé la session ne peut pas donner ce vote tant que quelqu'un d'autre dans l'espace de travail peut approuver. Un job de CI peut interroger la même barrière à propos d'une pull request via /api/release/check et définir blockingSeverity sur medium pour bloquer aussi sur les constats medium.
La revue ne couvre que les changements réalisés via des sessions AI CodeOps, pas toutes les pull requests de votre dépôt. Consultez Revue de code par IA pour la présentation du produit, Revues multi-agents pour l'articulation des passes, et Barrières qualité pour le tri et la barrière complète.
Pour aller plus loin
- Comment gérer les faux positifs de la revue de code par IA : pourquoi les relecteurs IA signalent des problèmes qui n'existent pas, et comment trier les constats et ajuster le relecteur sans masquer de vrais bugs.
- Comment relire du code écrit par un agent IA : ce qu'il faut lire avant le code, les erreurs que commettent souvent les agents de codage, et comment garder tout leur sens aux approbations.
Questions fréquentes
La revue de code par IA peut-elle remplacer les relecteurs humains ?
Non. C'est une première passe rapide et constante, mais elle ne connaît ni votre intention ni vos utilisateurs, et elle peut se tromper avec aplomb. Une personne doit toujours approuver ce qui est livré.
La revue par IA doit-elle bloquer une fusion ?
Seulement selon des règles claires. Bloquez sur les constats ouverts au-dessus d'une gravité donnée, laissez des personnes trier les faux positifs, et traitez une revue qui n'a pas pu s'exécuter comme un blocage, pas comme une réussite.
Pourquoi le même diff reçoit-il des commentaires de revue par IA différents d'une exécution à l'autre ?
Les modèles de langage ne sont pas entièrement déterministes, et de petites variations du contexte changent ce qu'ils remarquent. Une sortie structurée et un seuil de gravité fixe rendent le résultat plus facile à exploiter.
Le modèle qui a écrit le code peut-il le relire ?
Il le peut, mais il a tendance à partager ses propres angles morts. Une passe de revue distincte sur le diff réel, avec un autre prompt ou un autre modèle, est plus indépendante que de demander à l'auteur de se vérifier lui-même.
Le code envoyé à un relecteur IA est-il à l'abri de l'injection de prompt ?
Pas automatiquement. Les commentaires, les chaînes et les documents du diff sont des entrées non fiables qui peuvent tenter d'orienter le modèle ; le relecteur ne doit donc avoir aucun accès en écriture, et son verdict doit alimenter une barrière contrôlée par une personne.