L'outil d'IA GitHub Copilot améliore-t-il la qualité du code ? Si GitHub estime que le code produit est plus fonctionnel

GitClear note que cela peut entraîner « une dette technique induite par l'IA »

Avec l'avènement des outils d'intelligence artificielle dans le développement logiciel, GitHub Copilot, basé sur GPT, est devenu un acteur majeur. Mais une question fondamentale demeure : cet assistant de programmation améliore-t-il réellement la qualité du code produit ?

Qu'est-ce que GitHub Copilot ?

GitHub Copilot est un outil d'IA développé par OpenAI et GitHub. En s'appuyant sur des modèles d'apprentissage automatique entraînés sur des milliards de lignes de code, il offre des suggestions de complétion en temps réel. Que ce soit pour rédiger des fonctions, corriger des erreurs ou même générer des tests, il promet d'accélérer le développement tout en réduisant les efforts cognitifs des développeurs.

Pour GitClear, l'utilisation GitHub Copilot pour la programmation entraîne une baisse de la qualité globale du code

Selon une étude de GitClear, la qualité du code n'est pas bonne, avec des problèmes tels que le renouvellement du code (du code ajouté, mais supprimé peu après) et une plus grande proportion de code répété. L'étude porte sur le code ajouté, mis à jour, supprimé, copié ou déplacé, et exclut ce que GitClear définit comme du « bruit ». Cela fait référence au même code engagé dans plusieurs branches, des lignes vierges et d'autres lignes non significatives.

Selon Bill Harding, fondateur de GitClear, l'essentiel est que les assistants de code de l'IA sont très bons pour ajouter du code, mais ils peuvent causer « une dette technique induite par l'IA » : « L'ajout rapide de code est souhaitable si vous travaillez de manière isolée ou sur un problème nouveau. Mais un code ajouté à la va-vite est néfaste pour les équipes chargées d'en assurer la maintenance par la suite », a déclaré Harding. En d'autres termes, une plus grande quantité n'est pas toujours synonyme d'une meilleure qualité. Selon lui, cette tendance pourrait poser de nombreux problèmes aux organisations à l'avenir.

En outre, une étude publiée en octobre dernier a rapporté que GitHub Copilot génère du code comportant des faiblesses de sécurité. « Nos résultats confirment que les développeurs doivent être prudents lorsqu'ils ajoutent du code généré par Copilot (et des outils d'IA similaires de génération de code) et doivent également effectuer des contrôles de sécurité appropriés lorsqu'ils acceptent le code suggéré. Cela montre également que les praticiens doivent développer une conscience et des compétences en matière de sécurité correspondantes », ont écrit les chercheurs à l'origine de l'étude.

Dans le cadre de son étude, GitClear a mis l'accent sur la qualité du code plutôt que sur la quantité, et observe que les assistants d'IA ont tendance à donner "des suggestions pour ajouter du code, mais jamais de suggestions pour mettre à jour, déplacer ou supprimer du code". Les chercheurs proposent également que les algorithmes de suggestion de code soient incités à proposer les suggestions les plus susceptibles d'être acceptées, ce qui semble raisonnable jusqu'à ce que l'on considère l'importance d'un code concis et lisible. Selon le rapport de l'étude, il n'est pas facile de mesurer la qualité du code.


GitHub tire une conclusion différente avec sa propre recherche sur GitHub Copilot

Pour répondre à cette question, GitHub indique avoir mené un essai contrôlé randomisé pour comprendre à quel point le code rédigé à l'aide de GitHub Copilot est fonctionnel, lisible, fiable, maintenable, concis et susceptible d'être approuvé.

Pour cette étude, GitHub a recruté 202 développeurs ayant au moins cinq ans d'expérience. La moitié d'entre eux se sont vu attribuer au hasard un accès à GitHub Copilot et l'autre moitié a reçu pour instruction de ne pas utiliser d'outils d'IA. Les participants ont tous été invités à effectuer une tâche de codage en écrivant des points d'extrémité d'API pour un serveur web. GitHub a ensuite évalué le code à l'aide de tests unitaires et d'un examen d'expert réalisé par des développeurs.

Selon les conclusions de cette étude, le code rédigé avec GitHub Copilot a une fonctionnalité accrue et une meilleure lisibilité, est de meilleure qualité et reçoit des taux d'approbation plus élevés. Parmi les points clés :

• Fonctionnalité accrue : les développeurs ayant accès à GitHub Copilot avaient 56 % plus de chances de réussir les 10 tests unitaires de l'étude, ce qui indique que GitHub Copilot aide les développeurs à écrire un code plus fonctionnel, et ce dans une large mesure.
• Amélioration de la lisibilité : lors des évaluations en aveugle, le code écrit avec GitHub Copilot présentait nettement moins d'erreurs de lisibilité, ce qui a permis aux développeurs d'écrire 13,6 % de lignes de code supplémentaires, en moyenne, sans rencontrer de problèmes de lisibilité.
• Un code de meilleure qualité : la lisibilité s'est améliorée de 3,62 %, la fiabilité de 2,94 %, la maintenabilité de 2,47 % et la concision de 4,16 %. Tous les chiffres sont statistiquement significatifs. Ces améliorations de la qualité sont cohérentes avec celles constatées dans le rapport DORA 2024.
• Des taux d'approbation plus élevés : les développeurs étaient 5 % plus enclins à approuver le code écrit avec GitHub Copilot, ce qui signifie que ce code est prêt à être fusionné plus tôt, accélérant ainsi le temps nécessaire pour corriger les bogues ou déployer de nouvelles fonctionnalités.

