Refactoriser 10 000 lignes de legacy avec l'IA : retour d'expérience réel en 2 semaines

Début octobre, j’ai reçu un projet urgent : un système de gestion de commandes Vue 2.x d’environ 10 000 lignes de logique métier, couverture de tests inférieure à 10 %, gestion d’état si chaotique qu’on ne comprenait plus le flux des données — et personne n’y avait touché depuis 3 ans. Le chef m’a donné 2 semaines pour refactoriser et mettre en production.

Deux semaines pour refactoriser et livrer.

Mon premier réflexe : c’est de la provocation. En refactorisation manuelle classique, comprendre la logique métier prend déjà une semaine ; modifier prudemment, écrire les tests, valider — 30 à 40 jours ne suffiraient pas forcément. Mais le métier ne pouvait plus attendre : le système était si lent que les utilisateurs se plaignaient.

Puis je me suis souvenu de Claude Code, recommandé par un ami pour les refactorisations massives. Franchement, j’étais sceptique — refactoriser du code avec l’IA, est-ce sérieux ? Et si tout cassait ?

Je n’avais pas le choix. J’ai tenté.

Deux semaines plus tard, en appuyant sur déployer et en voyant le tableau de bord de monitoring tout au vert, l’émotion était réelle. La refactorisation a pris 14 jours, zéro incident en production, temps de réponse des API amélioré d’environ 20 %, taux de bugs en baisse d’environ 40 %.

Cet article raconte comment ces 14 jours se sont passés, les pièges rencontrés et ce que vous pouvez réutiliser. Si vous avez une dette technique similaire ou si la refactorisation assistée par IA vous intéresse, cela devrait vous aider.

Contexte du projet : à quel point c’était le chaos

Commençons par le niveau de désordre.

C’est un système central de gestion de commandes, environ 5 000 commandes par jour : création, paiement, suivi logistique, SAV, plus d’une dizaine de flux métier. Code Vue 2.x écrit début 2022 ; le dev frontend est parti juste après, puis 4 personnes ont maintenu le système en y collant des rustines, chacune avec son style.

À quel point c’était grave ? Deux jours entiers de diagnostic, résultats accablants :

1. 10 000 lignes de logique métier, fichiers isolés jusqu’à 1 800 lignes, OrderService.js le plus lourd avec 47 méthodes
2. Couverture de tests < 10 %, quelques tests unitaires simples, logique critique non couverte
3. Gestion d’état chaotique : Vuex, LocalStorage, SessionStorage, bus d’événements global — quatre approches mélangées, flux de données illisible
4. Duplication massive : la même logique de statut de commande, 23 copies collées
5. Problèmes de performance : liste des commandes en 3-4 secondes, plaintes utilisateurs

Le pire : malgré le chaos, le système tournait en prod et servait des milliers d’utilisateurs. Impossible de tout casser d’un coup — une erreur et l’activité s’arrête.

Combien de temps en refactorisation classique ?

Alibaba Cloud - Choix n°1 des développeurs, 15 % de réduction exclusive sur Lighthouse

Obtenir -15 % →Pub

Au tableau blanc :

1. Comprendre la logique métier (5-7 jours estimés)
2. Compléter les tests (7-10 jours)
3. Découper les modules (10-15 jours)
4. Refactoriser et valider module par module (8-12 jours)
5. Tests d’intégration + déploiement progressif (5 jours)

Total : au minimum 35 jours, sans compter les retours en arrière.

Or je n’avais que 14 jours.

Pourquoi Claude Code

Avant de miser sur l’IA, j’étais incertain aussi.

Beaucoup d’outils : GitHub Copilot que j’utilise déjà, Cursor dont j’entends du bien, Claude Code plus récent. Pourquoi Claude Code au final ?

Une petite expérience

Une demi-journée sur la fonction la plus complexe — mise à jour du statut de commande, 200+ lignes, limites, appels async, gestion d’erreurs. J’ai demandé aux trois outils de refactoriser.

