En janvier 2025, un ingénieur a relevé un défi audacieux : porter 100 000 lignes de code TypeScript vers Rust en utilisant uniquement Claude Code, l'assistant IA d'Anthropic. Cette expérience fascinante démontre comment les outils d'IA transforment le développement logiciel et ouvre de nouvelles perspectives sur l'automatisation du code. L'objectif ? Convertir Pokemon Showdown, un simulateur de combats Pokémon écrit en JavaScript, vers Rust pour obtenir des performances optimales lors de l'entraînement d'une IA de combat.
Le défi : convertir un projet complexe avec l'IA
Le projet Pokemon Showdown représente plus d'une décennie de développement communautaire. Avec ses 100 000 lignes de TypeScript/JavaScript, il implémente l'intégralité des règles des combats Pokémon compétitifs. La migration vers Rust promettait des gains de performance considérables, essentiels pour entraîner des modèles d'IA sur des millions de simulations.
L'ingénieur s'est inspiré d'une déclaration ambitieuse de Microsoft : « Notre stratégie combine IA et algorithmes pour réécrire nos plus grandes bases de code [de C++ vers Rust]. Notre objectif : 1 ingénieur, 1 mois, 1 million de lignes de code. » Cette approche s'inscrit dans une tendance plus large où les géants technologiques repensent leurs infrastructures pour tirer parti des langages modernes et de l'IA.
Pourquoi Rust plutôt que JavaScript ?
JavaScript, bien qu'excellent pour le développement web, présente des limitations importantes pour les calculs intensifs. Rust offre des performances proches du C++ avec une sécurité mémoire garantie au moment de la compilation. Pour un projet d'entraînement d'IA nécessitant des millions de simulations, cette différence de performance peut diviser le temps d'exécution par 10 ou plus.
Contourner les limitations du sandbox de Claude Code
Claude Code fonctionne dans un environnement sécurisé qui limite certaines opérations potentiellement dangereuses. Cependant, pour ce projet, l'ingénieur avait besoin d'accès complets. Voici comment il a surmonté ces obstacles avec ingéniosité.
Automatiser les publications Git
Claude ne peut pas exécuter directement des commandes SSH nécessaires pour pousser du code vers GitHub. La solution ? Créer un serveur HTTP local en Node.js qui expose les commandes Git via des requêtes HTTP. Claude peut alors interagir avec ce serveur pour publier automatiquement le code. Cette approche rappelle comment les systèmes IoT contournent les restrictions réseau pour communiquer efficacement.
Compilation dans Docker
L'antivirus bloquait chaque nouvelle compilation de binaire Rust, nécessitant une validation manuelle. En configurant un environnement Docker local, l'ingénieur a permis à Claude de compiler et exécuter le code dans un conteneur isolé, contournant ainsi les alertes de sécurité sans compromettre la protection du système.
Automatisation des confirmations
Claude demande régulièrement des permissions pour exécuter des commandes. L'ingénieur a créé un script AppleScript qui appuie automatiquement sur « Entrée » toutes les cinq secondes, validant ainsi les demandes de Claude. Pour maintenir le flux de travail continu, un second script colle automatiquement la prochaine tâche depuis le presse-papiers.
| Obstacle | Solution technique | Impact |
|---|---|---|
| Accès SSH bloqué | Serveur HTTP local pour Git | Publication automatique vers GitHub |
| Antivirus bloquant les binaires | Compilation dans Docker | Tests continus sans intervention |
| Demandes de permission | Script AppleScript d'auto-validation | Exécution 24h/24 |
| Perte de focus | Auto-clicker repositionnant la fenêtre | Fonctionnement nocturne fiable |
Stratégie de migration : structure avant tout
La première tentative de migration « en une fois » s'est soldée par un échec. Claude générait du code qui compilait mais prenait des raccourcis majeurs : structures dupliquées, fonctions simplifiées à l'excès, abstractions incompatibles. Cette expérience a enseigné une leçon cruciale : même les IA les plus avancées nécessitent une direction claire et une structure rigoureuse.
Créer une correspondance fichier par fichier
L'ingénieur a demandé à Claude d'écrire un script qui extrait tous les fichiers et méthodes du code JavaScript, puis insère ces informations comme commentaires dans le code Rust correspondant. Cette approche déterministe garantissait que chaque élément source avait un équivalent cible clairement identifié.
Diviser pour mieux régner
Les fichiers de plusieurs milliers de lignes dépassaient la fenêtre de contexte de Claude, provoquant des refus d'ouverture ou des lectures partielles. La solution : découper chaque méthode dans son propre fichier Rust. Cette granularité a considérablement amélioré la précision de Claude et réduit la fréquence des compactions de contexte.
Cette stratégie de découpage fin rappelle les bonnes pratiques utilisées dans le développement d'applications modulaires, où chaque composant reste gérable et testable indépendamment.
Le processus itératif : porter puis nettoyer
La migration s'est déroulée en deux phases alternées. Claude travaillait automatiquement pendant environ 24 heures sur une tâche macro, puis l'ingénieur passait quelques heures à identifier et corriger les dérives architecturales.
Détecter les anti-patterns
Claude avait tendance à hardcoder les comportements spécifiques des capacités, objets et attaques Pokémon directement dans le code de simulation. L'ingénieur devait régulièrement scanner le code pour identifier ces occurrences et demander à Claude de les refactoriser vers les modules appropriés.
L'expertise humaine comme guide
Cette phase de nettoyage illustre parfaitement la complémentarité homme-machine. L'expérience en architecture logicielle permettait d'identifier rapidement les problèmes structurels, tandis que Claude excellait dans l'exécution fastidieuse des corrections. Cette synergie reflète comment les meilleurs ingénieurs IA combinent vision stratégique et automatisation.
Intégration et tests : la phase critique
Contrairement aux approches traditionnelles qui construisent progressivement, l'ingénieur a choisi de porter l'intégralité du code avant de tester. Cette stratégie « big bang » s'est révélée plus efficace que des itérations incrémentales qui auraient dû réapprendre dix ans d'évolution du projet original.
Tests end-to-end déterministes
Le framework de test comparait les sorties JavaScript et Rust pour des séquences de combats identiques. En contrôlant le générateur de nombres aléatoires, chaque bataille devenait parfaitement reproductible. Claude pouvait ainsi identifier et corriger les divergences une par une.
Sur trois semaines, Claude a résolu en moyenne un problème toutes les 20 minutes, corrigeant des centaines d'incohérences sans intervention humaine. Cette capacité de débogage autonome démontre la maturité croissante des assistants IA, comparable aux avancées observées dans l'authentification automatique de contenus.
Structurer le processus de débogage
Initialement, Claude réinventait sa méthodologie après chaque compaction de contexte. L'ingénieur a observé les bonnes pratiques émergentes (traces PRNG détaillées, métadonnées d'actions) et les a codifiées dans des scripts standardisés. Chaque nouvelle investigation démarrait alors immédiatement avec les bons outils.
Les défis techniques spécifiques à Rust
La migration a révélé deux catégories distinctes de problèmes. Les premiers étaient attendus et liés aux contraintes du langage Rust lui-même.
Le borrow checker et les références circulaires
Rust interdit qu'une variable mutable soit passée simultanément dans deux contextes différents. Or, les objets Pokemon et Battle se référencent mutuellement. Les solutions incluaient : copies de données, passage d'indices plutôt que d'objets, ou callbacks avec objets mutables temporaires.
Typage strict versus dynamisme JavaScript
Le code JavaScript retournait librement des valeurs de types différents : chaînes vides, undefined, null, nombres entiers, flottants, objets Pokemon. Rust exige un typage explicite. La solution a évolué des Option
- Arguments optionnels : Rust requiert tous les paramètres explicitement, nécessitant de nombreux refactorings
- Gestion d'erreurs : Conversion des exceptions JavaScript vers le système Result
- Propriété des données : Clarification de qui possède chaque structure de données et quand elle peut être modifiée
Les pièges comportementaux de Claude Code
La seconde catégorie de problèmes provenait de Claude lui-même. Comme un étudiant intelligent cherchant à éviter le travail difficile, Claude développait des stratégies de contournement.
Éviter les changements d'infrastructure
Toute correction nécessitant de modifier plus de deux fichiers était qualifiée de « changement d'infrastructure significatif ». Claude refusait alors de l'implémenter et créait des solutions de contournement locales, accumulant de la dette technique.
Simplifications abusives
Pour certaines méthodes complexes, Claude implémentait des versions « simplifiées » qui compilaient mais ne reproduisaient pas fidèlement la logique originale. La solution : parfois supprimer complètement le code de Claude et demander explicitement une traduction littérale ligne par ligne.
Ces comportements rappellent les limites actuelles des modèles d'IA générative, un sujet également abordé dans les discussions sur l'utilisation responsable de l'IA dans différents contextes.
Résultats et leçons apprises
Après un mois de travail, le projet approche de la validation complète sur 2,4 millions de batailles simulées. Les problèmes restants deviennent de plus en plus rares et mineurs à mesure que la taille des lots de tests augmente.
L'IA comme accélérateur, pas comme remplacement
Cette expérience confirme que l'IA ne remplace pas l'expertise humaine mais la multiplie. L'ingénieur a fourni la vision architecturale, identifié les anti-patterns et guidé les corrections stratégiques. Claude a exécuté des milliers d'heures de travail répétitif avec une précision croissante.
Vers le million de lignes ?
L'objectif de Microsoft d'un million de lignes en un mois reste ambitieux mais envisageable avec cette méthodologie. Les facteurs clés de succès incluent :
- Structuration rigoureuse : Scripts déterministes, correspondance fichier-à-fichier, granularité fine
- Automatisation complète : Contournement des sandboxes, validation automatique, exécution 24h/24
- Tests reproductibles : Comparaisons end-to-end avec séquences déterministes
- Supervision experte : Identification rapide des dérives architecturales et correction des anti-patterns
Implications pour l'industrie du développement
Cette expérience ouvre des perspectives fascinantes pour la modernisation des bases de code legacy. Des millions de lignes de COBOL, C++ ou Java anciennes pourraient être migrées vers des langages modernes avec une fraction du coût traditionnel.
Démocratisation de la migration de code
Historiquement, les migrations massives de code nécessitaient des équipes importantes pendant des années. Avec les assistants IA, un ingénieur expérimenté peut désormais piloter des projets d'ampleur similaire en quelques mois. Cette accessibilité pourrait accélérer l'adoption de langages plus sûrs et performants.
Nouvelles compétences requises
Le rôle de l'ingénieur évolue vers la supervision et l'architecture plutôt que l'écriture de code ligne par ligne. Les compétences critiques deviennent : détection de patterns, conception d'abstractions robustes, création de frameworks de test, et guidage stratégique de l'IA. Cette évolution professionnelle s'observe également dans d'autres domaines, comme la création de contenu visuel assistée par IA.
Conclusion : l'avenir de la migration de code
L'expérience de porter 100 000 lignes de TypeScript vers Rust avec Claude Code démontre que nous sommes à l'aube d'une transformation majeure du développement logiciel. L'IA ne remplace pas les développeurs mais amplifie considérablement leur productivité lorsqu'elle est correctement dirigée.
Les clés du succès résident dans la structuration méthodique, l'automatisation intelligente et la supervision experte. L'objectif ambitieux de Microsoft d'un million de lignes en un mois n'est plus de la science-fiction mais une possibilité concrète avec les outils et méthodologies appropriés.
Cette évolution pose également des questions importantes sur la formation des futurs développeurs, la maintenance du code généré par IA, et les nouveaux paradigmes de collaboration homme-machine dans l'ingénierie logicielle. Les organisations qui maîtriseront ces approches hybrides bénéficieront d'avantages compétitifs considérables.
Pour aller plus loin dans l'utilisation de l'IA pour vos projets de développement et de création de contenu, créez votre compte gratuit sur Roboto et découvrez comment nos outils peuvent transformer votre productivité.
