Linus Torvalds publie des patches du noyau Linux écrits par Claude Code : le workflow agent validé au plus haut niveau

Linus Torvalds publie des patches du noyau Linux écrits par Claude Code : le workflow agent validé au plus haut niveau

🔎 Pourquoi ce commit est différent des mille annonces IA que vous avez lues

Autour du 12 octobre 2026, un branch nommé noref-filemap-read-with-llm est apparu dans l'arbre git de Linus Torvalds — celui-là même d'où sortent les versions officielles du noyau Linux. Phoronix l'a repéré en premier. En apparence, rien d'explosif : huit patches expérimentaux, basés sur Linux 7.3-rc6, qui réécrivent la lecture du page cache.

Sauf que le message de commit contient une phrase jamais vue à ce niveau du projet : « The code, the test programs, the review behind the list above and the first draft of this text were done with an LLM coding assistant (Claude Code) under my direction. The measurements were run on my machine. »

Le créateur de Linux crédite publiquement un agent IA pour du code d'infrastructure — code, tests, revue, brouillon de la cover letter — tout en gardant la direction, les mesures et la signature. Ce n'est pas un benchmark de plus dans l'avalanche hebdomadaire. C'est le créateur du noyau le plus déployé au monde qui dessine, en trois lignes de commit, la frontière entre code assisté et code écrit.

L'essentiel

• Un branch historique : noref-filemap-read-with-llm, poussé par Linus Torvalds dans son propre arbre git autour du 12 octobre 2026 — un geste qu'il ne fait normalement jamais.
• Une créditation explicite : le message de commit attribue à Claude Code le code, les programmes de test, la revue et le premier brouillon du texte, « sous ma direction », mesures exécutées sur sa machine.
• Un vrai sujet technique : 8 patches sur Linux 7.3-rc6 qui suppriment l'incrément atomique du compteur de référence du folio dans la lecture du page cache, remplacé par une lecture sous RCU avec libération mémoire différée.
• Un gain mesuré de x3 : lectures de 16 octets par 8 threads, de ~10 M à 30-33 M lectures/s sur un Core i7-8565U (mitigations CPU désactivées).
• Un statut clair : expérimental, non mergé. Phoronix évoque une possible fenêtre de merge pour Linux 7.4.
• Un précédent lourd de sens : Torvalds avait déjà déclaré utiliser l'IA pour débugger le noyau, mais c'est la première créditation publique d'un agent pour du code de ce niveau d'infra.

Outils recommandés

Le workflow de Torvalds repose sur un agent en terminal, dirigé par un humain qui mesure. Notre comparatif des meilleurs outils IA pour le code détaille toutes les options ; voici l'essentiel pour reproduire ce type de setup :

Pour choisir le modèle qui fait tourner votre agent, notre palmarès des meilleurs LLM pour coder est actualisé en continu.

Que changent ces 8 patches dans le noyau Linux ?

Réponse directe : ils retirent du chemin de lecture du page cache la seule chose qui obligeait tous les threads à se battre pour la même ligne de cache processeur — l'incrément atomique du compteur de référence du folio. À la place, la lecture se fait dans une section critique RCU, et la mémoire n'est libérée qu'après une période de grâce.

Le problème : un compteur que tout le monde se dispute

Quand un processus lit un fichier déjà en cache, le noyau ne touche pas au disque : il sert les données depuis le page cache. Mais chaque lecture prend une référence sur le folio — l'unité de gestion mémoire du cache — via une opération atomique.

Ce compteur vit dans une ligne de cache du processeur. Dès que plusieurs threads lisent le même fichier en parallèle, cette ligne fait la navette entre les cœurs : chaque incrément invalide la copie des autres. Le goulot n'est ni la RAM ni le stockage, c'est un compteur de quelques octets. Un problème remonté dès 2024, selon hwbusters.

La solution : lire sans prendre de référence, grâce à RCU

RCU (Read-Copy-Update) est un mécanisme de synchronisation historique du noyau : il permet de lire des données partagées sans verrou ni opération atomique, avec la garantie que la mémoire ne sera pas libérée pendant la lecture. La libération est simplement repoussée après une « période de grâce ».

Les patches appliquent cette technique à la lecture du page cache : le thread lit dans une section critique RCU read-side, sans incrémenter le compteur. Plus d'opération atomique sur le chemin chaud, plus de contention. La mémoire est libérée en différé.

Le garde-fou : 1024 pages par CPU, pas plus

Différer la libération a un coût : les pages s'accumulent en attendant leur période de grâce. Deux des huit patches ajoutent donc un garde-fou : au-delà de 1024 pages en file d'attente par CPU, un worker force une période de grâce expedited pour purger la file.