Résultats :

• GitHub Copilot : suggestions fragmentées, plutôt complétion ligne par ligne ; insuffisant pour une refactorisation massive.
• Cursor : bon, comprend l’intention, suggestions raisonnables ; sur la logique métier complexe, parfois « à côté », il faut réexpliquer le contexte.
• Claude Code : impressionnant — refactorisation, 3 bugs potentiels identifiés, conseil de tester d’abord, étapes détaillées.

Point clé : compréhension du contexte. Fenêtre 200K tokens : je peux lui donner tout le cœur du projet ; il voit les liens entre modules, pas seulement un fichier.

"La fenêtre de contexte 200K tokens de Claude Code peut contenir environ 150 000 mots de code, suffisant pour comprendre la logique métier centrale et les relations entre modules d’un projet de taille moyenne."

Refactorisation en pratique : comment se sont passés les 14 jours

Voici le concret : étapes et pièges.

Préparation : filet de sécurité (jours 1-2)

La peur en refactorisation, c’est de casser. La première étape n’est pas de toucher au code, mais de poser un filet de sécurité.

Tâche 1 : compléter les tests

Première demande à Claude Code : générer des tests.

Moi : Voici le cœur du module commandes (3000 lignes collées),
analyse les flux métier clés et génère des tests complets,
en couvrant création, paiement, remboursement, transitions de statut, etc.

Claude a dépassé mes attentes : tests unitaires classés par scénario, commentaires clairs. Quelques ajustements sur les cas limites ; en deux jours, couverture de 10 % à 45 %.

En manuel, une semaine minimum.

Tâche 2 : diagnostic du code

Avec les tests en place, diagnostic global :

KiloClaw - OpenClaw managé pour l’entreprise : orchestration d’agents IA et routage intelligent

Commencer →Pub

Moi : Analyse la qualité du code de ce projet,
focus : code smells, logique dupliquée, goulots d'étranglement, bugs potentiels.
Rapport détaillé.

Résultat : rapport de 20 pages (imprimé, vraiment 20 pages) :

• 87 code smells (fonctions trop longues, imbrication, nommage, etc.)
• 23 logiques dupliquées
• 14 problèmes de performance possibles
• 5 bugs possibles (2 confirmés ensuite)

Ce rapport est devenu ma feuille de route.

Exécution : l’art de la collaboration homme-IA (jours 3-10)

En refactorisant, j’ai trouvé un rythme avec Claude Code.

Rythme 1 : commencer par ce qui fait mal

Première cible : la fonction processOrder de 800 lignes — validation, stock, remises, paiement, notifications… tout empilé, cauchemar à maintenir.

Moi : processOrder est trop gros, refactorise avec :
1. Petites fonctions à responsabilité unique
2. Chaque fonction < 50 lignes
3. Logique commune extraite en utilitaires
4. Compatibilité fonctionnelle 100 %
5. Tests pour chaque nouvelle fonction

Plan détaillé : 800 lignes → 6 fonctions :

• validateOrderParams() — validation
• checkInventory() — stock
• calculateDiscount() — remises
• processPayment() — paiement
• sendNotifications() — notifications
• createOrder() — orchestration

Responsabilités claires, tests plus simples. En manuel : 3 jours ; avec Claude Code : une demi-journée.

Qualité : la validation qu’on ne peut pas sauter (jours 11-13)

Le code modifié n’est pas la fin — la validation l’est. Trois jours de tests.

Couche 1 : tests automatisés

• Tests unitaires : 187 cas, tous passés
• Tests d’intégration : 34 scénarios, 100 %
• E2E : parcours métier principal

Les tests générés avant ont été décisifs.

Couche 2 : revue de code
Revue automatisée avec Claude : 2 problèmes — nommage d’une variable, appel async sans gestion d’exception.

Mise en production et monitoring : le moment le plus tendu (jour 14)

