Les entreprises de tous genres sont souvent confrontées à un frein commun dans la livraison de logiciels : un historique lourd et une dette technologique qui datent de plusieurs années. Les entreprises manufacturières sont particulièrement touchées par ce phénomène. Ceci dit, nous serions surpris d’apprendre que des dizaines, voire des centaines, de domaines partagent le même enjeu.

Les systèmes legacy concentrent souvent le cœur de la valeur métier, mais leur évolution est coûteuse et risquée : documentation incomplète, dépendances implicites, tests longs à exécuter, effets de bord difficiles à anticiper. Comment intégrer une nouvelle fonctionnalité rapidement, sans fragiliser l’existant ni exploser les délais et le budget, quand une part importante du temps de projet est absorbée par la compréhension et la sécurisation du terrain?

Car avant même d'écrire une ligne de code, il faut cartographier l'inconnu : quelles zones sont réellement responsables du comportement à faire évoluer, quelles dépendances seront touchées, quels effets de bord guettent. C'est précisément à ce goulot d'étranglement que l'IA commence à changer la donne, en transformant une phase d'exploration longue et incertaine en un processus guidé et itératif.

L’IA comme levier stratégique des systèmes legacy

L’IA peut servir d’assistant d’analyse et de préparation pour les systèmes legacy : elle aide à lire et à résumer le code historique, à cartographier les dépendances, à révéler l’architecture implicite et à proposer des stratégies d’intégration. En préparant le terrain plus vite et plus finement, on réduit les risques d’effets de bord, on raccourcit les cycles de livraison et on améliore la qualité des décisions techniques prises par nos équipes de développement. Comme le mentionne mon collègue Alexandre Rivest dans son article sur le refactoring, « un développeur passe la majeure partie de son temps à lire plutôt qu'à écrire ». Le ratio est d'environ 90% de lecture, contre 10% d'écriture.” C’est donc essentiel, dans l’optimisation du travail des développeurs, de viser la portion de lecture du travail.

C'est ici que le refactoring assisté par IA prend tout son sens. Elle déplace l’effort : moins de temps passé à “découvrir” le système, plus de temps consacré à la conception, aux choix d’architecture, aux tests pertinents et à la robustesse. Utilisée méthodiquement, elle accélère l’intégration de fonctionnalités en legacy tout en renforçant les bonnes pratiques (traçabilité, tests, refactoring ciblé).

L’IA comme architecte des systèmes legacy

Dans un contexte legacy, l’enjeu n’est pas uniquement de “faire marcher” une fonctionnalité, mais de l’insérer au bon endroit, avec le minimum d’impact collatéral. C’est précisément sur cette phase de préparation qui est souvent longue, incertaine et peu valorisée que l’IA peut devenir un accélérateur puissant dans notre quotidien. Plutôt que de remplacer l’analyse d’un développeur ou d’une développeuse senior, l’IA sert ici de copilote d’investigation : elle aide à transformer une base de code dense en éléments exploitables. L’objectif est simple : réduire l’ambiguïté avant de toucher au code et produire une vision partagée de ce qui va changer, où et quels risques y sont associés.

Analyser le code historique pour retrouver l’intention

L'IA excelle dans la reconnaissance de structures, ce qui en fait un outil particulièrement adapté à l'analyse de code legacy dense.

Une partie de la complexité vient du fait que le code “explique” rarement le pourquoi. L’IA peut donc assister sur des tâches comme :

• résumer le rôle d’un module, d’une classe ou d’un ensemble de fichiers ;
• proposer une lecture fonctionnelle (ex. “ce composant calcule X, applique Y, puis publie Z”) ;
• identifier les conventions, patterns locaux et zones à forte dette technique.

Ce premier niveau n’est pas un diagnostic définitif, mais un moyen de démarrer plus vite : on réduit le temps passé à naviguer à l’aveugle et on prépare des questions plus pertinentes pour les revues et les ateliers. Là où l’analyse manuelle est coûteuse, l’IA peut aider à constituer une cartographie exploitable :

• dépendances directes et indirectes (imports, appels, événements, messages, jobs, triggers) ;
• points d’entrée réels (API, batch, UI, consommateurs de messages) ;
• composants “rayonnants” qui impactent beaucoup de choses, et composants “sensibles” (forte instabilité, bogues historiques, tests faibles).

Révéler l’architecture implicite (celle qui existe vraiment)

Dans les systèmes legacy, l’architecture « officielle » est parfois obsolète ou incomplète. En découpant le code, les flux et les usages, l’IA peut aider à rendre visible :

• les frontières réelles entre domaines (ou leur absence) ;
• les couplages cachés, les dépendances circulaires, les “services” qui ne sont plus réellement des services ;
• les invariants implicites (règles métier dispersées, validations réplicatives, comportements historiques).

L’intérêt n’est pas de refaire l’architecture à ce stade, mais de savoir dans quel terrain on intervient avant d’ajouter une brique.

Générer des hypothèses de plan d’intégration

Une fois la zone comprise, l’IA peut proposer un plan d’intégration sous forme d’hypothèses :

• scénarios d’implémentation (point d’extension A vs B, nouvelle abstraction vs adaptation minimale) ;
• refactorings ciblés qui réduisent le risque (extraction d’une fonction, isolation d’un accès DB, suppression d’une duplication) ;
• liste des impacts attendus (modules touchés, contrats à respecter, risques majeurs).

Ces propositions doivent être traitées comme des options à valider, et non comme des décisions automatiques. La valeur est d’arriver plus vite à une discussion structurée : trade-offs, risques et stratégie de déploiement. Une meilleure préparation technique n’est utile que si elle permet d’aboutir à un plan stratégique pour l’équipe et à des résultats concrets : moins d’incidents, plus de qualité et plus de fonctionnalités livrées rapidement.