GitHub a donné des détails sur ces éléments. Ci-dessous, un extrait de leur billet à ce sujet.

Le code écrit à l'aide de GitHub Copilot est plus fonctionnel

Si le code ne fonctionne pas, il est impossible de dire qu'il est de haute qualité. Nous avons donc examiné la fonctionnalité et l'avons mesurée en analysant le nombre de tests unitaires réussis par le code. Nous avons constaté que le code rédigé à l'aide de GitHub Copilot passait significativement plus de tests (p=0,002). En fait, les développeurs ayant accès à GitHub Copilot avaient 56 % plus de chances de réussir les 10 tests unitaires de l'étude (p=0,04). Cela signifie que l'utilisation de GitHub Copilot aide les développeurs à écrire un code qui est plus fonctionnel, et ce, dans une large mesure.


Les développeurs ont trouvé que le code écrit avec GitHub Copilot était plus facile à lire

Les 25 développeurs qui ont rédigé un code ayant réussi les 10 tests unitaires de la première phase de l'étude ont été désignés au hasard pour examiner en aveugle les soumissions anonymes, qu'elles aient été rédigées avec ou sans GitHub Copilot. Les examinateurs ont constaté que le code rédigé à l'aide de GitHub Copilot comportait moins d'erreurs de lisibilité.

Notre analyse de la revue de code ligne par ligne des développeurs a montré que le code écrit à l'aide de GitHub Copilot comportait beaucoup moins d'erreurs de code : les développeurs utilisant GitHub Copilot ont écrit 18,2 lignes de code par erreur de code, contre seulement 16,0 sans GitHub Copilot. Cela équivaut à 13,6 % de lignes de code en plus avec GitHub Copilot en moyenne sans erreur de code (p=0,002). Cela peut se traduire par des économies en temps réel, car chacune de ces erreurs de code nécessite une action de la part d'un développeur. Par exemple, sans utiliser GitHub Copilot, les équipes peuvent être confrontées à 13 % de commentaires ou de suggestions supplémentaires à traiter, ce qui s'accumule au fil du temps.


Le code rédigé à l'aide de GitHub Copilot a plus de chances d'être approuvé

Enfin, nous avons constaté que les développeurs étaient 5 % plus susceptibles d'approuver le code rédigé à l'aide de GitHub Copilot (p=0,014). Dans le monde réel, cela signifie que les développeurs utilisant GitHub Copilot écrivent du code qui est prêt à être fusionné plus tôt, ce qui accélère la correction des bogues ou le déploiement de nouvelles fonctionnalités.


Alors, améliore-t-il réellement la qualité ?

La réponse dépend largement de l'utilisateur et de l'usage. GitHub Copilot est un outil puissant, mais il n'est pas infaillible. Lorsqu'il est utilisé comme assistant, capable de réduire le temps consacré à des tâches répétitives ou triviales, il peut contribuer indirectement à la qualité en libérant les développeurs pour des tâches stratégiques. Cependant, la responsabilité ultime de produire un code robuste, sécurisé et maintenable reste entre les mains des développeurs.

Cela semble d'ailleurs être l'avis d'une étude réalisée par McKinsey l'année dernière qui a révélé qu'une « augmentation massive de la productivité » grâce aux assistants d'IA de programmation était possible, mais qu'elle dépendait de la complexité de la tâche et de l'expérience du développeur. « En fin de compte, pour maintenir la qualité du code, les développeurs doivent comprendre les attributs d'un code de qualité et inciter l'outil à produire les bons résultats », indique l'étude de McKinsey.

En conclusion, GitHub Copilot peut améliorer la qualité du code, mais uniquement dans les mains d'utilisateurs expérimentés capables de valider et d'adapter ses suggestions. Il ne remplace pas les bonnes pratiques de développement, mais il les complète efficacement.

Source : GitHub

Et vous ?

Trouvez-vous l'étude de GitHub crédible ou pertinente ?

Avez-vous essayé Copilot ? Pensez-vous qu'il influence votre manière de coder ?

Les suggestions de Copilot sont-elles toujours alignées avec les meilleures pratiques de développement ?

Peut-on vraiment considérer le code généré par Copilot comme fiable, ou nécessite-t-il systématiquement une revue manuelle approfondie ?

Pensez-vous que Copilot favorise l’apprentissage chez les développeurs débutants ou au contraire qu’il limite leur compréhension profonde des concepts ?

Les développeurs expérimentés gagnent-ils réellement du temps ou risquent-ils de perdre leur créativité face aux suggestions automatisées ?