Que se passe-t-il quand les agents IA maintiennent le code hérité ?

Le nouveau mainteneur face aux vieux systèmes

Le code hérité a toujours été paradoxal. Il est ancien, impopulaire, coûteux à modifier, mais il fait souvent tourner les fonctions les plus critiques d’une organisation. Facturation, reporting financier, traitements de données, flux d’authentification, adaptateurs mainframe et scripts d’intégration oubliés peuvent sembler désordonnés dans un dépôt Git, tout en portant des années d’engagements clients, de contraintes réglementaires et d’incidents de production.

C’est précisément ce qui rend les agents IA séduisants. Un agent ne se lasse pas de lire un module vieux de vingt ans, de suivre des chemins d’appel ou de produire une série de tests de régression. Contrairement aux assistants de code plus anciens, les outils agentiques actuels peuvent planifier une tâche, inspecter plusieurs fichiers, exécuter des commandes, corriger leurs propres propositions et remettre un diff à un réviseur. NVIDIA a récemment décrit un flux agentique pour réécrire des fonctions utilisateur Apache Spark en équivalents accélérés par GPU, avec tests, conversion, benchmark et optimisation intégrés [1].

La promesse est forte: réduire le coût d’archéologie logicielle. Mais le risque l’est tout autant: le code hérité n’est pas seulement du code. C’est un enregistrement de comportements métier, parfois non documentés, parfois accidentels, parfois indispensables.

Ce que les agents font déjà bien

Le point de départ le plus sûr est l’enquête. Un agent peut cartographier les modules, repérer les points d’entrée, résumer les flux de données, lister les dépendances externes et signaler les zones où les tests manquent. Les recommandations d’AIDLC sur le code hérité placent cette étape en premier: construire le contexte, rendre le comportement visible, puis modifier de petites parties plutôt que demander une réécriture complète [2].

Ce rôle d’archéologue logiciel est précieux, car les vieux systèmes manquent souvent de documentation vivante. Un agent peut parcourir la structure du dépôt, les commentaires, les configurations, les tests et l’historique des commits beaucoup plus vite qu’un humain. Il peut rédiger des notes d’architecture et poser les bonnes questions: pourquoi cette branche existe-t-elle, quel client utilise ce chemin, quelle tâche tourne en fin de mois, quelle table semble inutilisée mais reste lue par un export financier?

Les agents sont également efficaces sur les travaux répétitifs et vérifiables: mises à niveau de frameworks, dépendances, refactorings mécaniques, listes candidates de code mort, génération de tests. L’exemple Spark de NVIDIA est particulièrement instructif parce qu’il ne s’agit pas d’une promesse générale du type « l’IA écrit du code ». Le cas vise un goulot d’étranglement précis: les UDF Spark peuvent forcer des pipelines accélérés par GPU à revenir vers le CPU, car l’optimiseur ne peut pas inspecter du code arbitraire [1]. NVIDIA décrit un flux où l’agent passe par l’échafaudage, les tests, la conversion et le benchmark, et l’entreprise indique qu’une réécriture a réduit un temps opérateur de 274,55 heures à 12,78 heures sur une charge de 600 milliards de lignes [1].

C’est exactement le type de maintenance hérité où les agents sont les plus utiles: borné, mesurable et contrôlé par un vérificateur. Ce vérificateur peut être une suite de tests, un benchmark, un compilateur, un typage statique, un harnais de parité ou un expert métier. Sans vérificateur, la vitesse n’est pas de la productivité: c’est de l’incertitude accélérée.

Le vieux problème: le dépôt n’est pas le système

Le principal mode d’échec n’est pas nécessairement l’hallucination. Un agent peut comprendre correctement le code et mal comprendre le système.

