Imaginez que vous êtes un maître architecte ayant passé des années à concevoir un château magnifique et complexe. Imaginez maintenant que vous engagez un robot assistant super intelligent et incroyablement rapide pour vous aider à rénover ce château. Votre objectif n'est pas de changer la façon dont le château fonctionne — les gens doivent toujours pouvoir aller de la cuisine à la chambre sans tomber à travers le sol — mais de rendre les couloirs plus larges, les pièces plus lumineuses et la structure plus facile à entretenir. C'est le monde du remaniage de code (code refactoring) : le processus de nettoyage et de réorganisation du code informatique pour l'améliorer, sans casser le logiciel qu'il exécute.

Pendant longtemps, nous avons eu des outils qui agissent comme des correcteurs orthographiques basiques pour le code, signalant un formatage désordonné ou des erreurs évidentes. Mais récemment, un nouveau genre de « robot » est arrivé : les Modèles de Langage de Grande Taille (LLM). Considérez-les comme des assistants IA qui ont lu presque tous les livres, manuels et feuilles d'instructions jamais écrits. Ils sont incroyables pour écrire de nouvelles histoires ou corriger des phrases brisées. Cependant, lorsque vous leur demandez de rénover un château complexe (un projet logiciel), ils deviennent parfois un peu trop créatifs. Ils pourraient déplacer un mur qui soutient le toit, ou renommer une porte d'une manière qui confond tout le monde essayant de trouver la cuisine. La grande question que se posent les scientifiques et les ingénieurs est la suivante : pouvons-nous faire confiance à ces robots IA pour effectuer la rénovation en toute sécurité, ou ont-ils besoin d'un superviseur humain pour vérifier leur travail ?

C'est exactement ce que l'article « RefactorAssist: Agentic Refinement for Reliable Code Refactoring » étudie. Les chercheurs, Jonathan Cordeiro, Shayan Noei et Ying Zou, voulaient voir si ces robots IA pouvaient réparer le code sans le casser, et si, dans le cas où ils le cassaient, un « agent de réparation » intelligent pouvait corriger les erreurs du robot.

La première tentative du robot : un bilan mitigé

L'équipe a commencé par demander à plusieurs modèles d'IA différents (incluant certains modèles open-source comme StarCoder2 et des modèles commerciaux puissants comme GPT-4o) d'effectuer des rénovations sur de réels projets logiciels Java. Ils ont traité le logiciel comme un être vivant doté d'un système de « contrôle de santé » intégré appelé tests unitaires. Ces tests sont comme une série de points de contrôle : si le code est modifié correctement, le robot réussit le test ; si le robot casse accidentellement une fonction, le test échoue.

Les résultats ont été un peu choquants. Même les meilleurs modèles d'IA, comme GPT-4o, n'ont réussi la rénovation correctement qu'environ 80,8 % du temps. Cela signifie que près d'une fois sur cinq, l'IA a tenté d'améliorer le code mais a accidentellement cassé quelque chose, provoquant l'échec des contrôles de santé du logiciel. Les chercheurs ont découvert que le simple fait de donner plus d'exemples à l'IA sur la façon de rénover (une technique appelée « few-shot prompting ») n'aidait pas vraiment beaucoup. Le problème n'était pas que l'IA ne savait pas comment rénover ; c'est qu'elle ne comprenait pas assez bien le contexte pour éviter de commettre des erreurs subtiles et dangereuses.

Pourquoi les robots ont-ils échoué ?

Pour comprendre ce qui n'allait pas, les chercheurs ont agi comme des détectives, examinant les « scènes de crime » du code défaillant. Ils ont découvert que les erreurs de l'IA tombaient dans huit catégories principales, les plus fréquentes étant :

1. Hallucinations et confusion de contexte (24,3 %) : L'IA inventait de nouvelles fonctionnalités ou modifiait des choses qui n'avaient pas besoin d'être modifiées parce qu'elle comprenait mal l'histoire du code.
2. Renommage incohérent (15,3 %) : L'IA renommait une variable (comme appeler une « porte » un « portail ») à un endroit, mais oubliait de mettre à jour le nom partout ailleurs, laissant le code confus.
3. Ajout de nouveaux éléments (13,7 %) : L'IA ajoutait accidentellement de nouvelles variables ou fonctions qui n'étaient pas censées être là.
4. Code incomplet (11,3 %) : L'IA arrêtait d'écrire le code au milieu, laissant des morceaux manquants.
5. Erreurs de syntaxe et de structure (9,7 %) : Des erreurs basiques comme oublier une parenthèse fermante ou un point-virgule.
6. Cas limites (9 %) : L'IA oubliait de gérer des situations rares, comme ce qui se passe si un utilisateur entre zéro au lieu d'un nombre.
7. Gestion des types (8,7 %) : Mélanger différents types de données, comme essayer de mettre un message texte dans une boîte de nombres.
8. Problèmes de portée (8 %) : Essayer d'utiliser une variable dans un endroit où elle n'existe pas.

