ModernisationÉquipe d’ingénierie elitics

Modernisation applicative avec l'IA : le guide 2026 des CTO

Moderniser un système legacy avec l'IA : les sept R comparés, l'apport des agents de code, le strangler fig pattern, un plan en six phases et les coûts.

La modernisation des systèmes legacy assistée par l'IA utilise des agents de code pour lire, documenter, tester et traduire progressivement un ancien système, tandis que les ingénieurs prennent chaque décision et relisent chaque modification. En 2026, les agents rendent moins coûteux le travail préparatoire : expliquer un code dont plus personne ne se souvient, cartographier les dépendances, écrire des tests de caractérisation et absorber les montées de version fastidieuses. Ils ne suppriment pas le vrai risque, qui se trouve dans les comportements jamais documentés, dans la migration des données et dans la bascule. La démarche qui fonctionne : évaluer, poser un filet de sécurité de tests, avancer par petites tranches derrière une façade strangler fig, migrer les données avec rapprochement, faire tourner ancien et nouveau en parallèle, puis éteindre l'ancien système.

Ce guide s'adresse aux CTO qui doivent décider comment moderniser un système dont l'activité dépend encore : un mainframe COBOL, un monolithe .NET ou Java vieillissant, une application PHP que personne ne veut plus toucher. Pour l'effet des agents de code sur la livraison au quotidien, voir notre article sur les agents de code IA dans les projets logiciels ; ici, nous les appliquons à du code ancien.

Ce que l'IA change dans la modernisation applicative, et ce qu'elle ne change pas

Pendant des décennies, les premiers mois d'un programme de modernisation partaient en archéologie : lire le code, interroger les rares personnes qui savent encore pourquoi il fonctionne, reconstituer les flux de données à partir des traitements batch et des procédures stockées. Le budget était consommé avant qu'une seule fonction ait été déplacée.

Les agents de code peuvent désormais lire une grande base de code, suivre les appels d'un module à l'autre et l'expliquer en langage clair en quelques heures plutôt qu'en quelques semaines. Cela change l'économie des premières phases et rend moins chères les approches progressives, qui demandent beaucoup de tests et de petites modifications mécaniques. Cela ne change pas la raison pour laquelle les programmes de modernisation échouent : le code était rarement la partie la plus difficile.

Moins cher avec l'IA

  • Comprendre et documenter un code ancien
  • Cartographier dépendances, accès aux données et chaînes batch
  • Écrire des tests de caractérisation et des jeux de données de test
  • Montées de version de frameworks et de runtimes, API obsolètes

Toujours aussi difficile

  • Décider quels anciens comportements l'activité exige encore
  • Nettoyer et rapprocher des décennies de données
  • Basculer sans arrêter l'exploitation
  • Changer la façon dont les personnes et les équipes travaillent

L'IA rend moins coûteuse la compréhension de l'ancien système. Elle ne peut pas vous dire lesquels de ses comportements l'activité exige encore.

Options de modernisation des systèmes legacy : les sept R comparés

Les options de modernisation sont souvent décrites comme des stratégies en « R ». Les noms et le nombre varient selon les référentiels ; ces sept-là couvrent les décisions que vous aurez à prendre. Décidez composant par composant, pas pour tout le parc : un même système reçoit souvent trois réponses différentes.

StratégieCe que cela signifieQuand elle convientRisque principalApport de l'IA
Retain (conserver)Garder en l'état, éventuellement derrière une APIStable, rarement modifié, peu coûteux à exploiterLes compétences et le support éditeur disparaissentDocumentation, pour que le savoir ne parte pas avec les personnes
RehostDéplacer tel quel vers une nouvelle infrastructure (« lift and shift »)Sortie de datacenter, matériel en fin de vieMême code, mêmes problèmes, nouvelle factureInventaire de la configuration et des dépendances, infrastructure as code
ReplatformPetites adaptations pour une plateforme managée : conteneurs, base de données managée, runtime plus récentExploitation cloud sans réécritureDépendance cachée au comportement de l'ancien runtimeMontées de version et corrections de compatibilité
RefactorAméliorer la structure interne sans changer le comportementLa conception tient, mais le code est difficile à modifierGlisser vers une réécriture sans testsTests de caractérisation, refactorings mécaniques, détection du code mort
RearchitectChanger l'architecture, par exemple découper un monolithe en modules ou en servicesDes parties doivent évoluer ou monter en charge à des rythmes différentsComplexité distribuée, propriété des données floueCartographie des dépendances, repérage des points de découpe, génération d'adaptateurs
RebuildRéécrire sur une nouvelle pile, à périmètre constantCœur de métier et irréparableBascule « big bang », comportements oubliésTransformer les anciennes règles en spécifications et en tests ; traduire des modules
ReplacePasser à un SaaS ou à un progicielFonction standard comme la comptabilité, les RH ou le CRMPersonnalisations et données qui ne rentrent pas dans le produitFaire correspondre personnalisations et données au nouveau produit