C'est du très classique en ingénierie noyau : fast path sans verrou, mémoire bornée. Et c'est exactement le genre d'arbitrage qu'un humain doit valider avant de signer — ce que Torvalds a fait.

Les chiffres : x3 sur les petites lectures, à conditions précises

Réponse directe : sur son laptop Core i7-8565U, mitigations CPU désactivées, Torvalds mesure un triplement du débit sur le pire cas imaginable — des lectures de 16 octets par 8 threads sur le même fichier.

Sources : mesures publiées par Torvalds, détaillées par Startup Fortune et hwbusters.

Pourquoi ce cas de test est volontairement extrême

16 octets, c'est le cas où le coût fixe de chaque appel domine tout le reste — précisément là où une contention sur un compteur se voit le plus. Les charges qui multiplient les toutes petites lectures sur des fichiers chauds (métadonnées, configs, myriades de petits fichiers) sont les premières concernées. Vos lectures de 64 Ko ou 1 Mo verront un gain relatif bien plus faible.

Deux détails d'honnêteté à noter : le i7-8565U est un 4 cœurs/8 threads, donc les 8 threads saturent l'hyperthreading ; et les mitigations désactivées, c'est du silicium brut, pas une config de production. Torvalds ne cache rien : il publie son setup complet. C'est rare, et c'est la bonne pratique.

Reproduire ce genre de mesure sans flinguer votre machine

Compiler un noyau et le tester, ça se fait dans un environnement isolé. Un VPS comme Hostinger suffit largement pour la boucle compiler/tester, à quelques euros par mois. En revanche, pour des chiffres reproductibles au cycle processeur près, rien ne remplace une machine physique dédiée — un VPS mutualisé ajoute trop de bruit de mesure.

Le message de commit, mot pour mot : une première historique

Réponse directe : ce message fait ce que presque aucun projet ne fait — il attribue précisément, clause par clause, ce que l'IA a fait et ce que l'humain a gardé.

« The code, the test programs, the review behind the list above and the first draft of this text were done with an LLM coding assistant (Claude Code) under my direction. The measurements were run on my machine. »

Traduction : « Le code, les programmes de test, la revue derrière la liste ci-dessus et la première version de ce texte ont été réalisés avec un assistant de codage LLM (Claude Code), sous ma direction. Les mesures ont été exécutées sur ma machine. »

Trois clauses méritent d'être lues lentement.

Ce que l'agent a fait : le code, les programmes de test, la revue « derrière la liste », le brouillon du texte. Quatre livrables, dont trois relèvent du travail d'ingénierie vérifiable.

Ce que l'humain a gardé : la direction (« under my direction »), les mesures (« on my machine »), et implicitement la signature. Torvalds ne dit pas « l'IA a écrit ce patch ». Il dit « j'ai dirigé un agent qui a écrit ce patch, j'ai mesuré, je signe ».

Ce qui n'est pas dit : aucun tag diluant, aucune généralisation du type « généré par IA ». Juste un outil nommé, un cadre nommé, une responsabilité assumée. Notez même le détail le plus révélateur : la cover letter elle-même — le texte qui présente le travail — a un brouillon rédigé par l'agent, mais c'est Torvalds qui l'endosse.

Le contexte rend la chose plus lourde : Torvalds avait déjà expliqué utiliser l'IA pour débugger le noyau. Mais créditer publiquement un agent sur du code de ce niveau d'infrastructure, c'est une première. Et It's FOSS souligne que la série ne donne elle-même aucune cible de release — signe d'un travail encore en cours d'évaluation, pas d'un coup marketing.

Un branch dans l'arbre de Torvalds : un signal en soi

Réponse directe : Torvalds ne pousse normalement jamais de branches secondaires dans son arbre principal — le fait même que ce branch y figure est un message.

Son arbre, c'est l'endroit où les merges atterrissent, pas un bac à sable. Y déposer un branch expérimental qui porte le suffixe -with-llm jusque dans son nom, c'est l'exposer volontairement à la revue la plus féroce du secteur — et à la discussion publique qui a suivi, très large dans la communauté, comme le relève le roundup Reddit du 13 octobre.

Mon analyse : c'est l'inverse d'un coup de communication. Un billet de blog se rédige en une heure et n'engage à rien. Un branch dans l'arbre de Torvalds engage son auteur sur la technique, pas sur la com. S'il avait voulu faire du buzz, il aurait tweeté. Il a commité — dans le dépôt le plus surveillé de l'histoire du logiciel libre.

Le workflow « agent code, humain dirige et mesure » décortiqué

