Actualités technologiques

Migration de code native IA

Cédéric Noël16 juillet 2026

Le développement logiciel repose depuis longtemps sur une hypothèse tacite : la valeur des développeurs tiendrait à la quantité de code qu’ils écrivent eux-mêmes.

Cette hypothèse est désormais un handicap.

Récemment, j’ai migré en une demi-journée une fonctionnalité de production non triviale d’une application Rails vers Java Spring Boot, un travail qui aurait facilement pu prendre plus d’une semaine avec l’ancienne méthode.

Cet écart ne tient pas à la vitesse. Il tient à une autre façon de travailler.

L’ancienne méthode avait un coût caché

Voici à quoi ressemble l’approche traditionnelle pour porter une fonctionnalité :

  • – Lire le code source et garder tout le modèle mental en tête
  • – Le traduire, classe par classe, dans le nouveau langage
  • – Découvrir des cas limites en pleine implémentation
  • – Passer à côté de ce qui est enfoui quatre niveaux plus bas dans une fonction de rappel
  • – S’en rendre compte en assurance qualité. Ou en production

Un système où la charge cognitive est le goulot d’étranglement. Un système où les bogues les plus dangereux sont ceux auxquels on n’a même pas pensé à penser. Un système où « je connais cette base de code » est un prérequis qui prend des mois à acquérir.

Pendant ce temps, nos outils ont changé. L’IA les a transformés plus vite que la plupart des équipes d’ingénierie ne veulent bien l’admettre.

Le problème était bien réel

En bref : nous avions une fonctionnalité qui n’existait que dans notre ancienne application, et nous en avions besoin dans la nouvelle.

Notre client utilisait une ancienne application, construite en Ruby on Rails. Au fil du temps, nous avions entrepris de tout reconstruire dans une nouvelle application en Java, afin de suivre l’orientation qu’il voulait donner à l’ensemble de sa pile technologique. La majeure partie du produit avait déjà migré, mais la migration se poursuit. Une fonctionnalité en particulier (une fonction bien réelle, activement utilisée, qui communique avec un service externe pour vérifier des renseignements) ne fonctionnait encore que dans l’ancienne application. Elle n’avait pas encore été portée.

Chaque fonctionnalité encore coincée dans l’ancienne application empêche un peu plus cette migration d’aboutir. Quelqu’un devait transférer celle-ci, fidèlement, sans rien perdre en chemin.

La situation est plus courante qu’on pourrait le croire. Toute équipe qui a déjà « modernisé » un système a vécu ce moment précis : la nouvelle version est terminée à 95 %, et les 5 % restants se résument à un élément récalcitrant auquel personne ne veut toucher, parce qu’il est enchevêtré, qu’il est facile de s’y tromper subtilement et qu’il est fastidieux à réécrire à la main.

L’ampleur du travail était bien réelle :

  • Trois fichiers sources, chacun avec ses propres cas limites
  • Une couche de base de données avec une logique d’upsert et une gestion manuelle des horodatages
  • Des appels au service externe, avec des règles de version qui différaient d’un flux à l’autre
  • Des téléversements d’images qui devaient se faire en arrière-plan, sans bloquer l’utilisateur
  • Des codes d’erreur associés à des résultats précis
  • Des règles d’ordonnancement qui comptaient vraiment pour le service externe
  • Deux anciennes intégrations secondaires que nous avions volontairement cessé d’utiliser il y a des années, sans jamais les retirer

Mal faire ce travail, c’était s’exposer à des défaillances silencieuses en production. Le faire correctement à la main, c’était bien plus d’une semaine de traduction minutieuse et épuisante.

Il y avait une troisième option.

Ne commencez pas par le code. Commencez par la spécification.

Le premier geste n’a pas été d’ouvrir un IDE. Il a été d’extraire le savoir avant de toucher à quoi que ce soit.

Je savais déjà quels étaient les trois fichiers Ruby qui contenaient toute la logique pertinente. J’ai donc demandé à Claude de lancer trois agents en parallèle, un par fichier, avec une seule consigne : tout recueillir. Pas résumer. Recueillir. La structure des appels HTTP. Les champs du corps des requêtes et leur ordre. Les champs de réponse dont nous avions besoin. Les opérations sur la base de données. Les codes d’erreur. Les valeurs de configuration. Les cas limites. Les lignes de journal.

Des agents en parallèle, parce que les gains de vitesse se cumulent. Si chaque fichier prend dix minutes, trois agents successifs coûtent trente minutes. Trois agents en parallèle en coûtent dix.