Ajoutez une huitième option à chaque évaluation : retire, c'est-à-dire éteindre. Les données d'usage révèlent souvent des écrans, des rapports et des traitements batch que personne n'utilise ; chaque fonction éteinte est une fonction de moins à migrer.

Pour choisir, notez chaque composant sur sa valeur métier et son état technique. Forte valeur, mauvais état : refactoriser, réarchitecturer ou reconstruire progressivement. Faible valeur, mauvais état : remplacer ou éteindre. Forte valeur, bon état : conserver, derrière une API. Réécrire tout le parc d'un coup est rarement la bonne réponse. Quand une reconstruction se justifie, traitez-la comme un projet de développement web sur mesure doté d'une spécification d'une précision rare : l'ancien système.

Là où l'IA aide vraiment sur du code legacy

Six tâches où les agents trouvent leur place, à condition qu'un ingénieur vérifie le résultat.

Comprendre et documenter le code

Résumés clairs par module, glossaire des termes métier, flux de données et ébauches de documentation d'architecture, pour du COBOL, du PL/SQL, du Visual Basic ou du vieux Java. Une personne qui connaît le système les valide.

Tests de caractérisation et golden master

Enregistrer ce que fait le système aujourd'hui : lui fournir des entrées, capturer les sorties, vérifier que le nouveau code produit la même chose. Les agents écrivent le harnais de test et déduisent des cas d'entrée des branches qu'ils lisent. Le comportement actuel est capturé, bugs compris ; c'est tout l'intérêt.

Cartographie des dépendances

Graphes d'appels, quels programmes lisent et écrivent quelles tables, chaînes batch, includes et copybooks partagés, interfaces externes. Croisez la carte de l'agent avec l'analyse statique et les journaux d'exécution ; aucune source n'est complète seule.

Traduction progressive

Traduire module par module vers le langage cible, une fois que le module a ses tests. Demandez un code idiomatique plutôt qu'une copie ligne à ligne, et relisez-le comme n'importe quel autre code.

Montées de version fastidieuses

Mises à niveau de frameworks et de runtimes, par exemple de .NET Framework vers le .NET actuel, d'un vieux Java vers une version LTS récente ou de PHP 7 vers 8 : API obsolètes, valeurs par défaut modifiées, scripts de build et mises à jour de dépendances.

Capture du savoir

Transformer les entretiens avec les personnes qui exploitent le système en règles structurées, en questions ouvertes et en cas de test.

Le problème, c'est la précision. Dans le Stack Overflow Developer Survey 2025, 66 % des répondants citent « des solutions d'IA presque justes, mais pas tout à fait » comme leur principale frustration, 45 % estiment que déboguer du code généré par l'IA prend plus de temps, et davantage de développeurs se méfient de la précision des outils d'IA (46 %) qu'ils ne lui font confiance (33 %). Dans du code neuf, l'auteur qui sait ce qu'il voulait repère le « presque juste ». Dans du code legacy, personne ne connaît la bonne réponse par cœur, et l'erreur peut survivre des mois. D'où la règle : chaque production de l'IA devient un test qui s'exécute, du code qu'une personne relit, ou une documentation qu'une personne valide.

Là où l'IA ne supprime pas le risque

Un agent peut expliquer ce que fait le code. Il ne peut pas dire si l'activité le veut encore. Cinq risques restent les vôtres et ceux de votre partenaire.

