Les modèles de langage génèrent massivement du Python — 90 à 97 % du temps — non par supériorité technique, mais parce qu’il domine les données d’entraînement. Cette boucle de rétroaction amplifie les langages établis tandis que Rust, Haskell et F# s’enferrent dans l’invisibilité. Une étude 2025 révèle comment l’IA redessine l’écosystème en concentrant le développement autour de trois à cinq langages.
La mécanique incontournable : des données au monopole
Python monopolise le corpus d’entraînement des LLMs. GitHub Copilot a été entraîné sur 159 gigaoctets de code Python provenant de 54 millions de dépôts publics. Les cinq langages les mieux représentés — Python, Java, C++, JavaScript/TypeScript et C# — dominent l’ensemble du corpus. Les centaines d’autres langages se partagent le reste.
Cette asymétrie déclenche une chaîne sans fin : plus il existe de code Python public, mieux les LLMs l’apprennent ; mieux ils le génèrent, plus les développeurs l’utilisent ; plus de code Python se retrouve sur GitHub, plus les générations futures de modèles le maîtrisent. Les langages populaires s’enferment dans une domination croissante. Les langages niche, étranglés par manque de données, restent prisonniers d’une qualité générée médiocre.
L'étude qui mesure le phénomène
L’étude de King’s College (mars 2025) teste huit LLMs majeurs — GPT-4o, Claude 3.5, Llama 3.2, DeepSeek, Mistral 7B — sur des benchmarks spécifiques. Les résultats révèlent l’ampleur du problème : les LLMs choisissent Python même dans des contextes techniquement inadaptés.
Pour un problème de parallélisme haute performance, le langage optimal serait Rust, Go ou C++. Les LLMs recommandent Rust dans leur justification textuelle. Mais quand ils produisent le code, Python domine avec 57 % des cas. Cette incohérence n’est pas un dysfonctionnement : elle révèle le mécanisme réel. Les modèles ne « pensent » pas le choix du langage. Ils prédisent des tokens selon leur fréquence dans les données d’entraînement.
L'anomalie révélatrice : conseiller n'est pas agir
Les LLMs exposent une contradiction structurelle : ils recommandent un langage dans 83 % des cas, puis en utilisent un autre pour le code réel. Aucune corrélation significative n’existe entre ce qu’ils conseillent et ce qu’ils produisent.
Claude suggère Java pour un problème distribué. Claude génère la solution en Python. Ces deux choix ne sont pas liés statistiquement. Un LLM génère une recommandation textuelle dans un contexte d’exécution. Puis il génère le code dans un autre contexte, où les 159 gigaoctets de Python dans l’entraînement reprennent le dessus. Il ne choisit pas délibérément Python. Il marche dans la trace que les données lui ont gravée.
2025 : le renouvellement du classement GitHub
TypeScript a surpassé Python sur GitHub pour la première fois en dix ans, avec une hausse de 66 % en un an. JavaScript, occupant la 3e place depuis des années, dégringole à la 6e. Bash, normalement détesté des développeurs, explose de 206 % dans les projets générés par IA.
Ces chiffres fragmentent le récit d’une simple domination pythonienne. Ils indiquent plutôt un réalignement de l’écosystème sous la pression de l’IA.
TypeScript : sécurité immédiate
TypeScript gagne non par supériorité intrinsèque, mais parce que les développeurs choisissent maintenant les langages pour leur compatibilité avec l’IA. TypeScript offre des types statiques — des annotations qui explicitent chaque variable. Quand un LLM génère du code TypeScript, le compilateur vérifie immédiatement si les types correspondent. Les erreurs sautent aux yeux.
Python, dépourvu de types obligatoires, laisse circuler les hallucinations de LLM qui ne se manifestent qu’à l’exécution, voire pas du tout. Moins de garanties signifie moins de confiance, moins d’adoption pour le code généré par IA. Les développeurs votent avec leurs pieds. TypeScript, jadis langage de niche Web, devient le choix structurel des équipes confiant du code aux LLMs.
Bash : l'anomalie qui révèle la mutation
Bash enregistre une hausse aberrante de 206 % dans les projets assistés par IA. Cela semble absurde : Bash est réputé pour sa syntaxe archaïque et ses pièges. Mais cette augmentation révèle une mutation profonde du critère de sélection.
Avant l’IA, la question était : aime-t-on écrire dans ce langage ? Avec l’IA, elle devient : le LLM peut-il le générer sans erreurs, et c’est la bonne solution technique ?
L’IA rend supportables les outils désagréables. Quand on peut demander à Claude de générer les scripts d’automatisation fastidieux, on n’hésite plus à utiliser Bash pour la raison technique — accès direct au système. Bash remonte pour la première fois en décennie, non malgré ses défauts, mais parce qu’un LLM absorbe cette charge.
Les langages niche : marginalisation silencieuse
Observe le paradoxe des bibliothèques. Polars est deux fois plus rapide que pandas et enregistre trois fois plus de croissance GitHub. Les LLMs testés ne la génèrent zéro fois. FastAPI surpasse Flask avec trois fois plus de croissance des stars. FastAPI apparaît dans les générations de trois LLMs seulement. Plotly, la meilleure solution de visualisation, apparaît une seule fois.
La même logique s’applique aux langages entiers.
Rust offre la sécurité mémoire et la performance. Haskell propose la rigueur logique et le typage fort. F# combine expressivité et typage fort. Tous trois sont techniquement supérieurs pour leurs domaines respectifs. Aucun n’a assez de données publiques pour entraîner correctement les LLMs.
Pas parce qu’ils sont mauvais, mais parce qu’ils n’ont pas suffisamment de code public. Cette asymétrie déclenche une spirale inverse. Les LLMs produisent du Rust syntaxiquement correct mais sémantiquement défaillant. Les développeurs le remarquent et hésitent à confier du Rust à l’IA. Moins de code Rust généré signifie moins de données Rust publiques. La boucle tourne en arrière. Demain, personne ne demandera à Claude de générer du Rust, non parce que c’est impossible en théorie, mais parce que l’expérience aura été assez mauvaise assez souvent.
Les langages meilleurs techniquement se retrouvent écrasés par les langages entraînés. Ce n’est pas une compétition entre qualités ; c’est une compétition entre volumes de données.
Conséquences systémiques
L'espace des solutions se rétrécit
Au lieu de puiser dans 7 000 bibliothèques disponibles, les LLMs en choisissent 32 à 39 — toujours les mêmes. Le code généré suit les mêmes patterns. Les développeurs internalisent ces patterns. L’innovation en bibliothèques ralentit.
Un nouveau langage ne peut plus émerger
Une nouvelle langue, même excellente, a besoin de données massives pour entraîner les LLMs. Codex a été entraîné sur des décennies de code public accumulé. Un langage créé aujourd’hui n’a pas dix ans de données accessibles. Il ne peut pas atteindre le seuil d’apprentissage nécessaire.
La sérendipité communautaire meurt
Les projets niche, qui trouvaient autrefois des contributeurs par hasard, sont désormais invisibles aux LLMs et donc aux développeurs. La sérendipité, moteur de l’innovation depuis 30 ans, s’efface. Un développeur débutant en 2030 ne découvrira plus Rust par curiosité. Le LLM lui proposera systématiquement Golang ou C++. Les langages établis reçoivent des millions d’expositions ; les niches en reçoivent des centaines. Cet écart grandit chaque mois.
Remèdes en gestation
Fine-tuning spécialisé
Des chercheurs expérimentent l’entraînement de versions LLM exclusivement sur du code Rust, Haskell ou F#. La qualité de génération s’améliore. Mais le coûtage est prohibitif. Cela ne peut pas se faire pour les 600+ langages existants.
WebAssembly : contournement technique
Si un développeur peut écrire en Rust, compiler vers WebAssembly, puis exécuter partout sans compromise, le langage source devient un détail technique. Rust → compilateur → WebAssembly → partout. Mais WebAssembly n’est pas universel encore, et les LLMs devront d’abord apprendre à générer du code compilable.
Standardisation des prompts
Demander explicitement au LLM d’envisager trois langages pour un problème donné, puis justifier le choix. Cette approche demande une discipline permanente et ne corrige pas le biais structurel — elle le contourne seulement.
Modèles open-source équilibrés
L’émergence de LLMs open-source véritablement performants pourrait décentrer l’autorité d’OpenAI et GitHub, ouvrant l’espace pour des données d’entraînement volontairement équilibrées.
Trois futurs avant 2035
Scénario 1 : Concentration (50 % de probabilité)Les trois à cinq langages dominants verrouillent leur mainmise. Python conserve la data science, TypeScript la Web, Java l’entreprise, Go la cloud. Les langages niche s’enferrent dans une marginalité croissante. Les nouveaux projets font des choix rarement basés sur les mérites techniques, mais sur la couverture IA disponible.
Scénario 2 : Bifurcation (30 %)Deux écosystèmes coexistent. D’un côté, Python et TypeScript bombardés de données IA, industrie des copilotes rapide et homogène. De l’autre, langages de niche survivant comme choix délibéré — les systèmes temps réel s’écrivant en Rust, les modèles propriétaires émergent, les communautés se réorganisant autour de ce qui ne peut pas être généré.
Scénario 3 : Rupture (20 %)Une innovation technologique casse le jeu avant 2030. LLMs mieux entraînés sur données équilibrées. Modèles open-source véritablement performants. WebAssembly décolle. Nouvelle vague de langages exploitant les failles. Le langage source redevient un détail.
La question centrale : innovation ou verrouillage ?
L’IA redessine l’écosystème des langages de programmation en temps réel, non par intention malveillante, mais en apprenant de GitHub — qui reflétait le choix humain accumulé depuis 15 ans. Mais l’IA amplifie ce choix. Elle l’inscrit dans le marbre de l’apprentissage statistique.
La domination observée de Python, TypeScript et Go n’est pas le signe qu’ils sont objectivement meilleurs. C’est le signe qu’ils avaient une avance quantitative assez grande pour que l’IA la transforme en monopole.
Les développeurs n’ont pas le temps de résister. Pourquoi insister pour générer du Rust quand le LLM propose du Golang sans erreur visible ? Pourquoi financer le fine-tuning pour Haskell quand TypeScript fonctionne ? L’IA impose une rationalité court-termiste.
Mais ce n’est pas irréversible. Cette dynamique demande une attention consciente. Si les entreprises de LLMs entraînaient volontairement sur des données équilibrées. Si les communautés niche généraient elles-mêmes des modèles spécialisés. Si les développeurs résistaient à l’appel de la génération facile. Si WebAssembly explosait. Alors la boucle pourrait casser.
Pour l’instant, elle tourne. Et elle n’a pas fini de redessiner les cartes.
Leave a Reply