L’IA n’analyse pas votre code legacy : c’est un parser qui l’analyse
Par Xavier Franco, CEO de Elternativa · Grupo Zemsania
· 7 min de lecture
Rédigé avec l’aide de l’IA et relu par Xavier Franco

Dans cet article
- La vraie peur, ce n’est pas le langage
- Pourquoi il ne suffit pas de le demander à une IA
- D’abord le déterminisme, ensuite l’IA
- La documentation que vous n’avez jamais eue
- Les personnes qui le connaissent, en validateurs
- Et ensuite, comparer avec des données réelles
- Ce qu’il faut demander à qui vous propose de documenter votre legacy
- Par où commencer
- Comment nous vous aidons
Quand on parle de moderniser des systèmes legacy avec l’IA, la question qui revient le plus est : « et si l’IA inventait ce que fait mon système ? ». C’est une question très sensée. Et ma réponse est la suivante : l’IA ne doit pas analyser votre code. C’est un parser qui doit l’analyser. L’IA vient ensuite, pour l’expliquer.
La vraie peur, ce n’est pas le langage
Un système legacy ne fait pas peur parce qu’il est écrit en COBOL, en Visual Basic 6, en Oracle Forms ou en PL/SQL. Il fait peur parce que personne ne sait vraiment ce qu’il fait. Des décennies de modifications, des règles métier cachées dans un programme, des intégrations que seule une personne comprend et une documentation qui n’est plus mise à jour depuis des années.
Avant de migrer, de moderniser ou même de maintenir un tel système, il faut le comprendre. Et le comprendre doit être quelque chose que l’on peut vérifier.
En pratique : demandez à votre équipe où se trouve la documentation de votre système le plus ancien et de quand elle date. S’ils hésitent, vous savez par où commencer.
Pourquoi il ne suffit pas de le demander à une IA
Les modèles de langage sont extraordinaires pour expliquer du code. Mais ils ont un trait qu’il vaut mieux ne pas oublier : quand ils ne savent pas quelque chose, ils le complètent parfois avec quelque chose qui sonne juste.
Une étude l’illustre très bien. Un groupe de chercheurs a analysé 576 000 extraits de code générés par 16 modèles et a constaté que 19,7 % des paquets recommandés n’existaient pas. Au total, plus de 205 000 noms de paquets inventés. C’est un cas précis, celui des dépendances, mais le schéma est général : un modèle peut donner une réponse assurée, bien rédigée et fausse.
Si ce modèle est celui qui vous dit quelles règles métier contient votre système de facturation, le risque est évident. Une règle inventée est migrée comme si elle était réelle. Une règle omise disparaît en silence.
D’abord le déterminisme, ensuite l’IA
C’est pourquoi, dans notre approche, l’analyse se fait en deux couches :
- Le parser lit le code. Une analyse déterministe : le même code donne toujours le même résultat. Il extrait les programmes, les dépendances, les données lues et écrites, les appels, les conditions et les règles. Chaque élément est relié à la ligne de code dont il provient.
- L’IA l’explique. Sur la base de cette analyse, l’IA rédige la documentation fonctionnelle et technique dans un langage que comprend le métier. Elle explique, résume et ordonne. Mais elle n’invente pas ce que fait le programme, car le parser l’a déjà dit.
La différence est énorme. Avec l’IA seule, vous avez une interprétation. Avec le parser en amont, vous avez une carte que l’on peut vérifier, et chaque phrase de la documentation peut être retracée jusqu’à son origine.
En pratique : quand quelqu’un vous propose de documenter votre système avec l’IA, demandez comment on vérifie que chaque règle documentée existe dans le code. Si la réponse est « nous relisons à la fin », ce n’est pas suffisant.
La documentation que vous n’avez jamais eue
Le résultat, quand on procède ainsi, est quelque chose que beaucoup d’organisations n’ont jamais eu : une documentation fonctionnelle et technique extraite du code lui-même, qui dit ce que fait le système aujourd’hui, et non ce que quelqu’un croyait qu’il faisait.
Et elle a un effet qui se voit tout de suite : ce qui n’est pas utilisé apparaît. Des programmes que personne n’appelle, des rapports que personne ne demande, des processus restés « au cas où ». Cela ne se migre pas : cela s’éteint.
Les personnes qui le connaissent, en validateurs
Un parser ne remplace pas celles et ceux qui connaissent le système. Au contraire : il leur donne un outil. Les deux ou trois personnes qui savent pourquoi une règle existe ou quel processus on ne touche pas en fin de mois passent à valider la documentation extraite du code, règle par règle.
Leur savoir, qui est aujourd’hui dans leur tête, est consigné par écrit et relié au code. Pour moi, c’est l’une des meilleures nouvelles quand on modernise un tel système : vos personnes clés cessent d’être un risque et deviennent celles qui donnent le feu vert.
En pratique : installez vos experts devant la documentation issue du code. S’ils la valident, la moitié de la modernisation est faite.
Et ensuite, comparer avec des données réelles
Comprendre le système est la première étape. Lors de la reconstruction, le même principe s’applique à la fin : le nouveau système et l’ancien tournent en parallèle et sont comparés cas par cas, avec vos données réelles. Rien n’est coupé tant que cela ne concorde pas.
Ainsi, l’IA travaille sur ce qu’elle fait le mieux (expliquer, écrire, reconstruire) et la vérité est apportée par deux choses qui n’hallucinent pas : le code et les données.
Ce qu’il faut demander à qui vous propose de documenter votre legacy
Les offres pour documenter ou moderniser des systèmes legacy avec l’IA sont de plus en plus nombreuses. Avant de choisir, je demanderais cinq choses :
- Traçabilité : que chaque règle documentée indique de quel programme et de quelle ligne elle provient.
- Répétabilité : que le même code donne toujours la même analyse. Si vous l’exécutez deux fois et que le résultat change, ce n’est pas une analyse : c’est une opinion.
- Lecture seule : que le scan lise vos systèmes sans les toucher ni les modifier.
- Ce qui n’est pas utilisé, signalé : que l’inventaire indique ce qui tourne et ce qui est à l’arrêt depuis des années.
- Validation par vos équipes : que vos experts relisent la documentation avant que quoi que ce soit soit réécrit.
Si une proposition ne remplit pas ces cinq critères, la documentation sera peut-être belle, mais vous ne pourrez pas vous y fier pour décider. Et dans un système critique, une documentation à laquelle on ne se fie pas est presque pire que pas de documentation du tout.
En pratique : demandez à n’importe quel prestataire de documenter l’un de vos programmes et d’indiquer, pour chaque règle, la ligne dont elle provient. C’est le test le plus rapide.
Par où commencer
- Choisissez un système circonscrit, avec une valeur métier et quelqu’un qui le connaît.
- Inventoriez-le en lecture seule et extrayez-en la documentation à partir du code.
- Faites-la valider par vos experts, règle par règle.
- Repérez ce qui n’est pas utilisé et éteignez-le.
- Décidez avec cette documentation de moderniser, de migrer ou de conserver.
Comment nous vous aidons
Dans Migration de code et d’applications, nous migrons COBOL et mainframe, Visual Basic 6, Access, Oracle Forms et PL/SQL vers le langage de votre choix. Nous commençons par inventorier le code en lecture seule et documenter ce qu’il fait en l’extrayant du code, et non de la mémoire de quelqu’un ; ensuite nous le reconstruisons et basculons processus par processus avec une parité mesurée.
Nous le faisons avec le module de migration de Datagentis, qui scanne vos systèmes en lecture seule, documente ce qu’ils font et génère le plan pour migrer ce qui doit sortir.
Ce que fait votre système le plus ancien est-il documenté ?
Lors d’une démo, sur une application legacy d’exemple, nous vous montrons comment on extrait du code la documentation fonctionnelle et technique, règle par règle.