RisquePourquoi l'IA ne peut pas trancherQue faire à la place
Règles métier que personne ne peut confirmerLe code peut contenir un contournement pour une réglementation qui a changé, ou un cas particulier pour un client parti depuis longtemps. Le lire ne révèle pas l'intention.Un inventaire des règles avec, pour chacune, un responsable nommé qui décide : garder, modifier ou supprimer
Qualité des donnéesLes données anciennes mélangent les encodages, contiennent des valeurs magiques et des enregistrements orphelins que l'ancien code tolère en silenceProfiler les données tôt, convenir des règles de nettoyage, rapprocher chaque passe de migration
BasculeFenêtres d'arrêt, plannings batch, interfaces partenaires et retour arrière sont des décisions d'exploitation, pas du codeRépétitions générales, runbooks, routage réversible, plan de retour arrière testé
Changement organisationnelLes utilisateurs ont leurs contournements et des équipes en aval dépendent d'anciens rapportsImpliquer les utilisateurs tôt, recenser chaque destinataire de rapport, planifier formation et nouvelles responsabilités
Comportement hors du dépôtParamètres d'ordonnanceur, triggers de base de données, configuration et gestes manuels des opérateurs sont souvent absents du code que lit l'agentInventorier l'environnement d'exécution et l'exploitation, pas seulement le code source

Modernisation mainframe et COBOL avec l'IA

Les parcs COBOL ont leurs propres pièges : copybooks partagés, chaînes batch JCL, transactions CICS, arithmétique décimale condensée, données EBCDIC, fichiers VSAM ou tables Db2. Les agents expliquent bien le COBOL et produisent des ébauches Java ou C# utiles. C'est sur l'arithmétique décimale que la traduction devient « presque juste » : un autre mode d'arrondi dans un calcul d'intérêts passe une relecture rapide et échoue au rapprochement des semaines plus tard. Des tests golden master sur de vraies entrées et sorties batch sont le seul contrôle fiable.

Choisissez tôt entre traduction et refonte : la traduction ligne à ligne va plus vite mais produit du Java qui se lit encore comme du COBOL ; la refonte prend plus de temps et donne un code que votre équipe peut maintenir. Le côté cible relève de l'ingénierie moderne classique ; le côté mainframe exige des personnes qui connaissent la plateforme.

Le strangler fig pattern : moderniser sans réécriture « big bang »

Le strangler fig pattern remplace un système legacy étape par étape : les nouvelles fonctionnalités sont construites dans le nouveau système, les fonctions existantes y sont transférées une à une, et l'ancien système est arrêté lorsque plus rien n'en dépend. Il évite les trois écueils d'une réécriture « big bang » : l'ancien système continue d'évoluer pendant que vous le réécrivez, le nouveau n'apporte rien tant qu'il n'a pas atteint la parité complète, et la bascule devient un unique événement, lourd et risqué.

  1. Placer une façade devant : une passerelle d'API, un reverse proxy ou une interface dans le code, par laquelle passe chaque appel.
  2. Choisir une tranche fine : une fonction aux entrées et sorties claires, idéalement une qui change souvent ou pose problème.
  3. Construire la tranche dans le nouveau système, couverte par les tests de caractérisation de cette fonction.
  4. Rediriger une petite part du trafic, ou un groupe d'utilisateurs, vers la nouvelle tranche. Comparer les résultats ; en cas de problème, rebasculer le routage.
  5. Décider qui possède les données. Synchroniser ancien et nouveau par change data capture ou par événements, avec une seule source de vérité par jeu de données.
  6. Répéter, puis supprimer. Effacer l'ancien code dès qu'aucune route n'y mène, pour que le système legacy rétrécisse vraiment.

L'IA aide à chaque étape : repérer les points de découpe d'un monolithe, générer des adaptateurs entre ancien et nouveau modèle de données, écrire les tests de comparaison. Pour les systèmes très batch, découpez par traitement plutôt que par requête : migrez une chaîne de traitements à la fois et comparez ses fichiers de sortie.

Un plan en six phases pour une modernisation assistée par l'IA

Chaque phase se termine par une décision que vous pouvez financer séparément ; les phases 3 à 5 se répètent pour chaque tranche.