Une branche de facturation peut sembler redondante parce qu’aucune exigence actuelle ne la mentionne. En réalité, elle peut préserver un plafond négocié avec un client historique. Un délai de nouvelle tentative peut ressembler à une mauvaise pratique, alors qu’il a été introduit après un incident de production. Un champ nullable peut paraître inutilisé dans l’application, tout en alimentant un export trimestriel. Un agent qui lit seulement le dépôt voit la syntaxe, les références et les tests. Il ne voit pas forcément les contrats, les tickets de support, les comptes rendus d’incidents, les décisions d’audit, les rituels de déploiement ou la mémoire de l’ingénieur qui sait pourquoi la partie la plus laide existe.

C’est pourquoi l’ingénierie du contexte devient une partie centrale de la maintenance. AIDLC recommande des notes d’architecture revues, des liens vers les tickets et l’historique d’incidents, ainsi qu’un graphe de contexte donnant aux agents davantage que des fichiers isolés [2]. Le mot essentiel est « revues ». Un résumé produit par un agent sur un vieux sous-système est une hypothèse, pas une autorité. Si aucun humain ne l’a validé, l’organisation n’a pas acquis une connaissance fiable; elle a seulement acquis un document confiant.

Tester avant de transformer

La règle la plus pratique est ancienne, mais elle devient urgente: caractériser le comportement avant de le modifier. Un test de caractérisation enregistre ce que le système fait aujourd’hui, pas ce que l’équipe voudrait qu’il fasse. Cette nuance est cruciale, car les systèmes hérités contiennent souvent des défauts dont des clients, rapports ou intégrations dépendent désormais.

Les agents peuvent générer ces tests rapidement. Ils peuvent exercer des entrées, capturer des sorties et construire un filet de régression autour d’un code qui n’en avait aucun. Mais les tests générés doivent eux aussi être revus. Un test qui vérifie seulement qu’une fonction renvoie quelque chose, ou qui copie la structure interne sans contrôler un comportement significatif, crée une fausse sécurité. Le guide AIDLC recommande les tests de caractérisation avant les changements agentiques et déconseille de mélanger refactoring et correction de comportement dans une même modification [2].

C’est là que le mainteneur IA change le flux de travail. La première tâche n’est pas « modernise ce module ». La première tâche est « montre ce que ce module fait, où ce comportement est observé, et ce qui échouerait s’il changeait ». Ensuite seulement, l’agent peut refactorer, mettre à niveau ou remplacer.

Pourquoi le débat en entreprise se durcit

La discussion ne porte plus uniquement sur la productivité des développeurs. La couverture de l’appel de résultats de JPMorgan en octobre 2026 montre comment les grandes organisations considèrent les agents à la fois comme un levier interne et comme un risque opérationnel. La banque a évoqué l’usage interne d’agents IA, des preuves précoces de productivité en ingénierie logicielle incluant des réécritures de code hérité, tout en soulignant le danger d’agents « voyous » et d’agents externes entrant dans l’environnement de l’entreprise [3].

Cette tension est exactement celle que révèle la maintenance du code hérité. Si les agents sont assez puissants pour réécrire de vieux systèmes, ils sont assez puissants pour les casser. S’ils peuvent exécuter des tests, ouvrir des pull requests et appeler des outils, ils ont besoin d’identités, de permissions, de journaux d’audit et de frontières. La question devient moins « le modèle peut-il le faire? » que « sous quelle autorité, avec quelles preuves, et qui reste responsable? »

L’infrastructure de développement devient elle aussi un point de pression. DX Today a rapporté qu’Anthropic avait construit et adopté son propre système de gestion de versions après que l’activité de code liée à l’IA a dépassé une infrastructure pensée pour un rythme humain; selon ce rapport, les changements fusionnés sont passés d’environ 2 500 par jour en mai 2026 à plus de 30 000 par jour en septembre [4]. Peu d’entreprises verront des volumes comparables, mais la leçon se généralise: la maintenance générée par agents peut multiplier les files de revue, les coûts de CI, les conflits de merge et le bruit opérationnel [4].

Pour les systèmes hérités, c’est essentiel, car le goulot d’étranglement est rarement la frappe du code. C’est la validation du changement. Si les agents produisent dix fois plus de diffs alors que l’organisation conserve le même nombre de personnes capables de comprendre le système, le risque s’accumule dans la revue.

Un modèle d’exploitation plus sûr