Réponse directe : ce que documente Torvalds — sans le présenter comme tel — c'est un protocole reproductible en cinq étapes, et il tient en une phrase de commit.

1. Cadrer le problème : un goulot identifié depuis 2024, une direction technique choisie (RCU, libération différée). L'humain décide de l'architecture.
2. Laisser l'agent produire : le code, les programmes de test, le premier brouillon de la cover letter.
3. Revue humaine : « the review behind the list above » — Torvalds a relu ce que l'agent a produit.
4. Mesurer sur du matériel réel : « the measurements were run on my machine ». Pas de benchmark emprunté, pas de chiffre de brochure.
5. Signer : le patch part sous son nom, avec la responsabilité qui va avec.

La répartition est fine et mérite d'être soulignée : l'agent a écrit les programmes de test, mais c'est l'humain qui a exécuté les mesures et validé les résultats. Écrire un test et garantir qu'il mesure la bonne chose sont deux responsabilités différentes — Torvalds ne les confond pas.

Les outils suivent d'ailleurs le même chemin : le dashboard Claude Code Agent View d'Anthropic existe précisément pour superviser ce que font les agents sans lire leurs transcripts en continu. Et si vous voulez construire un agent encadré de vos propres mains, notre guide sur comment créer un agent IA détaille les garde-fous à mettre en place dès la conception.

Mon opinion : la plupart des équipes font l'inverse. Elles laissent l'agent écrire, mergent, et découvrent les problèmes en production. Le x3 de Torvalds est moins une victoire de l'IA qu'une victoire de la mesure. Retirez l'étape 4, et tout ce commit s'effondre.

Assisté ou écrit ? La ligne que ce commit déplace

Réponse directe : ce commit ne tranche pas la question « qui a écrit ce code ? ». Il la remplace par une meilleure : « qui dirige, qui vérifie, qui signe ? ».

Le débat binaire — code IA bon ou mauvais, accepté ou interdit — rate le sujet. Le message de Torvalds montre qu'on peut être granulaire : l'agent a fait ceci, l'humain a fait cela, et chaque affirmation est vérifiable. Comparez avec la pratique courante : un tag « généré par IA » posé en disclaimer sur des milliers de lignes, sans aucun détail. Il n'y a pas photo.

La question que la communauté du noyau va maintenant se poser : si l'agent a écrit le code mais que l'humain a dirigé, revu, mesuré et signe seul — qui est l'auteur ? La réponse de Torvalds est implicite : celui qui signe. La responsabilité ne se dilue pas avec le tooling. C'est probablement la seule position tenable dans un projet où une régression touche des milliards de machines.

Et ce commit n'arrive pas dans un vide : Google pousse Antigravity 2.0, sa suite agent-first construite autour du même pattern, et côté open-source, Qwen3-Coder-Next vise frontalement Claude Sonnet 4.6 avec seulement 3B de paramètres actifs. Ce que Torvalds valide, c'est le pattern — pas un outil isolé. Les classements agentiques du moment, dominés par GPT-5.5, Gemini 3 Pro Deep Think et Claude Opus 4.7, montrent que la matière première est là depuis un moment. Ce qui manquait, c'est le protocole.

Ce que ça change pour votre équipe — et ce que ça ne change pas

Réponse directe : pour la majorité des équipes, la leçon de ce commit n'est pas technique, elle est organisationnelle.

Ce qui change :

• Le tabou tombe. Quand la figure d'autorité maximale du domaine crédite un agent sur du code noyau, l'argument « on ne met pas d'IA dans l'infra critique » cesse d'être tenable.
• Un format d'attribution à copier. Nommer l'outil, décrire précisément ce qu'il a fait, décrire ce que l'humain a gardé. C'est vérifiable, honnête, et ça protège tout le monde — y compris l'agent.
• La culture de la mesure. Un agent qui code sans benchmark qui valide n'est qu'un générateur de code plausible. Le commit de Torvalds met la mesure au même niveau que le code.

Ce qui ne change pas :

• Les règles du noyau. Signed-off-by, revue par les mainteneurs : rien n'indique le moindre assouplissement. Torvalds joue selon les règles existantes, il ne les réécrit pas.
• L'obligation de comprendre ce qu'on signe. Ce workflow exige un expert capable de diriger et de relire — pas un junior qui accepte le diff en priant.
• Microbenchmark ≠ production. Votre charge de travail n'est pas « 8 threads, 16 octets, même fichier ». Mesurez la vôtre avant d'en tirer des conclusions.

Vers un merge dans Linux 7.4 ?

