Linus Torvalds's AI Arc: From '90 Percent Marketing' to 'Fork It or Walk Away' (1991–2026)

Case study run on 2026-09-21 against templates/research/pre-llm-elite-programmer-ai-adaptation.md, as the second cohort case after the DHH study. Every source listed at the end was fetched live during this session, with the exceptions stated in the Sources section: lore.kernel.org refused direct fetches, ZDNET and Phoronix pages returned only navigation chrome or errors, and the Ars Technica article was read through a Wayback snapshot whose body truncated after the standfirst. Where a quote reaches this note through a fetched secondary source, that is labeled. Kernel mailing-list primaries are the direct evidence layer; the LWN keynote write-up and conference reports are the self-report layer (as reported speech); LWN development statistics are external measurement. What could not be verified is labeled as such, not guessed.

Why this case (template Section 2 screen)

Torvalds passes the template’s inclusion criteria on every count:

• Publicly recognized before 2023 for technical work: he announced Linux on comp.os.minix on 25 August 1991 — “I’m doing a (free) operating system (just a hobby, won’t be big and professional like gnu)” (History of Linux, Wikipedia, which reproduces the archived newsgroup post) — and released Git on 7 April 2005, originally created for Linux kernel development (Git, Wikipedia). At the 2026 Open Source Summit North America keynote he was introduced as “the creator of two industry-shaping tools: the Linux kernel and the Git version-control system” (LWN, 2026-05-25).
• Reputation grounded in programming ability, not management or venture status: framework design, systems work, and the merge/integration role he has held for decades (LWN, 2026-05-25).
• Post-2023 public evidence is abundant: a dated LKML record (January and July 2026 posts, a 7.1-rc4 announcement), two kernel documentation pages he drove to adoption, LWN statistics articles, and four years of on-stage conversations with Dirk Hohndel.
• He actually encountered AI coding tools — and the record shows the template’s required pattern: famous programmer → encounters AI coding → changes (parts of) his practice while explicitly refusing to change his core role (documented below).

The template’s caution — “uses AI” ≠ “changed how he programs” — is unusually easy to honor here, because Torvalds states the boundary himself, on the record, in one sentence: as top-level maintainer, “he does not do a lot of coding… his job is working with people, and he does not use AI to work with people” (LWN, 2026-05-25).

One nuance for the screen: the template’s exclusion rule warns against people who are merely famous and now talk about AI. Torvalds is the opposite failure mode — famous and central to the AI-coding debate — so the discipline here is to study only what his practice did, not the volume of his commentary.

Pre-2023 baseline (template Section 3)

3a. What did he build?

3b. What kind of programmer was he?

Per the template taxonomy: systems programmer (kernel, C, “really close to the hardware” — his words on the 2026 keynote, LWN) plus developer-tool builder (Git, 2005). Both classifications are derivation from the verified facts above.

3c. What made him unusually good?

• Taste as a named, demonstrated skill: the linked-list “good taste” example — eliminating the head-node special case with an indirect pointer — is from his 2016 TED interview (TED 2016; the code illustration and video timestamp are documented at felipec.github.io/good-taste).
• Low-level grounding: he “had grown up writing machine code: ‘And when I say machine code, I don’t mean assembly language. I mean the numbers’” — working that directly with the hardware “leaves an imprint” (LWN, 2026-05-25).
• Self-described orientation: “I am not a visionary, I’m an engineer… I’m looking at the ground, and I want to fix the pothole that’s right in front of me before I fall in” (TED 2016 page, quoting the talk).
• The decisive pre-AI pivot: around 2000 he “had to change how I worked because I did not scale anymore for the project as Linux was growing. I still remember it being one of the more painful episodes in kernel development. And it was literally 25 years ago” (LWN, 2026-05-25). Git (2005) and the maintainer hierarchy were the tools of that pivot; from then on his unit of work was other people’s patches, not his own code. LWN’s statistics confirm the residual: in 7.0 he appears on the lines-changed table once, 15,884 lines (1.9%), “a rare appearance… by virtue of changes to Cook’s kmalloc() interface” (LWN, 2026-04-13).

Comparative advantage carried forward (derivation from the facts above): not typing speed and not, anymore, even personal code — institutional taste: deciding what enters the kernel, expressed through process (Git, the maintainer pyramid, merge discipline). This is what AI arrives to stress.

