Avec l'utilisation croissante des outils de codage basés sur l'IA , les bases de code sont devenues plus vulnérables, d'où la nécessité accrue de revues de code efficaces. Pour répondre à ce besoin, nous présentons RevEval (AI Code Review Eval), qui compare les performances des quatre principaux outils de revue de code basés sur l'IA sur 309 requêtes de fusion provenant de dépôts de tailles variées et évalue leur efficacité à l'aide des retours de 10 développeurs et d'un juriste titulaire d'un master en droit (LLM) faisant office de juge.
Résultats de référence
CodeRabbit s'est classé comme l'outil de revue de code le plus performant dans 51 % des 309 demandes de tirage :
Pour établir le classement, nous avons utilisé les scores attribués par notre équipe d'experts en droit (LLM-as-a-jugement). Nous avons examiné quel outil d'analyse de code IA avait obtenu le meilleur score dans chaque PR (score attribué par notre équipe LLM-as-a-jugement), puis calculé le pourcentage de toutes les PR dans lesquelles chaque outil était classé premier.
CodeRabbit a obtenu les meilleurs résultats lors des évaluations manuelles réalisées par des humains et lors des évaluations par des LLM en tant que juges, suivi par Greptile et GitHub Copilot :
Pour le calcul du score moyen, les trois catégories d'évaluation ont été pondérées de manière égale. Les scores des grands et des petits dépôts ont été évalués par LLM-as-judge, et les évaluations des développeurs ont été complétées manuellement afin de vérifier les scores de LLM-as-judge.
Évaluations humaines
Nous avons demandé aux développeurs ayant participé aux évaluations quel outil d'analyse de code par IA ils souhaiteraient intégrer à leurs flux de travail. Les directeurs techniques jouant un rôle décisionnel clé dans le développement logiciel, nous avons mis en évidence leurs réponses dans un graphique distinct :
Comparaison détaillée
Nous avons calculé le nombre moyen de bogues par PR en comptabilisant tous les bogues/problèmes signalés par chaque outil d'analyse de code et en divisant ce nombre par le nombre total de PR (309). Toutes les PR de notre base de code ne contiennent pas de bogues ou de problèmes. GitHub Copilot ne signale pas explicitement la détection de bogues dans une PR ; il a donc été exclu de cette comparaison.
Vous pouvez consulter notre méthodologie ci-dessous.
Caractéristiques
Ce service est assuré par la fonctionnalité « vérifications pré-fusion automatiques » de CodeRabbit. Elle valide automatiquement les demandes de fusion (pull requests) en fonction des normes de qualité et des exigences organisationnelles spécifiques avant leur fusion, et renvoie un résultat (réussite/échec) accompagné d'explications directement dans la présentation de la demande de fusion. Chaque vérification peut être configurée pour avertir les développeurs ou bloquer complètement les fusions. Bien que GitHub Copilot, Cursor BugBot et Greptile proposent des fonctionnalités de révision des demandes de fusion, ils fonctionnent comme des systèmes de conseil fournissant des commentaires et des suggestions plutôt que comme des cadres de validation systématiques.
** Cursor et GitHub Copilot peuvent offrir davantage de fonctionnalités que leurs composants de revue de code ; seules les fonctionnalités de Cursor Bugbot et de GitHub Copilot Code Review sont incluses dans notre comparaison.
Les fonctionnalités varient selon les formules d'abonnement ; certaines fonctionnalités indiquées comme disponibles ci-dessus peuvent ne pas l'être dans votre abonnement.
Dans le cadre des revues de code automatisées, CodeRabbit, GitHub Copilot et Cursor Bugbot étaient plus faciles à configurer que Greptile, car les revues de code automatisées ne peuvent pas être activées pour un dépôt vide dans Greptile.
Analyse approfondie des fonctionnalités
CodeRabbit
- Plus de 40 analyseurs de code et scanners de sécurité intégrés.
- Instructions personnalisées basées sur des modèles AST.
- S'adapte au fil du temps en fonction des retours des développeurs.
- Les développeurs peuvent mentionner @coderabbitai pour poser des questions de suivi, demander des corrections ou formuler des recommandations.
- Prend en charge les serveurs MCP personnalisés pour un contexte supplémentaire.
Analyse de code GitHub Copilot
- Le bouton « Implémenter la suggestion » transmet le relais à l’agent de codage Copilot.
- Intégration étroite avec l'écosystème GitHub.
- Instructions personnalisées via copilot-instructions.md.
Greptile
- Apprend les normes de codage de l'équipe à partir de l'historique des commentaires des demandes de fusion.
- Grâce aux dépôts modèles, les développeurs peuvent référencer des dépôts connexes dans greptile.json afin de fournir un contexte supplémentaire.
- Les développeurs peuvent répondre avec @greptileai pour toute question complémentaire ou suggestion de correction.
- Greptile tire des enseignements des commentaires positifs/négatifs.
- Diagrammes de séquence générés automatiquement pour toutes les PR.
BugBot de curseur
- Une fois qu'un bug est identifié par BugBot, les développeurs peuvent utiliser le bouton « Corriger dans le curseur » pour ouvrir rapidement le curseur et corriger le bug.
- Les développeurs peuvent personnaliser leurs règles de revue de code dans les fichiers BUGBOT.md.
Nous avions également prévu d'évaluer les performances de Graphite ; cependant, en raison d'un bug dans leur tableau de bord, nous n'avons pas pu activer les revues de code automatisées pour les nouveaux dépôts. Nous avons contacté leur équipe de support le 25 octobre 2025, mais leur réponse n'a pas permis de résoudre le problème. Malgré des relances par e-mail et un message sur leur canal Slack, le problème persiste.
Composants et intégrations
Toutes ces solutions sont compatibles avec GitHub.
Méthodologie
Nous avons créé des référentiels de référence distincts pour chaque outil au sein de notre organisation GitHub dédiée.
Après avoir activé les revues de code automatiques pour chaque outil dans son dépôt respectif, nous avons ouvert des demandes de fusion successivement, attendu la fin de la revue, puis fermé les demandes pour consigner les résultats. Nous n'avons modifié aucun paramètre d'outil. Chaque outil a été évalué avec sa configuration par défaut, telle qu'installée.
Notre flux de travail commence par le clonage du dépôt source tel qu'il existait à une date de référence sélectionnée, puis par la réexécution des demandes d'extraction soumises après cette date, en préservant la structure originale du dépôt.
Nous avons utilisé les versions de novembre 2025 de tous les produits. Notre banc d'essai comprenait deux ensembles différents de référentiels de code source :
1. Des dépôts de taille moyenne à grande et bien connus
Notre objectif était d'évaluer la capacité des outils d'analyse de code par IA à comprendre les dépôts présentant des structures vastes et complexes. Au total, 289 demandes de tirage ont été analysées dans 7 dépôts.
2. Petits et nouveaux dépôts
Nous sommes conscients que nous ne pouvons pas nourrir notre LLM-en-tant-que-juge avec le
Dans les grands dépôts, l'intégralité du dépôt n'était pas prise en compte, car leur fenêtre de contexte était insuffisante. Par conséquent, pour pallier ce problème, nous avons également évalué les 3 à 5 premières demandes de tirage (PR) des nouveaux et petits dépôts. Les serveurs MCP répondaient parfaitement à nos besoins. Nous avons donc sélectionné 8 serveurs MCP officiels et y avons fait examiner 20 demandes de tirage.
Notre ensemble de données contient du code écrit par des développeurs expérimentés. Nous n'avons pas évalué les performances sur des bases de code entièrement générées par l'IA.
Évaluations des développeurs
Nous avons sélectionné aléatoirement 35 demandes de fusion et les avons attribuées à 10 développeurs. Chaque demande a été évaluée 5 fois par les développeurs. Cette évaluation répétée visait à minimiser les biais des développeurs, qui ont évalué les résultats de manière indépendante de tout fournisseur.
La plupart d'entre eux sont parvenus aux mêmes conclusions de haut niveau :
- Les analyses détaillées de CodeRabbit sont utiles et son outil de détection des bugs est efficace.
- Greptile a fourni des résumés pertinents, mais les diagrammes de séquence qu'il a générés ne sont pas nécessaires pour certaines demandes de fusion.
Figure 1 : Exemple de diagramme de séquence fourni par Greptile. Greptile génère les diagrammes pour chaque PR. 1
- GitHub Copilot est très performant pour détecter les fautes de frappe dans le code et fait des suggestions très pertinentes ; son analyse est plus courte que celles de CodeRabbit et Greptile.
- Cursor Bugbot fournit une analyse moins détaillée et moins précise.
Suite à ces évaluations, ils ont également déclaré qu'ils commenceraient à les utiliser dans leurs propres dépôts comme outil de support pour les développeurs.
LLM-en-tant-que-juge
Nous avons utilisé GPT-5 pour évaluer les avis. Après l'évaluation, nous avons utilisé GPT-4o pour structurer le résultat au format JSON.
Notre processus d'évaluation comprend :
- Pour les grands dépôts : le corps original de la PR, le diff et les commentaires/revues des outils.
- Pour les petits dépôts : l’intégralité du code source, le corps original de la PR, les différences et les commentaires/revues des outils.
Voici le texte intégral que nous avons utilisé :
Évaluez chaque outil selon ces dimensions (échelle de 1 à 5) :
1. Exactitude
Les problèmes identifiés correspondent-ils réellement à de véritables problèmes/bugs/corrections dans le code ?
– 5 (Excellent) : Tous les problèmes identifiés sont de véritables problèmes
– 4 (Bien) : La plupart des problèmes sont réels, il s'agit de simples erreurs d'identification.
– 3 (Acceptable) : Mélange de problèmes réels et discutables
– 2 (Mauvais) : La plupart des problèmes identifiés ne sont pas de véritables problèmes.
– 1 (Échec) : Impossible d’identifier les problèmes réels, tous les résultats sont incorrects.
2. Intégrité
A-t-elle abordé les points importants ? L’analyse est-elle exhaustive ?
– 5 (Excellent) : Aborde tous les points critiques et les plus importants.
– 4 (Bien) : Détecte les problèmes majeurs, en laisse passer quelques-uns mineurs
– 3 (Acceptable) : Souligne certains points importants mais présente des lacunes notables.
– 2 (Mauvais) : Passe à côté de plusieurs points critiques
– 1 (Échec) : Ne répond pas à la totalité ou à la quasi-totalité des questions critiques
3. Capacité d'action
Les suggestions sont-elles claires et applicables ? Incluent-elles des correctifs ? Si le code ne contient aucun bogue, indiquez « null » pour l’applicabilité à tous les outils et ne donnez aucune note à cette PR.
– 5 (Excellent) : Toutes les suggestions incluent des correctifs clairs et sont directement applicables.
– 4 (Bien) : La plupart des suggestions sont accompagnées d’instructions claires, certaines incluent des correctifs.
– 3 (Acceptable) : Les suggestions sont plutôt claires, mais certaines solutions aux problèmes rencontrés sont incomplètes.
– 2 (Mauvais) : Les suggestions sont pour la plupart peu claires ou inapplicables.
– 1 (Échec) : Aucune suggestion ni indication claire fournie
4. Profondeur
Cela démontre-t-il une compréhension de la logique et de la finalité du code ?
– 5 (Excellent) : Démontre une compréhension approfondie de la logique, de l’architecture et de la finalité du code.
– 4 (Bien) : Démontre une bonne compréhension avec quelques lacunes mineures
– 3 (Acceptable) : Compréhension superficielle, manque de contexte
– 2 (Insuffisant) : Explications superficielles ou incorrectes du comportement du code
– 1 (Échec) : Aucune compréhension de la logique et de la finalité du code
Format de sortie
Pour chaque outil, veuillez fournir :
1. Raisonnement détaillé : Qu’a-t-il trouvé ? A-t-il omis des problèmes importants ? Quels correctifs ont été inclus ? Compréhension approfondie du code source ? Exemples précis.
2. Scores individuels (1 à 5 pour chaque dimension, en utilisant l'échelle ci-dessus)
Exemple de sortie
Outil A :
Raisonnement : L’outil A a démontré une excellente fiabilité en identifiant une fuite de mémoire réelle dans la logique de mise en pool des connexions à la ligne 145, et en fournissant un correctif spécifique utilisant un gestionnaire de contexte. Il a également détecté l’absence de gestion des erreurs dans le point de terminaison de l’API grâce à un code exploitable. Le score d’exhaustivité reflète le fait que, bien qu’il ait identifié des problèmes majeurs, il n’a pas détecté la condition de concurrence dans le gestionnaire asynchrone, susceptible d’entraîner des problèmes en production. Les quatre commentaires étaient pertinents et directement applicables. L’analyse approfondie était solide, témoignant d’une bonne compréhension des modèles de gestion des ressources et de la propagation des erreurs dans le code source.
Exactitude : 5
Intégrité : 4
Capacité d'exploitation : 5
Profondeur : 4
Outil B :
Raisonnement : L’outil B a correctement identifié la vulnérabilité de validation des entrées à la ligne 89 et a proposé une solution claire par la désinfection des paramètres. Cependant, son exhaustivité est fortement compromise car il n’a pas détecté la faille de sécurité critique dans le flux d’authentification qui autorise la réutilisation des jetons. La pertinence des solutions proposées est globalement satisfaisante ; des extraits de code sont inclus. La profondeur de l’analyse est acceptable mais superficielle, privilégiant les vérifications de bas niveau plutôt que la compréhension du modèle de sécurité ou des implications sur le flux de données.
Exactitude : 4
Intégrité : 1
Capacité d'exploitation : 4
Profondeur : 2
Outils à évaluer : CodeRabbit, Cursor Bugbot, Github Copilot, Greptile
Soyez objectif et rigoureux. Appuyez vos notes sur des exemples précis tirés des critiques.
Qu'est-ce que la revue de code par IA ?
L'analyse de code par IA consiste en l'analyse automatisée du code source à l'aide de modèles d'apprentissage automatique, principalement des modèles de langage à grande échelle (LLM), afin d'identifier les bogues, les inefficacités et les vulnérabilités potentielles. Outre la détection des problèmes, ces systèmes peuvent fournir des explications contextuelles, suggérer des solutions concrètes et générer des correctifs qui aident les développeurs à améliorer la qualité et la maintenabilité du code. De nombreux outils d'analyse par IA facilitent également la documentation en résumant les modifications et en produisant des commentaires ou des explications descriptives pour le code nouvellement ajouté.
Parce que les modèles d'IA peuvent évaluer le code rapidement et à grande échelle, ils accélèrent considérablement le processus de révision et facilitent la détection précoce des problèmes tout en maintenant des normes de codage cohérentes sur des projets de grande envergure ou évoluant rapidement.
Dans les environnements de développement modernes assistés par l'IA, tels que Cursor ou Claude Code, les développeurs peuvent, involontairement, perdre de vue l'évolution de leur code lorsqu'ils privilégient le « codage intuitif » ou se fient fortement aux suggestions automatiques. Cela peut engendrer des vulnérabilités cachées ou des incohérences logiques. Les outils de revue de code basés sur l'IA contribuent à atténuer ces risques en fournissant une couche supplémentaire d'analyse structurée et systématique pour valider et améliorer le code généré par l'IA.
Avantages de l'analyse de code par IA
Efficacité et rapidité
Les outils d'analyse de code par IA analysent le code en temps réel, fournissant un retour d'information immédiat et signalant les problèmes potentiels pendant que les développeurs travaillent. Ils sont capables de détecter les erreurs et les failles de sécurité que les relecteurs humains pourraient négliger, notamment dans les bases de code volumineuses ou en évolution rapide. En automatisant les vérifications de routine, ces outils permettent aux développeurs de se concentrer sur des aspects plus stratégiques, la résolution de problèmes complexes et les décisions architecturales.
Qualité du code améliorée
Les outils d'analyse de code par IA contribuent à garantir des normes de codage uniformes au sein des équipes en identifiant les incohérences stylistiques et les écarts par rapport aux bonnes pratiques. Ils fournissent également des retours et des recommandations détaillés sur un large éventail de problèmes de codage, allant des améliorations mineures aux bugs importants. Au fil du temps, les développeurs peuvent tirer des enseignements de ces retours, perfectionner leurs habitudes de codage et adopter de nouvelles techniques qui renforcent la qualité globale de leur travail.
Limites et défis
Dépendance excessive aux outils d'IA
L'une des principales préoccupations liées à la revue de code par IA est la dépendance excessive aux retours automatisés. Bien que l'IA puisse constituer une source précieuse d'informations, elle ne saurait se substituer entièrement à l'expertise humaine. Les revues automatisées peuvent accélérer les flux de travail, mais l'intervention humaine demeure essentielle pour garantir l'exactitude du code, la prise en compte du contexte et son adéquation aux objectifs du projet. Lors de notre étude comparative, les développeurs ont systématiquement affirmé qu'ils ne se fieraient pas aveuglément à ces outils. Ils les considéraient comme des assistants venant compléter le jugement humain, et non le remplacer.
Gestion des faux positifs et des faux négatifs
Les faux positifs surviennent lorsque l'outil identifie à tort du code fonctionnel comme problématique, tandis que les faux négatifs se produisent lorsque de véritables problèmes passent inaperçus. Lors de notre évaluation, le principal problème résidait dans les faux négatifs. Les outils étaient plus susceptibles de négliger des problèmes importants que de générer des alertes erronées. Ceci souligne la nécessité d'améliorer en permanence les modèles et algorithmes sous-jacents.
Pour relever ces défis, les outils d'analyse de code par IA doivent évoluer grâce à une meilleure formation, une gestion du contexte améliorée et des capacités de raisonnement plus précises.
Meilleures pratiques pour l'utilisation des revues de code par IA
Conseils d'experts
Associez les revues de code par IA aux analyses humaines : utilisez les revues de code par IA en complément des revues humaines pour garantir que le code est à la fois techniquement irréprochable et conforme aux objectifs du projet.
Personnalisez les règles en fonction de votre projet : ajustez les règles de l’outil d’IA aux normes de codage de votre projet afin de réduire les alertes inutiles.
Utilisez les retours de l'IA comme un outil d'apprentissage : considérez les suggestions de l'IA comme un moyen d'apprendre et de vous améliorer, en les discutant avec votre équipe pour comprendre pourquoi et comment éviter des problèmes similaires à l'avenir.
Remerciements
Nous adressons nos sincères remerciements aux développeurs qui ont consacré leur temps et leur expertise à la réalisation des évaluations manuelles :
Aziz Durmaz (directeur technique d'une entreprise de transport et de logistique)
Berk Kalelioğlu (co-fondateur d'un studio de développement de jeux)
Elif Ece Örnek (ingénieur logiciel sur un site Web de voyage)
Haydar Külekçi (consultant dans une entreprise spécialisée dans les technologies de recherche et l'IA)
Mehmet Sirin Can (responsable du développement chez AIMultiple)
Mehmet Korkmaz (directeur technique d'une entreprise de médias spécialisée dans l'e-sport et les jeux vidéo)
Murat Orno (ancien directeur technique d'une plateforme de paiement régionale comptant plus de 500 employés)
Orçun Candan (développeur full-stack chez AIMultiple)
Yalçın Börlü (ingénieur logiciel senior dans une entreprise du secteur de la santé et du bien-être)
Yiğit Dinç (co-fondateur d'une entreprise de technologie juridique)
Nous remercions également les développeurs et les responsables des dépôts open source inclus dans notre analyse comparative pour leur travail et leurs précieuses contributions à la communauté.
Anonymisation des identités des développeurs d'origine
Pour mener ce test de performance de manière responsable, nous avons anonymisé les noms et adresses électroniques de tous les développeurs d'origine lors de la réexécution des demandes de fusion à partir des dépôts amont. Les dépôts de test étant publics, la conservation des informations des auteurs d'origine pourrait exposer involontairement des données personnelles et exposer les développeurs au risque de les notifier à chaque ouverture ou mise à jour d'une demande de fusion recréée. Bien que GitHub n'informe généralement pas les auteurs lorsque leurs commits sont réexécutés dans un dépôt distinct, nous avons jugé préférable d'adopter cette approche afin d'éviter tout risque de notification indésirable, de problème d'attribution ou d'atteinte à la vie privée.
L'anonymisation garantit que :
- Les développeurs ne sont pas perturbés par des milliers d'événements de relations publiques automatisés.
- Les informations personnelles ne sont pas republiées dans un autre répertoire public.
- Les critères d'évaluation restent impartiaux, empêchant ainsi que les outils ou les juges des LLM ne soient influencés par des noms d'auteurs connus.
- Les normes éthiques et de confidentialité sont respectées lors de l'utilisation de contributions open source.
Seules les métadonnées d'identité ont été modifiées ; l'intégralité du code, des différences, de l'ordre des commits et des structures de fichiers a été préservée à l'identique afin de garantir l'authenticité et la reproductibilité du benchmark.
Liens de référence
Soyez le premier à commenter
Votre adresse courriel ne sera pas publiée. Tous les champs sont obligatoires.