25 octobre, vendredi, 15 h, creux d’activité.

Déploiement progressif :

• 15 h00 — 5 % du trafic, monitoring 30 minutes
• 15 h30 — 10 %
• 16 h00 — 30 %
• 17 h00 — plein trafic

Je fixais le tableau de bord, mains moites. L’équipe en ligne, prête à rollback.

Tout au vert ; temps de réponse moyen de 450 ms à 360 ms. Soulagement.

🔥 Ne perdez plus des mois sur des produits sans demande ! Validez vos promesses SaaS avec Adsterra à petit budget →

Tester l'MVP →Pub

Résultats finaux :

• Zéro incident en production
• Temps de réponse API -20 %
• Taux de bugs -40 %
• Score SonarQube de C à A
• Couverture de tests de 10 % à 75 %

Bibliothèque de modèles Prompt efficaces

Quatre modèles réutilisables, à copier et adapter.

Modèle 1 : diagnostic

J'ai un projet [type de projet] en [stack technique].
Code métier central : [coller le code]

Diagnostic complet, focus :
1. Code smells (fonctions longues, imbrication, nommage, etc.)
2. Logique dupliquée et code commun extractible
3. Goulots d'étranglement performance
4. Bugs et risques sécurité possibles

Rapport détaillé, priorisé.

Modèle 2 : refactorisation

Refactorise ce code : [coller le code]

Exigences :
1. Fonctions à responsabilité unique, < [50] lignes chacune
2. Extraire la duplication en utilitaires
3. Améliorer le nommage, respecter [normes équipe]
4. Compatibilité fonctionnelle 100 %
5. Tests pour chaque nouvelle fonction

Contraintes :
- Ne pas changer la logique métier, seulement la structure
- Pas de nouvelles dépendances (sauf indication)
- Ne pas supprimer du code d'usage incertain — le signaler
- Style du projet : [décrire]

Contexte :
[appelants, structures de données, etc.]

Modèle 3 : génération de tests

Module [nom du module], code central : [coller le code]

Génère des tests complets :
1. Framework [Jest/Vitest, etc.]
2. Scénarios métier : [lister]
3. Cas limites (null, entrées invalides, extrêmes)
4. Exceptions (timeout réseau, erreurs API)
5. Commentaire par test expliquant l'objectif

Objectif couverture : > 70 %

Modèle 4 : revue de code

Refactorisation terminée, merci de revoir :

Avant : [coller]
Après : [coller]

Vérifier :
1. Nouveaux bugs ou erreurs de logique
2. Problèmes de performance (boucles inutiles, etc.)
3. Conformité [normes équipe]
4. Risques sécurité (SQL injection, XSS, etc.)
5. Clarté nommage et commentaires
6. Couverture de tests suffisante

Avis détaillé et recommandations.

Pour conclure

De l’anxiété de début octobre au code refactorisé aujourd’hui — on dirait qu’on s’en est sorti.

14 jours, 10 000 lignes, du monolithe à la prod : une autre vision du développement assisté par IA.

L’IA n’est pas une baguette magique : elle ne décide pas à votre place, ne comprend pas le métier pour vous, ne porte pas le risque. C’est un assistant puissant — comme un senior à côté de vous pour la revue, les tests, les alertes.

Le vrai gain vient de la collaboration homme-IA. Vous apportez le métier et le jugement ; l’IA, l’exécution et les bonnes pratiques. Une personne peut produire l’équivalent de trois, avec une meilleure qualité.

Si vous êtes dans la même situation :

1. Osez essayer : les outils IA sont matures
2. Petits pas : un petit module pour apprendre
3. Restez vigilant : l’IA est forte mais imparfaite — revue humaine obligatoire
4. Préparez-vous : tests, monitoring, rollback — rien ne se négocie

La dette technique ne se résout pas en repoussant. Avec Claude Code, la rembourser est moins douloureux — même gratifiant.