Sur de petits fichiers, la différence est modeste. Sur des bases de code volumineuses, truffées de références croisées, c’est la différence entre une heure de travail concentré et une matinée perdue.

Une fois le travail des agents terminé, j’ai demandé une synthèse : un seul document de spécification d’implémentation, conçu pour construire, pas pour lire. Concret. Prescriptif. Chaque section correspondant à une classe ou à une méthode à livrer.

Ce fichier est devenu le contrat.

En même temps, pendant que ces agents travaillaient, j’ai fait passer un autre agent dans le code existant du service de vérification de l’application Java. Parce qu’on ne porte pas du code dans le vide. L’application Java comptait déjà VerificationApiClient, VerificationConstants, un flux de synchronisation par lots et des patrons bien établis. Le nouveau travail devait prolonger l’existant, sans le masquer ni le dupliquer.

Deux pistes en parallèle. Toutes deux terminées avant qu’une seule ligne de Java soit écrite.

Relisez ce que vous avez généré. C’est là le vrai travail.

Voici l’étape que les gens sautent. J’ai lu toute la spécification avant de demander à Claude d’écrire quoi que ce soit.

C’est là que j’ai repéré une intégration tierce morte : un appel à un service externe, enfoui dans une fonction de rappel after_commit de l’application Rails. Nous ne l’utilisions plus depuis quatre ans. Personne ne l’avait supprimée. Claude l’a trouvée, l’a comprise et l’a fidèlement incluse dans la spécification. Si je ne l’avais pas repérée, nous aurions livré du code qui appelait un service qui n’existait plus pour nous.

C’est là que j’ai repéré une fonctionnalité expérimentale abandonnée : une fonction que nous avions mise à l’essai, puis écartée, et laissée dans la base de code sans la retirer. Elle aussi était incluse. Elle aussi a été supprimée avant le début de l’implémentation.

Impossible de repérer l’une ou l’autre simplement en lisant le code. Le code ne sait pas qu’il est mort : il a l’air tout aussi légitime que tout ce qui sert encore. Si on les a repérées, c’est uniquement parce qu’une personne se souvenait de les avoir mises de côté, et pourquoi.

C’est dans la spécification que s’exerce le jugement. C’est dans la spécification que se prennent les décisions.

C’est le travail que l’IA ne peut pas faire à votre place. La spécification, c’est là que vous définissez ce qui sera construit et ce qui sera délibérément laissé de côté.

Nettoyez la spécification. Ensuite, construisez.

L’implémentation, c’est la partie facile

Avec les deux documents en main (ce qu’il fallait construire et ce qui existait déjà), j’ai demandé à Claude d’implémenter la fonctionnalité.

Ce qu’il a produit en une seule passe : un contrôleur. Un service de routage. Un service d’authentification. Un service d’empreinte. De nouvelles méthodes de client d’API, bien intégrées à côté du flux par lots existant. Un DTO de réponse. Un service asynchrone de téléversement d’images. Une classe d’exception typée. Un ensemble complet de constantes.

Il a aussi écrit des tests unitaires pour chaque service et des tests d’intégration pour le point de terminaison, automatiquement, parce que les conventions pour le faire étaient déjà définies.

Le tout compilait. La structure était correcte. La logique d’affaires correspondait à la spécification.

Une section était erronée.

Là où l’IA se trompe, et pourquoi c’est votre travail

L’application Rails déclenchait les téléversements d’images vers GCP au moyen d’une fonction de rappel after_commit. Un patron propre à Rails : lancer une action une fois la transaction de base de données validée, en dehors des limites de cette transaction.

Claude a parfaitement compris l’intention. Il a tenté de reproduire le patron, et c’est là que tout a déraillé.

Java n’offre pas d’équivalent direct au after_commit de Rails. Le code généré autour de cette section était alambiqué : il tentait d’imiter quelque chose qui ne se transpose pas proprement. Il n’aurait pas fonctionné.

L’IA sait quel doit être le comportement. Elle ne connaît pas toujours l’idiome qui convient sur la plateforme de destination. C’est à vous de combler cet écart.

J’ai donné à Claude du contexte sur la façon dont l’application Java gère déjà le travail asynchrone, je lui ai demandé une réécriture et j’ai obtenu une méthode @Async propre : correcte, idiomatique, non bloquante. La bonne réponse en Java.

  • – approximation alambiquée d’after_commit, qui n’aurait pas fonctionné
  • + méthode @Async propre : correcte, idiomatique, non bloquante