PhaseCe qui se passeRôle de l'IACritère de sortie
1. ÉvaluationInventaire, usage, notation valeur et état, stratégie par composant, première tranche et budgetLire le code, ébaucher la documentation, cartographier les dépendancesStratégie par composant validée ; première tranche choisie
2. Filet de sécuritéTests de caractérisation, CI, supervision, environnements de testGénérer le harnais de test et les cas d'entréeLes tests passent sur l'ancien système ; couverture de la première tranche convenue
3. Tranches successivesFaçade en place ; tranches construites et activées une à uneTraduction, refactoring, montées de version, première relecturePar tranche : tests au vert, en production derrière la couche de routage
4. Migration des donnéesProfiler, faire correspondre, nettoyer, migrer, rapprocher, répéterÉbaucher correspondances et scripts, signaler les anomaliesRapprochement propre lors d'une répétition sur des données de volume production
5. Fonctionnement en parallèleAncien et nouveau traitent les mêmes entrées ; les résultats sont comparésTrier et regrouper les écartsChaque écart expliqué ; le responsable métier valide
6. DécommissionnementÉteindre, archiver les données, supprimer les routes, mettre fin aux licencesTrouver les références restantes à l'ancien systèmeAncien système éteint, archive accessible, coûts d'exploitation supprimés

Ne sautez pas la phase 6 : un ancien système laissé en marche « au cas où » double les coûts d'exploitation et maintient tous les anciens risques. Pour un regard extérieur sur la phase 1, notre offre de modernisation legacy commence par une évaluation de l'architecture et du code.

Faites évaluer votre système legacy

Nous lisons votre système avec des outils assistés par l'IA et des ingénieurs seniors, cartographions dépendances et risques, recommandons une stratégie par composant et définissons la première tranche. Vous recevez une proposition dans les 24 heures suivant le premier échange.

Checklist de modernisation legacy

  1. Responsables : un responsable métier pour le système et pour chaque tranche.
  2. Inventaire : composants, interfaces, traitements batch, rapports et leurs utilisateurs.
  3. Données d'usage : quelles fonctions sont réellement utilisées, et lesquelles peuvent être éteintes.
  4. Stratégie : l'un des sept R par composant, avec la raison écrite.
  5. Inventaire des règles : chaque règle métier connue a un responsable qui peut la confirmer ou la supprimer.
  6. Filet de sécurité : des tests de caractérisation tournent en CI contre l'ancien système.
  7. Façade : la couche de routage est en service avant que la première tranche ne bouge.
  8. Données : profilées, avec des règles de nettoyage et de rapprochement convenues.
  9. Retour arrière : un plan pour chaque mise en production, testé au moins une fois.
  10. Fonctionnement en parallèle : méthode de comparaison et critères de validation définis à l'avance.
  11. Politique IA : outils autorisés, règles sur les données et règles de relecture, par écrit.
  12. Plan de décommissionnement : durées de conservation, accès aux archives, dates de fin des licences et contrats.

Encadrer les modifications générées par l'IA

Dans une modernisation, la production de l'IA atterrit dans des systèmes qui font tourner la facturation, la paie ou la gestion des sinistres. Six règles :

Relecture humaine de chaque modification

Un ingénieur qui comprend le module relit chaque modification générée par l'IA, dans le processus de pull request habituel. Dimensionnez les tranches pour qu'elles puissent être relues sérieusement.

Les tests font foi

Les tests de caractérisation sont le critère d'acceptation. Un agent ne modifie pas un test pour le faire passer sans validation explicite ; modifications de tests et de code vont dans des commits séparés.

Aucun secret transmis aux outils

Les vieux dépôts contiennent souvent des mots de passe en dur, des chaînes de connexion et de vraies données clients dans des fichiers de test. Nettoyez-les avant qu'un outil d'IA ne lise le code ; jamais de données de production dans un prompt.

Conditions des fournisseurs sur les données

Sachez quels services d'IA voient votre code, sous quelle offre, s'il peut servir à l'entraînement, combien de temps et où il est conservé. Des données personnelles dans le code ou les jeux de test en font aussi une question RGPD.

Injection de prompt