La réponse émergente est une autonomie graduée selon le risque.

Les travaux à faible risque peuvent être délégués plus librement: documentation, inventaires de dépendances, rapports candidats de code mort, brouillons de tests, exploration en lecture seule. Les travaux à risque moyen peuvent inclure des mises à niveau mécaniques, des refactorings étroits et des corrections non critiques, mais avec tests, revue humaine et plan de retour arrière. Les travaux à risque élevé — paiements, authentification, migrations de données, conformité, infrastructure de production et comportements propres à certains clients — doivent rester soumis à une validation humaine, même si l’agent rédige le patch.

Ce n’est pas une position anti-automatisation. C’est la condition pour rendre l’automatisation exploitable. Le flux UDF de NVIDIA est convaincant parce qu’il associe conversion de code, vérification et benchmark [1]. Les recommandations AIDLC sont convaincantes parce qu’elles demandent de préserver le comportement, d’avancer par petits lots et d’éviter les réécritures massives [2]. La posture de JPMorgan est convaincante parce qu’elle traite les agents comme utiles, mais pas sans frontières [3].

Un programme mature de maintenance par IA devrait donc contenir plusieurs artefacts: carte système revue, tests de caractérisation, niveaux de risque, profils de permissions des agents, barrières CI, journaux d’audit, plans de rollback et décisions documentées. Chacun transforme une sortie d’agent en preuve plutôt qu’en simple « faites-moi confiance ».

Que deviennent les développeurs?

Les développeurs ne disparaissent pas de la maintenance du code hérité. Leur travail remonte d’un niveau.

Ils passent moins de temps à suivre manuellement chaque appel et davantage à juger si la trace est complète. Ils passent moins de temps à écrire des tests répétitifs et davantage à décider quels comportements comptent. Ils passent moins de temps sur des migrations mécaniques et davantage sur la séquence, le rollback et la stratégie de vérification. Autrement dit, le rôle humain se déplace de la production de lignes vers la responsabilité de maintenance.

Ce déplacement crée un problème de compétences. Les juniors apprenaient souvent les systèmes en effectuant de petites corrections. Si les agents prennent toutes ces corrections, les équipes doivent créer volontairement des boucles d’apprentissage: binômes développeur-agent, explication obligatoire des diffs, rotation de la revue, documentation proche du code. Sinon, l’organisation peut gagner du débit à court terme tout en perdant la compréhension humaine nécessaire pour superviser les agents plus tard.

Conclusion

Quand les agents IA maintiennent du code hérité, le meilleur résultat n’est pas un robot autonome qui nettoie tout seul. C’est une boucle de maintenance plus rapide et plus disciplinée: les agents cartographient, testent, proposent et mesurent; les humains apportent l’intention, la priorité et la responsabilité.

Le pire résultat est différent. Une équipe pointe un agent vers un système fragile, accepte un diff plausible, puis découvre qu’un « nettoyage évident » a supprimé une règle métier que personne n’avait documentée.

En octobre 2026, la réponse pratique est claire. Les agents IA peuvent déjà aider à maintenir du code hérité, surtout lorsque le travail est répétitif, borné et vérifiable. Mais la maintenance du legacy n’est pas seulement un problème de programmation. C’est un problème de préservation de la connaissance. Les organisations gagnantes ne seront pas celles qui laissent les agents modifier le plus de code. Ce seront celles qui rendent les vieux comportements observables avant d’autoriser les agents à changer quoi que ce soit.

Sources des dernières 72 heures

1. [1]How to Rewrite Apache Spark UDFs for GPU Acceleration with AI Agents13 oct. 2026, 02:00
2. [2]AIDLC on Legacy Code: Using AI Agents on Brownfield Systems13 oct. 2026, 02:00
3. [3]JPMorgan Expands AI Agent Use While Blocking External Access14 oct. 2026, 09:05
4. [4]DX Today AI Newsletter | October 14, 202614 oct. 2026, 15:00

Article généré par IA à partir d’une recherche web récente, puis conservé comme instantané éditorial daté.