Une correction. Trente secondes. Mais seulement parce que j’ai relu.

Ce que les tests ne détecteront pas

Au-delà de ce problème évident, il existe une catégorie de bogues silencieux. Le point de terminaison répond. Les tests passent. Et pourtant, quelque chose cloche en production parce qu’une règle subtile a été enfreinte.

Voici ce que j’ai vérifié explicitement par rapport à la spécification :

  • Selon le type de requête, le service externe attend un numéro de version différent. Envoyez le mauvais et rien ne plante : il renvoie simplement, sans bruit, des données différentes et erronées.
  • Ce même service tient aussi à l’ordre dans lequel vous demandez les choses. Demandez-les dans le mauvais ordre et les résultats deviennent peu fiables, même si la requête elle-même semble parfaitement correcte.
  • Quand il n’y a rien à signaler, le service ne renvoie pas d’erreur : il renvoie un « succès » normal, simplement accompagné d’un résultat vide. Si vous ne vérifiez que les échecs francs, vous ne verrez pas la différence entre « ça a fonctionné, et il n’y a rien ici » et « ça a vraiment planté ».
  • Le chemin que prend ensuite un enregistrement n’est pas déterminé par ce que nous avons demandé, mais par ce que le service nous a réellement répondu. Partez du principe qu’il dépend de la requête, et les enregistrements seront acheminés au mauvais endroit.
  • Quand quelqu’un retourne un article et qu’il est revérifié, le système doit mettre à jour l’enregistrement d’origine, pas en créer un nouveau, et il ne doit jamais toucher aux champs qui retracent l’historique de cet article. Une erreur à ce niveau, et vous corrompez sans bruit la trace du parcours de l’article.
  • Les horodatages de « création » et de « dernière mise à jour » ne sont pas gérés automatiquement ici : ils doivent être définis à la main, exactement aux bons endroits, sinon l’historique d’un enregistrement devient discrètement inexact.

Chacun de ces points figurait dans la spécification, sous forme d’élément de liste de vérification. Chacun serait passé inaperçu lors d’une revue de code standard.

La mauvaise question à propos de l’IA

Les gens n’arrêtent pas de demander : « L’IA va-t-elle remplacer les développeurs ? »

Mauvaise question. La vraie question est la suivante : « Quel type de développeur survit dans un flux de travail natif IA ? »

La réponse devient évidente. Pas celui qui écrit le plus de code. Pas celui qui mémorise le plus de syntaxe. Pas celui qui garde jalousement ses connaissances de peur que les partager le rende superflu.

Le développeur qui survit, c’est celui qui sait :

  • Comprendre les systèmes assez en profondeur pour savoir quelles questions poser
  • Fournir un contexte assez précis pour que l’IA produise un résultat exact
  • Examiner le résultat d’un œil assez critique pour repérer ce que l’IA ne peut pas savoir
  • Trancher sur ce qu’il faut construire et ce qu’il faut laisser de côté
  • Transposer un comportement d’un paradigme à l’autre quand les idiomes ne correspondent pas

Le travail de traduction répétitif est en voie d’automatisation. Tant mieux. Nous pouvons enfin consacrer notre attention aux aspects qui ont vraiment besoin de nous : quoi construire, pourquoi, et si ce qui a été construit est vraiment correct.

Les chiffres

  • – Sans cette approche : une semaine ou plus
  • + Avec cette approche : une demi-journée

Je n’ai pas écrit une seule ligne de Java à la main. J’en ai lu chaque ligne, j’ai pris chaque décision à son sujet et j’ai repéré ce que l’IA avait mal fait.

Ce n’est pas l’IA qui remplace un développeur. C’est un développeur qui a cessé de faire les parties du travail qui n’exigent pas un développeur.

Le virage est déjà amorcé

Certains développeurs continueront de travailler à l’ancienne et appelleront ça de la rigueur. D’autres confieront tout à l’IA et considéreront le travail comme terminé, puis apprendront à leurs dépens que l’automatisation sans jugement n’est qu’une façon d’échouer plus vite.

Ceux qui l’emportent comprennent où se trouve vraiment le levier.

Pas dans l’écriture. Dans la réflexion. Pas dans le volume de code produit. Dans la qualité des décisions prises.

Ce développeur n’est pas remplacé. Il est propulsé.

Notre façon de bâtir des logiciels est en train de changer. Pas un jour. Dès maintenant.

La seule question est de savoir si votre flux de travail a déjà pris le virage.

Retour au CodeBlog