Les agents lisent des commentaires, des documents et des tickets qui peuvent contenir des instructions cachées. Donnez-leur le minimum de droits et jamais d'accès à la production.

Mesurer plutôt que supposer

Suivez le délai par tranche, le temps de relecture, les défauts arrivés en production et les écarts de rapprochement par rapport au plan.

Le Top 10 OWASP pour les applications LLM place l'injection de prompt au premier rang des risques (LLM01) : les autorisations relèvent donc de la configuration, pas du prompt. Sur la mesure : dans une étude de METR de 2025, que METR juge désormais dépassée, le gain de vitesse ressenti par les développeurs avec l'IA différait de celui mesuré. Gains perçus et gains mesurés peuvent diverger : mesurez.

Si une équipe externe voit des données personnelles dans l'ancien système, anticipez-le. Le Kosovo, où travaillent nos ingénieurs, est hors de l'UE et ne bénéficie pas d'une décision d'adéquation : l'accès à distance à des données personnelles constitue donc un transfert, qui exige un accord de sous-traitance, les clauses contractuelles types et une analyse d'impact du transfert. Contactez-nous pour en parler. Pour un audit de sécurité de l'ancien et du nouveau système, voir nos services de sécurité.

Ce que coûte la modernisation d'un système legacy et comment la budgéter

Aucun prestataire sérieux ne peut chiffrer une modernisation sans avoir vu le système. Ce qui fait varier le coût :

  • Taille et enchevêtrement du code : la part d'état, de tables et d'includes partagés, pas seulement le nombre de lignes.
  • Interfaces : chaque partenaire, transfert de fichiers et rapport en aval est une tâche de bascule.
  • Tests existants : s'il n'y en a pas, le filet de sécurité est une phase à part entière.
  • Volume et qualité des données : migration et rapprochement sont souvent le plus gros bloc.
  • Accès aux experts : le temps des personnes qui connaissent le système est la ressource la plus rare.
  • Contraintes et fonctionnement en parallèle : réglementation, pistes d'audit, fenêtres d'arrêt et durée pendant laquelle les deux systèmes tournent.
  • Stratégie : un rehosting coûte une fraction d'une reconstruction, et rapporte une fraction du bénéfice.

L'IA réduit le coût de la compréhension, de l'écriture des tests et des modifications mécaniques, pas celui du temps des experts, du rapprochement des données, du fonctionnement en parallèle ou de la conduite du changement. Méfiez-vous de toute offre qui promet une économie fixe « grâce à l'IA » avant que quiconque ait lu votre code.

Fourchettes illustratives à nos tarifs publiés de 45–65 € par heure d'ingénieur, sur la base de semaines de 40 heures : des exemples de planification pour une application de taille moyenne, pas des devis. Les licences et le temps de vos propres équipes s'y ajoutent.

Phase (illustratif)Équipe et duréeHeuresCoût illustratif
Évaluation et feuille de route : inventaire, carte des dépendances, stratégie par composant, première tranche2 ingénieurs × 2 semaines160 h7 200–10 400 €
Filet de sécurité : tests de caractérisation, CI, supervision pour le premier périmètre2 ingénieurs × 3–4 semaines240–320 h10 800–20 800 €
Une tranche : développement, tests, mise en production derrière la façade3 ingénieurs × 4–6 semaines480–720 h21 600–46 800 €
Migration des données de cette tranche : correspondances, scripts, rapprochement, répétitions2 ingénieurs × 3–5 semaines240–400 h10 800–26 000 €
Fonctionnement en parallèle et accompagnement de la bascule2 ingénieurs × 2–4 semaines160–320 h7 200–20 800 €
Décommissionnement : archive, suppression des routes, nettoyage1 ingénieur × 1–2 semaines40–80 h1 800–5 200 €

Comment budgéter : financez l'évaluation seule, car c'est elle qui décide s'il faut conserver, remplacer ou reconstruire. Financez ensuite le filet de sécurité et la première tranche comme une décision distincte ; la première tranche révèle la vraie vitesse, relecture et rapprochement compris. Budgétez la suite tranche par tranche sur cette base, gardez une réserve à la mesure de ce que l'évaluation a révélé, et comptez les deux coûts d'exploitation, car l'ancien système coûte jusqu'à la phase 6.