Réponse directe : rien n'est joué — le branch est expérimental, sans cible de release annoncée, et Phoronix n'évoque qu'une fenêtre de merge possible pour Linux 7.4.

Le message de commit lui-même ne donne aucune destination. Les patches pourraient être retravaillés, repoussés ou purement abandonnés après revue — c'est le sort normal d'un code expérimental, quel que soit son auteur ou son assistant. Le statut à date : toujours hors mainline.

Ce qui survit au merge ou à l'abandon, en revanche, c'est le précédent. Même si ces 8 patches ne vont jamais nulle part, la phrase de commit restera dans les archives git comme le premier endossement public du workflow « agent code, humain dirige et mesure » au sommet du projet Linux. Et ça, aucune merge window ne peut le retirer.

❌ Erreurs courantes

Erreur 1 : « L'IA a réécrit le noyau Linux »

Ce qui ne va pas : les titres viraux réduisent l'histoire à « Linux écrit par une IA ». La réalité : 8 patches ciblés sur un chemin précis, dirigés, revus, mesurés et signés par l'humain le plus expérimenté du domaine. La solution : citez le message de commit, pas le headline.

Erreur 2 : Généraliser le x3 à tous vos accès fichiers

Ce qui ne va pas : le benchmark mesure le pire cas de contention (16 octets, 8 threads, même fichier), conçu précisément pour révéler le goulot. Vos lectures réelles, plus grosses et moins concurrentes, verront un gain bien plus faible. La solution : benchmarkez votre propre charge avant toute décision d'architecture.

Erreur 3 : Croire que c'est mergé dans le mainline

Ce qui ne va pas : le branch est expérimental, logé dans l'arbre de Torvalds, sans cible de release. Aucun noyau stable ne contient ces modifications aujourd'hui. La solution : suivez le log du branch et la fenêtre Linux 7.4 pour savoir où ça va.

Erreur 4 : Copier l'outil sans copier la discipline

Ce qui ne va pas : des équipes qui sortent l'agent du placard, mergent sans revue ni mesure, puis invoquent Torvalds pour se justifier. La solution : reproduire le protocole complet — cadrage humain, revue, benchmarks sur matériel réel, signature assumée. L'outil sans le protocole ne vaut rien.

❓ Questions fréquentes

Les patches écrits avec Claude Code sont-ils dans Linux ?

Non. Le branch noref-filemap-read-with-llm est expérimental, poussé dans l'arbre de Torvalds autour du 12 octobre 2026, sans cible de release dans le message de commit. Phoronix évoque une possible fenêtre de merge pour Linux 7.4. Tant que le merge n'a pas lieu, aucun noyau stable n'embarque ces modifications.

Quel est le gain de performance exact ?

Sur le laptop Core i7-8565U de Torvalds (mitigations CPU désactivées) : lectures de 16 octets par 8 threads sur un même fichier, de ~10 M à 30-33 M lectures/s, soit un triplement. Avec 4 threads sur cœurs séparés : de ~9-12 M à 25-26 M lectures/s. Ce sont des microbenchmarks volontairement extrêmes, pas des moyennes de charge réelle.

Claude Code a-t-il travaillé seul ?

Non, et c'est le point clé : « under my direction ». L'agent a produit le code, les programmes de test, soutenu la revue et rédigé le premier brouillon du texte. Torvalds a dirigé le travail, exécuté les mesures sur sa machine et signé le résultat sous son nom. La responsabilité finale reste explicitement humaine.

Quel modèle d'IA tourne dans Claude Code ?

Le commit ne précise pas la version du modèle, seulement l'outil. Claude Code s'appuie sur les modèles Claude d'Anthropic, dont les fleurons actuels pour le code agentique sont Claude Opus 4.7 (Adaptive) et Claude Sonnet 4.6. Pour voir comment Claude se positionne face à son principal rival, notre comparatif Claude vs ChatGPT détaille leurs forces en contexte agentique.

Faut-il en déduire que le code généré par IA est désormais accepté partout ?

Non. Ce que Torvalds valide, c'est un protocole : direction humaine, revue, mesure sur matériel réel, signature assumée. Sans ces garde-fous, le même outil produit du code plausible mais non vérifié. La leçon n'est pas « l'IA peut écrire du noyau », mais « un expert peut diriger une IA sur du noyau » — et la nuance change tout.

✅ Conclusion

Huit patches expérimentaux, un x3 sur un microbenchmark, et surtout une phrase de commit qui fait plus pour clarifier le code assisté par IA que des mois de débats : l'agent produit, l'humain dirige, mesure et signe. Pour choisir l'agent adapté à votre propre workflow, commencez par notre sélection des meilleurs outils IA du moment.