Entrée en scène de RefactorAssist : le super-inspecteur

Les chercheurs ont réalisé que simplement demander à l'IA d'essayer à nouveau ne suffisait pas. Ils avaient besoin d'un système capable de détecter ces erreurs et de les corriger automatiquement. Ils ont donc construit RefactorAssist, un intelligent « agent de réparation » qui agit comme un inspecteur de contrôle qualité à deux étapes.

Étape 1 : La correction rapide (Réparation statique)
Avant même de demander à l'IA de réfléchir à nouveau, RefactorAssist exécute une vérification rapide basée sur des règles. C'est comme un correcteur orthographique qui n'a pas besoin de comprendre l'histoire, juste la grammaire. Il corrige les choses évidentes comme les imports manquants, les parenthèses déséquilibrées et les erreurs de type simples. Cette étape est peu coûteuse et rapide car elle n'utilise pas le cerveau lourd de l'IA. Étonnamment, cette étape simple a corrigé une grande partie des problèmes, faisant passer le taux de réussite de 66,1 % à 74,4 % (et jusqu'à 80,3 % dans leur meilleure configuration) simplement en nettoyant la syntaxe.

Étape 2 : Le travail de détective (Réparation agentique)
Pour le code restant défectueux (celui qui échouait encore après la correction rapide), RefactorAssist passe en « mode agent ». Il rassemble toutes les preuves : les messages d'erreur des tests échoués, les changements spécifiques effectués par l'IA (le « diff »), et le contexte du code environnant. Il demande ensuite à une IA puissante (comme GPT-4o) d'agir comme un détective, expliquant pourquoi le code a échoué et suggérant une correction. Ce détective ne se contente pas de deviner ; il utilise les preuves pour guider la réparation.

Les résultats de ce processus en deux étapes sont impressionnants. Après la tentative initiale de l'IA, la correction statique, puis le travail itératif du détective, le taux de réussite grimpe jusqu'à 94,2 %. Crucialement, le système a été capable de réparer 70,8 % des échecs qui demeuraient après l'étape initiale de réparation statique. Cela signifie que pour le sous-ensemble de rénovations que l'IA a ratées et que la vérification grammaticale n'a pas pu corriger, l'agent détective de RefactorAssist a récupéré la vaste majorité, portant le taux de réussite total à un niveau presque parfait.

Ce qui n'a pas fonctionné

Les chercheurs ont également testé des idées qu'ils pensaient utiles, mais qui se sont révélées moins utiles. Par exemple, ils ont essayé d'ajouter un système de « récupération » (retrieval) qui chercherait dans l'ensemble du projet un contexte supplémentaire pour donner plus de contexte à l'IA. Bien que cela ait aidé un peu lors des toutes premières secondes de la correction, cela n'a pas réellement aidé l'IA à résoudre les problèmes les plus difficiles sur le long terme. L'article suggère qu'avoir une explication claire et précise de pourquoi quelque chose a échoué (le « diagnostic ») est bien plus important que d'avoir une masse énorme de contexte supplémentaire.

À retenir

Cet article ne prétend pas que l'IA peut encore refactoriser le code parfaitement de manière autonome. En fait, il prouve que sans aide, l'IA commet des erreurs environ 20 % du temps. Cependant, il montre qu'en combinant une simple et rapide « vérification grammaticale » avec un « agent détective » intelligent basé sur des preuves, nous pouvons corriger la plupart de ces erreurs.

La conclusion principale est que RefactorAssist peut prendre une rénovation générée par l'IA, désordonnée et défectueuse, et la transformer en une mise à jour de code sûre et fonctionnelle avec un taux de réussite de 94,2 %. Cela suggère que l'avenir du génie logiciel ne consiste pas seulement à avoir une IA plus intelligente, mais à construire une équipe où l'IA fait le gros du travail, et où un agent de réparation spécialisé rattrape les erreurs avant qu'elles n'atteignent l'utilisateur. C'est un rappel que même les robots super intelligents ont besoin d'une bonne équipe de contrôle qualité pour faire de leur mieux.