Pour un programme de plusieurs tranches, une équipe stable garde le savoir en un seul endroit : notre renfort d'équipe s'intègre à vos développeurs, et les squads démarrent à 15 000 € par mois. Pour situer la modernisation dans un programme IA plus large, voir notre feuille de route de mise en œuvre de l'IA.

Choisir un partenaire de modernisation legacy

Six questions qui distinguent un partenaire de modernisation d'un simple atelier de réécriture :

  1. Commencez-vous par une évaluation, ou par une proposition de réécriture ?
  2. Comment capturez-vous le comportement actuel avant de modifier quoi que ce soit ?
  3. Quels outils d'IA liront notre code, à quelles conditions sur les données, et qui relit leur production ?
  4. Comment migrez-vous et rapprochez-vous les données, et combien de répétitions prévoyez-vous ?
  5. Quel est le plan de retour arrière pour chaque tranche ?
  6. À qui appartiennent le code, les tests et la documentation, et travaillez-vous dans nos dépôts ?

Notre offre de modernisation legacy couvre le découpage de monolithes en services et la mise à niveau progressive de piles .NET, Java ou PHP obsolètes. Nos réponses : une proposition dans les 24 heures suivant le premier échange ; NDA et cession de propriété intellectuelle avant le début des travaux ; nous travaillons dans vos dépôts et comptes cloud, et le code vous appartient. Les ingénieurs démarrent environ 48 heures après que vous avez validé leurs profils, avec une période d'essai de deux semaines : si vous n'êtes pas satisfait, vous ne payez pas, et le remplacement se fait sans surcoût. L'équipe travaille depuis Prishtina, à l'heure de Paris et de Berlin (CET/CEST).

Questions fréquentes

Qu'est-ce que la modernisation applicative ?

La mise à jour ou le remplacement d'un ancien système dont l'activité dépend encore, pour le rendre moins coûteux à exploiter, plus sûr et plus facile à faire évoluer. Les options vont de la conservation au remplacement par un progiciel, en passant par le déplacement, la restructuration ou la réécriture.

L'IA peut-elle réécrire automatiquement un système COBOL ou legacy ?

Non. L'IA explique le code, génère des tests et ébauche des traductions rapidement, mais des personnes doivent confirmer quelles règles s'appliquent encore, rapprocher les données et préparer la bascule. La production de l'IA est un brouillon que les tests et les relecteurs doivent accepter.

Faut-il refactoriser ou réécrire ?

Refactorisez si la conception tient mais que le code est difficile à modifier ; reconstruisez si le système est cœur de métier et irréparable. Dans les deux cas, avancez par tranches derrière une façade strangler fig plutôt qu'en une seule mise en production « big bang ».

Combien de temps dure une modernisation legacy ?

Cela dépend de la taille, des données et des contraintes. À titre illustratif, une évaluation prend environ deux semaines et une tranche de quelques semaines à quelques mois, migration des données et fonctionnement en parallèle compris.

Combien coûte une modernisation legacy ?

À titre illustratif, à nos tarifs de 45–65 € par heure d'ingénieur : une évaluation 7 200–10 400 €, un filet de sécurité 10 800–20 800 € et une tranche avec sa migration de données environ 32 000–73 000 €. Votre système, vos données et vos contraintes fixent le chiffre réel.

Peut-on confier notre code legacy à des outils d'IA en toute sécurité ?

Oui, avec des règles : des outils autorisés sous des conditions qui excluent l'entraînement, secrets et données personnelles retirés au préalable, des agents aux droits minimaux et une relecture humaine de chaque modification.

Modernisez votre système legacy, une tranche sûre à la fois

Parlez-nous du système, de ses utilisateurs et de ses données. Nous l'évaluons, posons le filet de sécurité de tests et le faisons évoluer pas à pas, avec l'IA là où elle aide et des ingénieurs seniors sur chaque modification.

Construisons ce qui vient ensuite.

Dites-nous ce que vous souhaitez construire ou faire évoluer. Vous recevrez une proposition et une estimation sous 24 heures.

Ou écrivez-nous directement

hello@elitics.io+383 49 171 069

Dukagjini Center, Prishtina, Kosovo