Linus Torvalds, Linux et l’IA : le pragmatisme plutôt que la peur

Linus Torvalds vient de clarifier sa position sur l’utilisation de l’intelligence artificielle dans le développement du noyau Linux. Comme souvent avec lui, le message est direct : Linux ne deviendra pas un projet opposé à l’IA par principe.

Les personnes qui refusent catégoriquement ces outils restent libres de ne pas les utiliser. Elles peuvent également quitter le projet ou créer leur propre fork. En revanche, elles ne peuvent pas imposer ce refus à l’ensemble de la communauté.

Derrière la formule provocatrice reprise par plusieurs médias, sa position est en réalité plus intéressante et beaucoup plus nuancée.

Linux n’est pas un projet anti-IA

Linus Torvalds ne prétend pas que l’IA est parfaite. Il reconnaît qu’elle peut produire de mauvais rapports de bugs, du code médiocre et une quantité importante de bruit supplémentaire pour les mainteneurs.

Mais il considère désormais qu’elle est devenue un véritable outil de développement.

Il y a encore peu de temps, Torvalds se montrait beaucoup plus sceptique. En 2024, il estimait qu’une grande partie du discours autour de l’IA relevait surtout du marketing. Aujourd’hui, son constat a évolué : ces outils sont utiles, même s’ils restent imparfaits et parfois pénibles à gérer.

Sa position tient finalement en une idée simple : il faut juger une contribution sur sa valeur technique, pas sur les convictions personnelles que chacun peut avoir à propos de l’IA.

Et sur ce point, je pense qu’il a raison.

Il fixe la direction du projet qu’il a créé

Linux est aujourd’hui un immense projet collectif. Des milliers de développeurs, de mainteneurs et d’entreprises contribuent au noyau.

Il ne serait donc pas exact de présenter Linux comme la propriété personnelle de Linus Torvalds. Mais il en reste le créateur et le mainteneur principal. Son rôle consiste justement à arbitrer et à définir les grandes orientations techniques du projet.

Lorsqu’il affirme que Linux ne deviendra pas un projet anti-IA, il assume cette responsabilité.

On peut ne pas partager sa position. C’est aussi le principe du logiciel libre : le code peut être étudié, modifié et forké. Mais on ne peut pas exiger du projet principal qu’il adopte une ligne idéologique contraire à celle définie par son mainteneur.

L’open source n’est pas l’absence de direction. Il repose aussi sur des responsabilités clairement assumées.

Tôt ou tard, l’IA participera au développement de Linux

À mon avis, le débat ne porte déjà plus réellement sur la question de savoir si l’IA sera utilisée pour développer Linux.

Elle l’est probablement déjà, directement ou indirectement, pour analyser du code, rechercher des régressions, préparer des rapports, relire des modifications ou identifier certaines anomalies.

La véritable question est plutôt de savoir jusqu’où son utilisation pourra aller et dans quelles conditions.

L’IA ne remplacera pas soudainement les mainteneurs du noyau. En revanche, elle pourrait progressivement prendre une place plus importante dans plusieurs domaines :

• l’analyse statique du code 

• la détection de vulnérabilités 

• l’identification de régressions 

• la génération ou l’amélioration de tests 

• la revue préliminaire des correctifs 

• la recherche dans l’historique des commits 

• l’analyse des interactions complexes entre différents sous-systèmes

Il serait assez surprenant que le projet Linux se prive durablement de ces possibilités alors que le noyau contient plusieurs dizaines de millions de lignes de code et évolue constamment.

Torvalds semble l’avoir compris : ignorer ces outils ne les fera pas disparaître. Il vaut mieux apprendre à les utiliser correctement et définir des règles suffisamment solides pour éviter qu’ils ne deviennent une charge supplémentaire.

Mais Linux n’est pas un projet comme les autres

Cette ouverture à l’IA doit néanmoins s’accompagner d’une grande prudence. Linux est partout.

On le trouve dans les serveurs, les infrastructures cloud, les smartphones Android, les routeurs, les objets connectés, les supercalculateurs, les systèmes industriels, les équipements réseau et de nombreux systèmes critiques.

Une erreur introduite dans une application classique peut affecter quelques utilisateurs. Une erreur dans le noyau Linux peut avoir des conséquences beaucoup plus larges.

C’est pour cette raison que l’utilisation de l’IA dans un projet aussi sensible ne peut pas suivre la logique du « vibe coding », où l’on accepte du code simplement parce qu’il semble fonctionner.

Un modèle peut générer une modification convaincante, correctement structurée et parfaitement plausible tout en introduisant une faille difficile à détecter. Il peut aussi mal comprendre un comportement historique, ignorer une contrainte matérielle rare ou proposer une correction qui fonctionne sur une architecture mais provoque une régression sur une autre.

Avec le noyau Linux, un code plausible ne suffit pas. Il faut le comprendre, le tester, le revoir et en assumer la responsabilité.

L’humain doit rester responsable

C’est probablement le point le plus important.

Peu importe qu’un patch ait été écrit entièrement à la main, suggéré par une IA ou produit avec l’aide de plusieurs outils : la personne qui le soumet doit rester responsable de son contenu.

L’IA ne peut pas devenir une excuse.

Un développeur ne devrait jamais pouvoir répondre à une régression ou à une vulnérabilité par : « Je ne sais pas, c’est le modèle qui a généré le code. »

Celui qui signe une contribution doit être capable de l’expliquer, de la défendre et, si nécessaire, de la corriger.

Cela suppose également que les mainteneurs disposent d’outils permettant d’identifier les contributions douteuses, de renforcer les tests et de vérifier que l’IA réduit réellement leur charge de travail au lieu de la déplacer vers la phase de revue.

Torvalds le dit lui-même : l’objectif doit être de faire en sorte que les outils basés sur les grands modèles de langage aident les mainteneurs, plutôt que de leur imposer du travail artificiel supplémentaire.

Ni rejet systématique, ni confiance aveugle

Je comprends les inquiétudes d’une partie de la communauté open source.

Les rapports générés automatiquement, les contributions opportunistes et le code envoyé sans avoir été réellement compris peuvent rapidement épuiser les mainteneurs. Le problème est réel et il ne faut pas le minimiser.

Mais rejeter toute utilisation de l’IA par principe ne me semble pas être la bonne réponse.

À l’inverse, accepter aveuglément du code parce qu’il a été produit rapidement par un modèle serait tout aussi dangereux.

La position la plus raisonnable se trouve entre les deux : utiliser l’IA comme un outil, sans lui déléguer la responsabilité technique.

C’est finalement l’essence du message de Linus Torvalds.

L’intelligence artificielle n’est ni une autorité, ni un ennemi. C’est un outil supplémentaire. Elle peut détecter des erreurs, mais aussi en créer. Elle peut faire gagner du temps, mais également en faire perdre énormément.

Dans un projet aussi central que Linux, son adoption me paraît inévitable. Mais elle devra se faire avec une exigence plus élevée que partout ailleurs.

Parce que Linux est partout, et que lorsque le noyau se trompe, les conséquences dépassent largement le poste de travail du développeur qui a envoyé le commit.