À l'ère de la programmation assistée par l'IA, de bonnes habitudes de codage restent importantes

Récemment, en réalisant un benchmark d'Agent, j'ai constaté qu'il ne fallait pas simplement évaluer la complexité d'une tâche de programmation du point de vue du développeur pour l'IA.
Par exemple, une tâche de refactorisation : diviser un gros fichier de plusieurs milliers de lignes en une dizaine de petits modules selon leur fonctionnalité.
Cette tâche n'est pas vraiment difficile pour un développeur, le travail principal étant de déplacer du code, d'organiser les imports, de compiler et de vérifier, ce qui est à la portée d'un débutant.
J'ai donc pensé utiliser une tâche simple pour faire un benchmark, mais le résultat a été inattendu.
Claude Code a jugé cette tâche assez grande, a essayé de la diviser en partie, a proposé un PR et a prévu de faire un travail futur étape par étape.
Mon propre Agent a été “forcé à y aller à fond”, en avançant davantage vers une division complète, mais le coût en a été évident : la consommation de tokens était des dizaines de fois supérieure à celle de Claude, et beaucoup de temps a été consacré à relire les fichiers, corriger les erreurs de compilation, relire à nouveau, corriger encore.
Cela m’a fait réaliser que ce qu’une personne trouve simple n’est pas forcément simple pour un Agent.
Pour un humain, ce type de refactorisation consiste souvent à “déplacer ce morceau”. Mais pour un Agent, il faut d’abord lire en plusieurs fois de gros fichiers, se souvenir de quelles fonctions et quels tests sont liés, puis générer une série de modifications inter-fichiers, et enfin combler les trous à force d’erreurs de compilation.
Cela ressemble à une tâche mécanique, mais en réalité, c’est une tâche coûteuse en tokens et en gestion d’état.
Il y a quelque temps, j’ai vu quelqu’un dire qu’à l’ère de la programmation assistée par l’IA, les principes de division en modules n’étaient plus si importants, puisque de toute façon, les humains ne regardent pas le code.
En y regardant de plus près, je ne suis pas tout à fait d’accord. Avoir des frontières de modules claires, des fichiers de taille appropriée, et des dépendances simples ne facilite pas seulement la lecture humaine, mais aide aussi l’Agent à réduire la complexité de la tâche.
D’un autre point de vue, les outils de lecture et de modification de fichiers pour l’Agent ne sont pas très adaptés à ce genre de refactorisation.
Pour modifier un fichier, l’Agent de codage se limite principalement à des remplacements de texte. Par exemple, Claude Code utilise souvent le mode old_string / new_string : fournir un ancien texte, puis le remplacer par un nouveau.
Codex utilise souvent apply_patch : générer un patch ressemblant à un diff git, exprimant le remplacement de l’ancien contenu par le nouveau.
Ces méthodes conviennent pour de petites modifications, mais si l’on veut supprimer une grande partie de code ancien ou déplacer une série de fonctions dans un autre fichier, le modèle doit d’abord lire le contenu original dans le contexte, puis générer une grande section de remplacement ou de diff.
J’ai donc donné un conseil à l’Agent : utiliser un script, sed, perl ou d’autres outils pour découper grossièrement le gros fichier, supprimer directement l’ancien contenu, l’écrire dans un nouveau fichier, puis faire des corrections étape par étape.
Sa capacité à réaliser cela s’est nettement améliorée.
L’Agent ne le fait pas par défaut, principalement parce que le système de prompts lui impose fortement d’utiliser les outils intégrés pour modifier les fichiers, plutôt que des outils en ligne de commande.
En allant plus loin, l’Agent de codage pourrait avoir besoin d’outils d’édition plus avancés.
Ce ne serait pas seulement une interface “remplacer du texte”, mais plutôt une capacité à établir une structure de code via un parser, LSP ou compilateur, permettant à l’Agent de faire des refactorisations comme dans un IDE : déplacer des fonctions, supprimer des blocs impl, organiser les imports.
Je ne sais pas si quelqu’un a déjà tenté cela dans ce domaine.
En résumé, même à l’ère de la programmation assistée par l’IA, de bonnes habitudes de codage ont encore de la valeur.
Il est beaucoup plus rentable, dès le début, d’intégrer ces bonnes pratiques dans l’ingénierie de l’environnement, pour que l’Agent les adopte par défaut, plutôt que de devoir tout refaire plus tard.