Retour terrain: naviguer un écosystème .NET legacy multi-répertoires

Dans le cadre d'un mandat récent, nous avons dû intégrer une nouvelle fonctionnalité dans un écosystème .NET réparti sur plusieurs dépôts, sans documentation centralisée et avec des dépendances implicites entre les systèmes, notamment pour la génération de la facturation et du bill of materials. La logique métier était fragmentée entre des services qui se supposaient mutuellement sans contrat explicite.

À cela s'ajoute une couche supplémentaire de complexité : une partie du système reposait encore sur PowerBuilder, une technologie des années 90 dont la syntaxe et les paradigmes sont étrangers à la majorité des développeurs modernes. Plutôt que de plonger directement dans le code, nous avons utilisé l'IA pour constituer une première cartographie : quels modules participaient au cycle de facturation, quels événements déclenchent la génération du bill of materials, où se trouvaient les règles de calcul et dans quel état était la couverture de tests. En quelques heures, nous avions une vue d'ensemble qui aurait normalement nécessité plusieurs jours d'exploration manuelle et d'entretiens avec les équipes.

Ce travail de préparation nous a permis d'identifier deux zones à risque élevé avant même d'écrire une ligne de code et de concevoir un plan d'intégration ciblé, avec des garde-fous adaptés. Le résultat : une livraison sans régression sur un système que personne dans l'équipe ne maîtrisait complètement au départ.

Bénéfices concrets et renforcement de la qualité

Utilisée correctement, l’intelligence artificielle nous permet d’améliorer considérablement la productivité de nos équipes de développement, tout en améliorant la qualité du code livré et sa pérennité dans le temps. De plus, elle permet d’améliorer la qualité des décisions des développeurs et des développeuses, ainsi que la robustesse de leurs solutions, ce qui est souvent plus important qu’une performance “brute” améliorée.

Plus d’effets, plus de prévisibilité

En legacy, la majorité des surprises provient des dépendances implicites et des comportements historiques. Une préparation assistée par IA permet de :

• mieux cibler les zones à risque ;
• définir des garde-fous (tests, feature flags, instrumentation) avant de modifier ;
• Expliciter les hypothèses (« si on change X, alors Y doit rester vrai »).

L’IA ne devine rien ; ceci dit, elle rend visibles les facteurs difficiles à remarquer et nous permet de mieux comprendre l’état des lieux avant de créer de la valeur ajoutée.

Accélération des cycles sans compromis systématique sur la qualité

Le gain de temps se situe surtout dans les activités à forte friction comme la compréhension initiale, l’exploration du code, l’identification des impacts potentiels, ainsi que la préparation d’un plan de tests ou d’implémentation pertinent. Le résultat attendu est une réduction du temps nécessaire à la préparation et à l’exploration afin d’avoir une meilleure continuité entre analyses → design → implémentation → validation.

Cela étant dit, il est primordial de se rappeler que l’IA nous outille et ne doit pas remplacer notre raisonnement. Expérimenter et découvrir par essais et erreurs nous amène à une maîtrise supérieure du domaine et du code, ainsi qu’à garantir la pérennité du développement. On peut l’utiliser pour valider nos hypothèses et accélérer le refactoring, tout en faisant appel à notre jugement pour prioriser les zones chaudes et sécuriser les manipulations susceptibles d’engendrer des bogues ou des régressions.

L’IA au service des bonnes pratiques (et pas l’inverse)

Le point clé côté engineering est d’éviter l’effet de « copier-coller des suggestions ». Dans une approche mature, l’IA renforce des pratiques déjà saines :

• Tests orientés risque : On priorise les scénarios critiques identifiés.
• Revue de code plus efficace : On arrive avec des hypothèses et des impacts documentés.
• Refactoring ciblé : Petites améliorations structurelles qui améliorent la fonctionnalité et réduisent la dette.
• Documentation vivante : Schémas, résumés, décisions (ADR) produits.

Autrement dit, l’IA sert à industrialiser la préparation, mais la qualité reste pilotée par des standards d’ingénierie, comme la validation, la traçabilité et la discipline de livraison. Plusieurs outils de refactoring se sont ajoutés dans la boîte à outils des devs au fil des ans, et les LLM en sont un nouveau. Ils permettent d’automatiser des extractions de code et l’introduction de patrons de design, comme le patron stratégie, qui est très pratique dans les vieilles bases de code.

En conclusion

Les systèmes legacy ne sont pas seulement du vieux code, ce sont des plateformes critiques, riches en règles d'affaires, mais dont l’évolution est ralentie par l’incompréhension et l’incertitude. Dans ce contexte, l’IA ne doit pas être vue comme une baguette magique, mais comme un outil de préparation : elle accélère la compréhension, rend la complexité plus visible et aide à élaborer des plans d’intégration plus sûrs. La valeur la plus tangible apparaît quand l’IA est utilisée avec une discipline d’ingénierie : tests orientés risque, revues de code structurées, refactoring ciblé. On obtient alors un double bénéfice : une livraison accélérée et une réduction des surprises coûteuses. Cela établit une base solide pour une modernisation progressive.

Si votre enjeu est d’ajouter des fonctionnalités sans fragiliser l’existant, l’approche consiste à commencer par préparer le terrain : cartographier, clarifier, sécuriser, pour seulement ensuite implémenter. C’est exactement là que l’IA, utilisée avec méthode et jugement critique, devient un avantage compétitif pour faire évoluer un système legacy avec qualité. Parlons de votre prochaine feature legacy : nous pouvons combiner notre expertise logicielle, nos exigences en qualité et l’IA pragmatique afin d’accélérer votre modernisation et la livraison de fonctionnalités, tout en garantissant une meilleure prévisibilité.