The adoption timeline (template Section 4)

Phase 0 — 2022 and earlier (no modern LLM coding)

“The kernel has had the same process now for about 20 years, since switching to Git,” he said on the 2026 keynote — and for most of that period there is no public evidence, in this session’s fetched sources, of AI tooling anywhere in his workflow (LWN). His tools were the kernel toolchain, email, and the merge process.

Phase 1 — 2023 (ChatGPT / GPT-4 era)

At Open Source Summit Japan in December 2023, Dirk Hohndel asked whether he would ever see AI-written code submitted to the kernel. Torvalds said yes and guessed it might already be happening on a small scale; on hallucinated code risk, “I think we’re doing just fine at making mistakes on our own” (as reported by It’s FOSS, 2026-07-17, citing ZDNET coverage of the event; the ZDNET page could not be fetched this session). His recorded posture: AI-written kernel code is coming and is not particularly alarming.

Phase 2 — 2024 (Copilot / early agents)

Dismissive, in two public steps:

• Open Source Summit North America, Seattle, 2024: he joked that he might “be replaced by an AI model” and suggested everyone “wait 10 years and see where it actually goes before we make all these crazy announcements” (It’s FOSS chronology, citing ZDNET; not fetched directly).
• October 2024, TFiR interview at OSS Europe in Vienna: he called the AI industry “90 percent marketing and 10 percent reality” and said he would mostly tune it out until that changed, while predicting real use cases might show up in about five years (It’s FOSS, citing a TFiR YouTube interview; video not fetched this session).

Template key distinction recorded: through 2024 he treated AI as neither assistant nor programmer — it was noise at both layers.

The turn (November 2025 – January 2026)

• November 2025, OSS Korea: “fairly positive” about vibe coding — but only for people learning to code, comparing it to typing programs out of computer magazines as a kid (It’s FOSS).

• Holiday project 2025→2026 — AudioNoise (github.com/torvalds/AudioNoise, “Random digital audio effects”, GPL-2.0): he wrote the C part himself and handed the Python visualizer to an AI IDE — Google Antigravity. His README, as quoted by It’s FOSS, 2026-01-11: “the python visualizer tool has been basically written by vibe-coding. I know more about analog filters – and that’s not saying much – than I do about python. It started out as my typical ‘google and do the monkey-see-monkey-do’ kind of programming, but then I cut out the middle-man – me – and just used Google Antigravity to do the audio sample visualizer.” The previous holiday’s project was the GuitarPedal (github.com/torvalds/GuitarPedal; software plus schematics under GPLv2, LWN keynote).

• January 7, 2026, LKML (primary, fetched in full via lkml.org): in the thread on “Documentation: Provide guidelines for tool-generated content”, responding to Lorenzo Stoakes’ “just another tool” objection:

  “No. Your position is the silly one. There is *zero* point in talking about AI slop. That’s just plain stupid. Why? Because the AI slop people aren’t going to document their patches as such. […] So stop this idiocy. The documentation is for good actors, and pretending anything else is pointless posturing. As I said in private elsewhere, I do *not* want any kernel development documentation to be some AI statement. We have enough people on both sides of the ‘sky is falling’ and ‘it’s going to revolutionize software engineering’, I don’t want some kernel development docs to take either stance. It’s why I strongly want this to be that ‘just a tool’ statement. And the AI slop issue is *NOT* going to be solved with documentation, and anybody who thinks it is either just naive, or wants to ‘make a statement’.”

  Note what this post already contains: a personal-use signal, a policy stance, and a refusal to moralize — three weeks before AudioNoise’s public README said the same thing from the hobby side (“toy effects that you shouldn’t take seriously”, ItsFOSS quoting the README).

Phase 3 — 2025→2026: AI enters the kernel’s machinery

The 2026 record is institutional, not anecdotal:

