Selon une nouvelle étude de CodeRabbit, le code généré par l'IA présente nettement plus de défauts que le code écrit par des humains dans les principales catégories de qualité logicielle. Le rapport a révélé que les pull requests générées par l'IA contiennent en moyenne environ 1,7 fois plus de problèmes que celles écrites uniquement par des humains. Il a également identifié des taux plus élevés de défauts critiques et majeurs dans le code impliquant des outils d'IA.Les assistants d'IA de codage sont censés accélérer le développement de logiciels. Les entreprises d'IA comme Microsoft affirment que leurs outils améliorent déjà la productivité des développeurs, mais les études rigoureuses indépendantes révèlent le contraire. Une étude du Model Evaluation & Threat Research rapporte que l'utilisation d'outils d'IA fait perdre du temps aux développeurs. Ils s'attendaient à une augmentation de 24 % de leur productivité, mais l'équipe a constaté un ralentissement de 19 %. Une précédente étude a révélé que l'utilisation d'outils d'IA n'augmente pas la vitesse de codage, mais augmente significativement le taux de bogues.
Selon une nouvelle étude de CodeRabbit, le code généré par l'IA présente nettement plus de défauts que le code écrit par des humains dans les principales catégories de qualité logicielle. La société de révision de code IA basée à San Francisco a analysé 470 demandes d'extraction open source sur GitHub. Elle a comparé 320 demandes d'extraction étiquetées comme co-rédigées par l'IA avec 150 soumissions rédigées uniquement par des humains. L'étude a mesuré les taux de problèmes dans des domaines tels que la logique, la maintenabilité, la sécurité, les performances et la lisibilité.
Le rapport a révélé que les pull requests générées par l'IA contiennent en moyenne environ 1,7 fois plus de problèmes que celles écrites uniquement par des humains. Il a également identifié des taux plus élevés de défauts critiques et majeurs dans le code impliquant des outils d'IA. CodeRabbit a déclaré que les modifications apportées par l'IA présentaient des problèmes accrus dans tous les domaines majeurs liés à la qualité. Les problèmes de logique et d'exactitude ont augmenté de 75 % dans le code généré par l'IA. Il s'agissait notamment d'erreurs de logique métier, de configurations incorrectes et de flux de contrôle non sécurisés.
Les vulnérabilités de sécurité sont apparues entre 1,5 et 2 fois plus souvent dans les pull requests générées par l'IA. Les problèmes de sécurité les plus courants concernaient une gestion incorrecte des mots de passe et des références d'objets non sécurisées. Les problèmes de lisibilité ont plus que triplé dans le code assisté par l'IA. Le rapport cite des niveaux plus élevés d'incohérences dans les noms et de problèmes de formatage, qui peuvent rendre le code plus difficile à comprendre et à maintenir au fil du temps.
Les inefficacités en termes de performances ont connu la plus forte augmentation relative. L'étude a révélé que des problèmes tels que des opérations d'entrée/sortie excessives apparaissaient près de huit fois plus fréquemment dans les soumissions générées par l'IA que dans les pull requests uniquement humaines.
L'un des auteurs a déclaré que ces résultats correspondaient aux préoccupations soulevées par les équipes de développement logiciel cette année. « Ces résultats confirment ce que de nombreuses équipes d'ingénieurs ont constaté tout au long de l'année 2025 », a déclaré David Loker, directeur de l'IA chez CodeRabbit. « Les outils de codage basés sur l'IA augmentent considérablement la production, mais ils introduisent également des faiblesses prévisibles et mesurables que les organisations doivent activement atténuer. »
Adoption croissante de l'IA
Cette étude intervient alors que les outils de génération de code basés sur l'IA se répandent rapidement dans l'industrie du logiciel. Plus de 90 % des développeurs déclarent désormais utiliser des outils de codage assistés par l'IA pour augmenter leur productivité et gérer les tâches routinières. Les entreprises font état des avantages de ces outils, notamment une augmentation d'environ 10 % de la productivité des ingénieurs et une réduction du temps consacré aux tâches répétitives. Les nouvelles données suggèrent que ces gains de productivité s'accompagnent d'un taux de défauts plus élevé et de nouvelles catégories de risques.
L'analyse de CodeRabbit indique que le code généré par l'IA n'ajoute pas seulement des problèmes mineurs. Selon l'entreprise, les défauts critiques et majeurs sont jusqu'à 1,7 fois plus fréquents dans les modifications apportées par l'IA que dans les demandes de modification effectuées uniquement par des humains.
Le rapport met en évidence des modèles clairs dans lesquels le code généré par l'IA présente des lacunes. Les erreurs logiques proviennent souvent d'une mauvaise compréhension des règles commerciales ou d'hypothèses incorrectes concernant la configuration et l'architecture. Les erreurs de configuration et les flux de contrôle non sécurisés augmentent le risque de comportement incorrect dans les systèmes de production.
Des problèmes de sécurité surviennent fréquemment lorsque le code généré par l'IA traite des informations sensibles. L'étude note des cas répétés de stockage ou de transmission inappropriés des mots de passe. Elle signale également des références d'objets non sécurisées qui pourraient exposer involontairement des données ou des fonctions.Les problèmes de lisibilité et de style semblent très répandus. L'incohérence des noms, le formatage irrégulier et la structure peu claire augmentent la charge de travail des réviseurs et des responsables de la maintenance. Ces problèmes peuvent ralentir la révision du code et rendre la maintenance à long terme plus complexe.
Les défauts de performance liés aux outils d'IA impliquent souvent une utilisation inefficace des ressources. Le rapport souligne que les opérations d'E/S excessives constituent un schéma récurrent, qui peut dégrader les temps de réponse et augmenter les coûts d'infrastructure lorsqu'elles sont déployées à grande échelle.
Stratégies d'atténuation
Parallèlement aux conclusions statistiques, CodeRabbit présente une série de mesures que les équipes logicielles peuvent adopter lorsqu'elles utilisent le développement assisté par l'IA. L'un des objectifs est de fournir un contexte de projet plus riche dans les invites. Selon l'entreprise, les modèles d'IA commettent davantage d'erreurs lorsqu'ils manquent d'informations sur les règles métier, les normes de configuration ou les contraintes architecturales. Elle recommande l'utilisation d'extraits de messages spécifiques au référentiel, de capsules d'instructions et de schémas de configuration qui fournissent ce contexte dès le départ.
Un autre domaine concerne le contrôle plus strict du style et du formatage du code. Le rapport note que les formateurs, les linters et les guides de style imposés par l'intégration continue peuvent éliminer de nombreux problèmes de lisibilité et de formatage avant la révision humaine. Les politiques exprimées sous forme de code dans ces outils réduisent la nécessité d'appliquer manuellement les normes.
CodeRabbit préconise également des contrôles plus stricts dans les pipelines d'intégration continue en réponse à l'augmentation des problèmes de logique et de gestion des erreurs. Il suggère d'exiger des tests pour tout flux de contrôle non trivial. Il suggère également d'imposer explicitement la nullabilité et les assertions de type, de normaliser les approches de gestion des exceptions et de demander explicitement des garde-fous dans les domaines complexes.
En matière de sécurité, l'entreprise recommande de centraliser la gestion des identifiants et de bloquer l'utilisation de mots de passe ad hoc dans le code. Elle invite également les équipes à effectuer automatiquement des tests de sécurité statiques des applications et des linters de sécurité dans leurs pipelines afin de détecter les vulnérabilités plus tôt dans le processus.
Le rapport propose des listes de contrôle des pull requests tenant compte de l'IA pour les réviseurs. Celles-ci comprennent des questions explicites sur la couverture des chemins d'erreur, l'exactitude des primitives de concurrence, la validation des valeurs de configuration et le respect des aides à la gestion des mots de passe approuvées. L'objectif est d'orienter les réviseurs vers les domaines où l'IA est le plus susceptible d'introduire des défauts.
Détails de la méthodologie
L'analyse s'appuie sur 470 pull requests open source GitHub. Elle utilise la taxonomie de révision structurée de CodeRabbit pour classer les problèmes dans les catégories logique, maintenabilité, sécurité et performances. Les chercheurs ont comparé les pull requests co-rédigées par l'IA et celles rédigées uniquement par des humains à l'aide de taux de problèmes normalisés. Ils ont appliqué des ratios de taux de Poisson avec des intervalles de confiance de 95 % pour évaluer la force statistique des différences entre les deux groupes. CodeRabbit a déclaré qu'il prévoyait de continuer à suivre le code généré par l'IA dans le monde réel. L'entreprise vise à élargir l'ensemble de données et à affiner les conseils destinés aux équipes de développement à mesure que l'adoption des outils de codage IA augmente.
On peut se poser la question des conséquences sur la qualité du code actuel des logiciels de Microsoft. En effet, le PDG de Microsoft, Satya Nadella, a déclaré que 20 à 30 % du code contenu dans les référentiels de l'entreprise était « écrit par un logiciel », c'est-à-dire par l'IA, lors d'une discussion avec le PDG de Meta, Mark Zuckerberg, à l'occasion de la conférence LlamaCon de Meta. Nadella a donné ce chiffre après que Zuckerberg lui a demandé quelle proportion du code de Microsoft était générée par l'IA aujourd'hui. Le PDG de Microsoft a déclaré que l'entreprise obtenait des résultats mitigés en matière de code généré par l'IA dans différents langages, avec davantage de progrès en Python et moins en C++.
Voici les 10 principales conclusions du rapport
Aucune catégorie de problème n'était propre à l'IA, mais la plupart des catégories présentaient beaucoup plus d'erreurs dans les PR rédigées par l'IA. Cela signifie que les humains et l'IA commettent le même type d'erreurs. L'IA en commet simplement beaucoup plus souvent et à plus grande échelle.
1. Les PR générés par l'IA contenaient environ 1,7 fois plus de problèmes au total.
Sur 470 PR, les modifications rédigées par l'IA ont produit 10,83 problèmes par PR, contre 6,45 pour les PR rédigés uniquement par des humains. Plus frappant encore : les valeurs aberrantes à problèmes élevés étaient beaucoup plus fréquentes dans les PR générés par l'IA, ce qui a entraîné une charge de travail importante pour la révision.
2. La gravité augmente avec l'IA : problèmes plus critiques et plus importants.
Les PR générés par l'IA présentent environ 1,4 à 1,7 fois plus de problèmes critiques et majeurs.
3. Les problèmes de logique et d'exactitude étaient 75 % plus fréquents dans les PR générés par l'IA.
Il s'agit notamment d'erreurs de logique métier, de dépendances incorrectes, de flux de contrôle défectueux et de configurations erronées. Les erreurs de logique sont parmi les plus coûteuses à corriger et les plus susceptibles de provoquer des incidents en aval.
4. Les problèmes de lisibilité ont plus que triplé dans les contributions de l'IA.
La plus grande différence dans l'ensemble des données concernait la lisibilité. Le code produit par l'IA semble souvent cohérent, mais enfreint les modèles locaux en matière de nommage, de clarté et de structure.
5. Les lacunes en matière de gestion des erreurs et des chemins d'exception étaient près de deux fois plus fréquentes.
Le code généré par l'IA omet souvent les vérifications de nullité, les retours anticipés, les garde-fous et la logique d'exception complète, des problèmes étroitement liés aux pannes dans le monde réel.
6. Les problèmes de sécurité étaient jusqu'à 2,74 fois plus fréquents.
Le modèle le plus courant concernait la gestion incorrecte des mots de passe et les références d'objets non sécurisées. Bien qu'aucun type de vulnérabilité ne soit propre à l'IA, presque tous ont été amplifiés.
7. Les régressions de performances, bien que peu nombreuses, étaient fortement biaisées en faveur de l'IA.
Les opérations d'E/S excessives étaient environ 8 fois plus fréquentes dans les PR rédigés par l'IA. Cela reflète la tendance de l'IA à privilégier la clarté et les modèles simples plutôt que l'efficacité des ressources.
8. La concurrence et l'exactitude des dépendances ont augmenté d'environ 2 fois.
Les erreurs d'ordre, les flux de dépendances défectueux ou l'utilisation abusive des primitives de concurrence apparaissaient beaucoup plus fréquemment dans les PR générés par l'IA. Il s'agissait de petites erreurs ayant de grandes implications.
9. Les problèmes de formatage étaient 2,66 fois plus fréquents dans les PR générés par l'IA.
Même les équipes disposant de formateurs et de linters ont constaté une augmentation des erreurs : espacement, indentation, incohérences structurelles et dérive de style étaient tous plus fréquents dans le code généré par l'IA.
10. L'IA a introduit près de deux fois plus d'incohérences dans les noms.
Des noms peu clairs, des terminologies incohérentes et des identifiants génériques apparaissaient fréquemment dans les modifications générées par l'IA, augmentant ainsi la charge cognitive des réviseurs.
Pourquoi ces schémas apparaissent-ils ?
Pourquoi les équipes rencontrent-elles autant de problèmes avec le code généré par l'IA ? Voici l'analyse de CodeRabbit :
- L'IA manque de logique métier locale : les modèles déduisent les modèles de code de manière statistique, et non sémantique. Sans contraintes strictes, ils passent à côté des règles du système que les...
La fin de cet article est réservée aux abonnés. Soutenez le Club Developpez.com en prenant un abonnement pour que nous puissions continuer à vous proposer des publications.