1. Sashiko — an LLM-based kernel patch-review system by Roman Gushchin, live on kernel mailing-list patches from March 2026. LWN: “it has written over 10,000 reviews in [under a month], with an average of approximately 3,500 words of output (counting quoted source code) per patch. It is, quite literally, producing words faster than any individual person could reasonably read,” and per various statistics about half of those words concern bugs no human reviewer had spotted beforehand; mm maintainer Andrew Morton counted 22 of ~35 review replies as requiring changes, and fought to make responding to Sashiko mandatory (“Rule #1 is, surely, ‘don’t add bugs’. This thing finds bugs.”), over Lorenzo Stoakes’ false-positive objections (LWN, 2026-03-31). At the May keynote Torvalds put Sashiko in the kernel’s own column: “We do use AI tools,” such as Sashiko, “which produces reviews of patches sent to the kernel mailing list” (LWN, 2026-05-25).
2. Policy docs shipped with 7.0 (April 2026) — the kernel now carries two normative pages: “Kernel Guidelines for Tool-Generated Content” (docs.kernel.org) and “AI Coding Assistants” (docs.kernel.org). The operative rules, from the fetched pages: AI agents “MUST NOT add Signed-off-by tags. Only humans can legally certify the Developer Certificate of Origin”; attribution via an Assisted-by: LLM [TOOL1] [TOOL2] tag; a mandatory bug-fix procedure requiring a reproducer, a build, and checkpatch compliance, ending in “the assistant must never send anything itself”; and the framing sentence “reviewer and maintainer bandwidth is a scarce resource.”
3. Maintainer-level adoption underneath: stable-tree maintainer Greg Kroah-Hartman was found running an AI-assisted fuzzing tool against the kernel from a branch nicknamed “clanker” (April 2026, It’s FOSS, citing its separate report).
4. Measured intake growth: LWN’s 7.0 statistics counted 2,362 developers (record; previous record 2,134 in 6.19), 489 first-time contributors (record), and noted the first-timer curve has been rising since 6.14 — with LWN’s own caution that attribution to LLM tools is “guesswork” (LWN, 2026-04-13). Only 31 commits in 7.0 carried an Assisted-by tag, “but it has been clear for a while that many contributors are not adding such tags when they should”; 12,000+ queued changesets in linux-next carried 105 such tags at article time.

Phase 4 — 2026, the actual research target

Three facts define where he sits now:

• Volume: “about half a year ago, things changed” — the kernel has seen “about 20% more commits for the past two kernel releases than the project had seen for many years.” His first theory (companies rushing the 7.0 release) “turns out I was wrong”; the real change was AI tools improving enough “that we’re seeing a definite uptick in development on pretty much all fronts,” which “is not entirely positive” (LWN, 2026-05-25). Tension to keep honest: LWN’s measured number for 7.0 — 14,251 non-merge commits — is called “a fairly typical number” in the same site’s statistics article (LWN, 2026-04-13). The unambiguous measured signals are the developer-count and first-timer records, not the commit count.
• The security-list flood: in the 7.1-rc4 announcement (2026-05-17, full text at LWN’s mirror): “the continued flood of AI reports has basically made the security list almost entirely unmanageable, with enormous duplication due to different people finding the same things with the same tools… we’re making it clear that AI detected bugs are pretty much by definition not secret.” The policy consequence, stated on stage: “if you find a security or any bug with AI, you should basically consider it to be public. Just because if you found it with AI, a hundred other people also found it with AI” (LWN, 2026-05-25).
• The stance: on July 14, 2026, in a mailing-list thread discussing perceived anti-LLM sentiment following a Software Freedom Conservancy post, he wrote that he is willing to “absolutely put my foot down as the top-level maintainer… Linux is not one of those anti-AI projects, and if somebody has issues with that they can do the open-source thing and fork it. Or just walk away” — and described AI as a tool “just like other tools we use. And it’s clearly a useful one. It may not have been that ‘clearly’ even just a year ago, but it’s no longer in question today” (quotes via The Register, 2026-07-15 and It’s FOSS, which give the lore.kernel.org link to the July 14 post; lore.kernel.org refused direct fetches this session).

And the correction that keeps this honest: at OSS India in Mumbai in July 2026 he admitted his own “10x” productivity estimate for AI tools had been guesswork rather than measurement, and named the concrete new pain — a fabricated AI bug report can take hours to disprove (It’s FOSS chronology, citing ZDNET coverage of the summit; page not fetchable this session).

Where he stops delegating is stated in the same keynote: he does not use AI in the layer that is actually his job — people. “And I should suggest that you don’t do that either” (LWN, 2026-05-25).

The AI stack, as evidenced (template Section 6)

Unit of work (template Section 7)

The template’s cross-case question — what is the largest unit of work the programmer comfortably delegates? — has a two-layer answer here.

Community layer: nothing that matters. The merge decision, the DCO certification, and the security process are explicitly fenced off from AI: agents “MUST NOT add Signed-off-by tags. Only humans can legally certify the Developer Certificate of Origin,” and the AI-assistant procedure ends with “the assistant must never send anything itself” (docs.kernel.org). Sashiko reviews patches, and even that advisory role triggered a maintainer revolt when a subsystem tried to make it semi-mandatory (LWN).

Personal layer: the toy layer. The largest unit he is documented to have handed to AI is the Python visualizer of a hobby project whose README says you “shouldn’t take seriously” — a layer he explicitly disclaims maintenance on (“toy effects… The main design goal has been to learn about digital audio processing basics”, ItsFOSS quoting the README). This is delegation-with-a-disclaimer: he vibe-coded precisely the component he has said he does not intend to maintain, while keeping the C core and reading assembly output himself.

Interpretation, labeled as such: DHH delegates whole problems in production systems; Torvalds delegates only what he has publicly declared unworthy of maintenance. Both keep the same invariant — the delegator must still understand the result (“you need to understand not just your prompts, but you need to understand your end result, because that’s the only way you can maintain it long term”, LWN) — but Torvalds enforces it by refusing delegation outside the boundary, and DHH by reviewing shape and critical lines inside it.

Bottleneck migration (template Section 8)

• Before AI (his own account): the historical constraint was his own implementation capacity, around 2000 — “I had to change how I worked because I did not scale anymore for the project as Linux was growing… one of the more painful episodes in kernel development” (LWN, 2026-05-25). That constraint was solved with process: the maintainer pyramid, then Git (2005).
• After AI: the constraint reappears one layer out — intake. The security list is “almost entirely unmanageable” with “enormous duplication” (7.1-rc4 announcement, LWN); the kernel’s own policy doc names “reviewer and maintainer bandwidth” as “a scarce resource” (docs.kernel.org); LWN reports the LLM-driven security-report flood is now motivating removal of over 140,000 lines of old, seemingly unused driver and protocol code — PCMCIA host controllers, ATM, ax25, amateur radio, ISDN, Bluetooth CMTP, CAIF — precisely because dormant code is what AI bug hunters keep “finding” (LWN, 2026-04-27); and he promised to be “a bit more hardnosed” about late-cycle PR volume (It’s FOSS chronology, citing LKML messages not fetched this session).
• He makes the analogy himself: “I think we’re seeing some of the same effects now with AI, where it kind of forces people to get out of their comfort zone” (LWN).

Derivation, labeled as such: the man who solved human scaling with process in 2000 responds to tool-driven scaling the same way in 2026 — not by delegating his role to agents, but by re-engineering the intake: policy documents, the Assisted-by tag, AI-bugs-are-public security doctrine, and an LLM reviewer bolted advisory-side onto the email workflow. The bottleneck did not move from implementation to specification for him; it moved from his implementation to everyone’s intake.

What he stopped doing / started doing (template Sections 9–10)

Stopped (documented): dismissing AI as noise — the arc from “90 percent marketing” (Oct 2024) to “clearly a useful one… no longer in question today” (July 2026) is on the record (It’s FOSS; The Register). No fetched source documents him stopping any concrete kernel-work practice; his own framing is that nothing in the process changed (“the kernel has had the same process now for about 20 years”, LWN) — what changed is the volume arriving at it.

Refusals to delegate (extremely informative, per the template): AI must not touch the people layer; AI must not sign off; AI must not send anything; and kernel documentation itself must not take either side of the AI debate — “It’s why I strongly want this to be that ‘just a tool’ statement” (LKML, 2026-01-07).

Started, mapped to the template’s categories:

• F Evaluation — endorsing and using an LLM patch-review service (Sashiko) inside the kernel’s review pipeline (LWN; LWN keynote).
• D Harness/process engineering — the AI Coding Assistants and Tool-Generated Content policy pages: the Assisted-by tag, the DCO restriction, the mandatory reproducer/build/checkpatch procedure (docs.kernel.org, docs.kernel.org).
• H Product experimentation — vibe-coding hobby projects: AudioNoise’s Python visualizer via Google Antigravity; the GuitarPedal project the holiday before (ItsFOSS; LWN keynote).
• I Domain expansion — digital audio processing as a self-declared learning project (“toy effects… to learn about digital audio processing basics”), on top of 3D printing as “describing things in text… treating 3D printing as programming” (LWN keynote).
• Local-AI advocacy — recommending self-hosted tooling to kernel developers: “You don’t want to be entirely at the mercy of the big companies” (LWN keynote).

Identity after AI (template Section 11)

The template’s six types all assume the person’s code production changed. For Torvalds, the honest reading is that his type did not move — and he says so in exactly the template’s Type-A voice: “So AI is great, but AI is not changing programming. It may be changing other areas, don’t get me wrong, but I’m a programmer, so I don’t care” (LWN, 2026-05-25).

Interpretation, labeled as such: he is a Type B (programmer + architect) who was already functionally a Type F (specify/evaluate) two decades early — his “specification” layer is merge discipline and his “evaluation” layer is taste — and the AI era left the type intact while multiplying what it must process. He explicitly rejects the orchestration identity the DHH case adopted: agents do not work his layer, because his layer is people.

AI resistance (template Section 12) — the moderate branch, articulated by the gatekeeper

The template demands the spectrum, not just adopters. Torvalds is the moderate-adoption branch — institutional AI adoption (Sashiko, policy docs, local-AI endorsement, vibe-coded toy layers) with explicit refusal at the core. The July 14 “fork it or walk away” post is that position stated as governance: Linux “is not one of those anti-AI projects” (The Register; Ars Technica’s headline framing, verified through the archived standfirst: “Creator says he will ‘very loudly ignore’ those arguing for a ban on AI tools,” Ars, 2026-07-16).

The template’s question — did their output change despite different AI adoption? — gets a precise answer in his case, below.

Output leverage, with the caveats on every number (template Section 13)

All figures sourced; the self-report/measurement tension is shown, not smoothed:

The template’s leverage question — did AI increase the output frontier of exceptional programmers? — inverts here: the measurable frontier that moved is the community’s (developer records, first-timer records, review throughput), not the man’s. His personal code output shows no documented increase.

AI leverage × pre-existing strength (2×2, template Section 14)

Torvalds lands in the strong-programmer row, low-to-moderate adoption column: the “traditional master” cell — with the twist that the row’s question, “what exactly does AI amplify in a great programmer?”, gets an institutional answer: it amplifies what arrives at his gate (patches, reports, reviewers’ tooling), not his personal capacity. His response was to amplify the institution instead: policy, tags, advisory LLM review, hardnosed gating.

“Taste-to-code ratio” (template Section 15) — qualitative construct

Not a measured metric; labeled as a qualitative construct. Torvalds’s own compilers line is the cleanest statement of the ratio in the cohort: “AI will increase your productivity by a factor of 10. And I claim that compilers increase your productivity by a factor of a thousand” (LWN) — a claim that judgment compounds more than typing, from a man whose typing has been irrelevant to his output since ~2000. For the integrator, AI raises the volume of code arriving, not the judgment applied to it; the ratio framework fits him better than any builder case — and his July 2026 retraction of the 10x number is itself a taste act: refusing to state an unmeasured number as fact.

The unchanged core (template Section 16)

What he refused to change, with evidence:

1. Understand the end result. Even for AI-assisted hobby code, “he looks at the assembly language end result because that is what he grew up with… you need to understand not just your prompts, but you need to understand your end result” (LWN keynote).
2. Humans certify; tools assist. “AI agents MUST NOT add Signed-off-by tags. Only humans can legally certify the Developer Certificate of Origin”; “the assistant must never send anything itself” (docs.kernel.org).
3. People over AI in collaboration. “He does not use AI to work with people. ‘And I should suggest that you don’t do that either’” (LWN).
4. Process continuity over novelty. “The kernel has had the same process now for about 20 years, since switching to Git” — the process survived; only the intake changed (LWN keynote).
5. Refusal to let the project take a side. The docs must be “just a tool” statements — “I do *not* want any kernel development documentation to be some AI statement” (LKML, 2026-01-07).
6. The engineer’s identity. “I am not a visionary, I’m an engineer… I’m looking at the ground, and I want to fix the pothole that’s right in front of me” (TED 2016) — unchanged in the AI era, per the keynote’s tone three decades in.

Hypotheses H1–H4 against this case (template Section 19)

• H1 (great programmers become super-programmers) — Not supported for the individual, which is itself the finding. His personal code output is unchanged in kind (rare, small appearances in LWN’s tables; two hobby repos). The amplification the template predicts shows up at project level: developer-count and first-timer records in the cycles after tools improved (LWN). Against: he attributes the change to tooling (“AI tools had improved enough for a lot of people”), not to anyone’s amplified skill, and retracted his own 10x claim as guesswork. Not testable at the individual level for this case; community-level amplification observed.
• H2 (programming moves upward) — Supported at the ecosystem layer, refused at the personal layer. The kernel’s answer to AI was to move the abstraction of its controls upward (policy, attribution tags, advisory review systems, threat-model docs) — while Torvalds personally refuses to raise his level further, because his level has been the top since ~2000 and he explicitly keeps humans in it (“I do not use AI to work with people”). Supported with a stated refusal at the top.
• H3 (more specialized, not less) — Partially. His professional layer was already maximally specialized (kernel internals); the observed expansion is hobby-breadth (audio DSP, hardware, Python he doesn’t claim to know). This case shows specialization as a constant, not a post-AI migration — the template’s binary doesn’t bind at the ceiling.
• H4 (taste + orchestration is the scarce skill) — Supported, with the sharpest amendment in the cohort so far: the scarce skill at this scale is not personal orchestration but institutional judgment — deciding what the tools may touch. His 2026 output is boundary-definition: humans certify, tools never send, AI bugs are public, docs stay neutral, review bandwidth is the scarce resource. The Basecamp 5 lesson in the DHH case (taste must be institutionalized) is here already native: the kernel’s taste lives in its merge process, and that process is what he is re-engineering.

Gaps and what would change this picture

• No per-commit sampling of his own stream (template Section 5): no kernel git clone in this session; the per-case numbers come from LWN’s statistics articles. A follow-up should sample the mainline merge stream and his personal commits directly.
• 2023–2024 specifics are thin: the three 2023–2024 public statements are known via the ItsFOSS chronology citing ZDNET and TFiR; those underlying pages could not be fetched this session, so the quotes are secondhand from a fetched source. The 2026 record, by contrast, is primary.
• lore.kernel.org refused direct fetches; the January 7 post was read in full via lkml.org, the July 14 post only via The Register’s and ItsFOSS’s quotations of it.
• No evidence found on: which model powered Antigravity in his AudioNoise session; whether he personally runs any coding agent (nothing suggests he does beyond the documented toy-layer and Sashiko service use); his local-AI setup specifics (“many of the main kernel developers are using local AI” — unnamed tools).
• Ars Technica’s full text could not be read (405; archive snapshot truncated after the standfirst), so only its headline framing is cited.
• This is one case; the cross-case matrix stays meaningless until more cohort members are run.

Two cases on one spectrum (contrast coda, interpretation)

The template’s Section 12 exists so the study is not an AI-hype exercise. Run together, DHH and Torvalds are its designed bookends, and the contrast is the value:

Both cases agree on the invariant (the human owns the final selection), and they disagree productively on where the surplus goes: DHH spent implementation abundance on scope; Torvalds is spending institutional authority on keeping the abundance governable.

Interpretation

This case suggests that — and this paragraph is our interpretation, not a sourced fact — the template’s “where they stop delegating” question has a third answer besides DHH’s. For a builder like DHH, the boundary is taste: delegation stops where output stops being reviewable. For a gatekeeper like Torvalds, the boundary is the certificate: delegation stops where judgment must be legally owned by a human (DCO), socially owned by a community (process), and personally embodied (“understand your end result”). His 2026 behavior is not adoption or rejection but boundary maintenance at scale: he personally vibe-codes what he has disclaimed, institutionally adopts what he can bound with process, and refuses AI in the layer — people — that his reputation is actually made of. The 2000 anecdote is the tell: he has been here before, when growing scale forced him out of coding and into process. AI re-runs that lesson at community scale, and his response is the same tool that worked the first time — process, tags, and a short list of things that may not be automated, written down where everyone can read them.

Sources

Fetched and read during the run on 2026-09-21:

Primary / direct layer

• Linux 7.1-rc4 announcement by Linus Torvalds, 2026-05-17 (LWN archive, full text) — the security-list flood, the AI-bugs-are-public doctrine, Willy Tarreau’s AI-assisted-report doc commits; message-ID and lore archive-link on the page.
• LKML: Linus Torvalds, Re: [PATCH] [v3] Documentation: Provide guidelines for tool-generated content, 2026-01-07 (lkml.org, full text) — the “zero point in talking about AI slop” / “just a tool” post.
• Kernel Guidelines for Tool-Generated Content (docs.kernel.org) — transparency rules; “reviewer and maintainer bandwidth is a scarce resource”; “expected to understand and to be able to defend everything you submit.”
• AI Coding Assistants (docs.kernel.org) — DCO restriction on AI agents, Assisted-by: LLM format, mandatory find-and-fix procedure, “the assistant must never send anything itself.”
• Development statistics for the 7.0 kernel (LWN, 2026-04-13) — 14,251 non-merge commits; 2,362 developers (record); 489 first-timers; 31 Assisted-by commits; Torvalds’s 15,884-line “rare appearance.”
• The rest of the 7.1 merge window (LWN, 2026-04-27) — 12,996 changesets by rc1; 342 first-timers; >140,000 lines removed on LLM-driven reports.
• The role of LLMs in patch review — Sashiko (LWN, 2026-03-31) — the mm-subsystem fight, Morton’s 22/35 sample, 10,000+ reviews in a month.

Self-report layer

• Dirk and Linus discuss AI and kernel development (LWN, 2026-05-25; OSS NA keynote 2026-05-20) — the ~2000 scaling anecdote, “20% more commits,” “I love the tools,” Sashiko endorsement, “does not use AI to work with people,” compilers-vs-AI productivity framing, assembly checking on hobby code, local-AI advocacy.
• Linus Torvalds tells AI haters to fork off (The Register, 2026-07-15) — quotes the July 14 lore.kernel.org post (“absolutely put my foot down… fork it. Or just walk away”); the lore message itself refused direct fetches this session.
• Linus Torvalds Spent Years Dismissing AI, Only to Vouch for It (It’s FOSS, 2026-07-17) — chronology with primary links: OSS Japan Dec 2023, OSS NA 2024, TFiR Oct 2024 (“90 percent marketing and 10 percent reality”), OSS Korea Nov 2025 (“fairly positive” on learner vibe coding), AudioNoise, kernel policy April 2026, Greg KH “clanker” fuzzing, “a bit more hardnosed,” OSS India July 2026 retraction of the 10x estimate. The ZDNET and TFiR pages it cites could not be fetched this session; those quotes are secondhand from this fetched source.
• Even Linux Creator Linus Torvalds is Using AI to Code in 2026 (It’s FOSS, 2026-01-11) — AudioNoise README quotes (“cut out the middle-man – me”), Google Antigravity, GuitarPedal reference; README text as quoted there (the repository pages were not fetched directly).

External observation layer

• Linus Torvalds to critics of AI coding in Linux: “Fork it. Or just walk away.” (Ars Technica, 2026-07-16) — live page returned 405; verified via Wayback snapshot 2026-08-27, which truncated after the standfirst; only the headline, author (Kyle Orland), date, and standfirst are cited.
• LWN’s three development articles above double as external observation (Jonathan Corbet, Daroc Alden, Joe Brockmeier bylines).

Baseline layer (pre-2023)

• History of Linux (Wikipedia) — 1991 comp.os.minix announcement text as reproduced there (tertiary source, labeled as such; the archived newsgroup post itself was not fetchable this session); MINIX/GCC development context; GPLv2 decision (Feb 1992).
• Git (Wikipedia) — original author Linus Torvalds; first release 2005-04-07 (infobox).
• The mind behind Linux (TED 2016) — “I am not a visionary, I’m an engineer”; the interview where the good-taste linked-list example appears.
• good-taste, part 1 (felipec.github.io) — documentation of the TED 2016 interview’s linked-list “good taste” illustration, with the two code versions and video timestamp.

Deliberately excluded from evidence: Reddit threads and aggregations (directional only, not fetched), Neowin and Phoronix items (fetch failed or content unavailable this session), ZDNET pages (fetches returned only navigation chrome), an AI-generated blog-summary site found in search, and all quotes from pages not actually fetched — anything used from those is explicitly marked secondhand in the text above.

Template: templates/research/pre-llm-elite-programmer-ai-adaptation.md in this repo. Every claim above is either a sourced fact with the link shown, a labeled self-report, a labeled derivation, or labeled interpretation. Nothing in this note was recalled from model memory without a fetched source.