Linus Torvalds on AI Coding: Why He Compares It to Compilers

10 min read · Last updated: October 24, 2026

Linus Torvalds, the creator of Linux, says AI coding is no more cheating than using a compiler. On October 13, 2026, he rejected rules that police which tools kernel developers use. What matters to him is whether you understand the code you submit. Days later, the Linux kernel removed its "Assisted-by" AI disclosure tag.

Came here from Instagram, LinkedIn, X or YouTube? Here is the full source list you came for. Everything below is built from these, nothing else.

The mailing list thread

• Sasha Levin's patch to deprecate the Assisted-by tag, Oct 9, 2026
• Laurent Pinchart's objection, Oct 13, 2026
• Linus Torvalds' reply, Oct 13, 2026

The code and the docs

• Commit 1e03529, "docs: remove Assisted-by references", Oct 13, 2026
• History of Documentation/process/coding-assistants.rst, Dec 2025 to Oct 2026
• The kernel's AI Coding Assistants guide, current version

The reporting

• The Register, "Linux kernel devs drop obligatory confession of AI tool usage", Oct 14, 2026
• The Next Web, Torvalds calls AI disclosure rules "utterly stupid", Oct 2026
• The New Stack, "Why Linux creator Linus Torvalds gets angry hearing 99% of code is AI", May 29, 2026
• MakeUseOf, Torvalds' message for anyone who doesn't want AI in Linux, Oct 2026
• It's FOSS, Torvalds on AI from 2023 to 2026

Key takeaways

• On October 13, 2026, Torvalds told a kernel developer who wanted AI use disclosed: "Here's a new rule just for you: don't use compilers for any of your kernel submissions."
• The kernel removed the Assisted-by tag in commit 1e03529, which touched 7 files and deleted 88 lines.
• Only about 10% of 18,533 non-merge commits in Linux 7.3 (through -rc7) carried the tag, so its absence told maintainers nothing.
• The rule that survives: AI agents must not add Signed-off-by tags. A human reviews the code and takes full responsibility.
• His test is understanding, not tooling: "that understanding has very little to do with what tools they use."

What did Linus Torvalds say about AI coding and compilers?

Torvalds said that banning or flagging AI tools makes as much sense as banning compilers. A compiler also writes code you never typed, and nobody calls that cheating. His standard is simple: do your best and understand what you submit. Which tool produced the first draft is not the reviewer's question.

Here is the exchange. On October 9, 2026, Sasha Levin, a kernel developer at Nvidia, posted a patch saying "The Maintainers Summit reached consensus to deprecate the Assisted-by Tag." The patch drew more than 50 replies, according to The Next Web.

On October 13, Laurent Pinchart of Ideas on Board objected. He said he was "not happy removing the tag without adding another mechanism for required disclosure."

Torvalds replied the same day. As quoted by The Register and The Next Web:

"Do you not see how UTTERLY STUPID those kinds of rules would be?"

"Here's a new rule just for you: don't use compilers for any of your kernel submissions."

"The kind of expectations I have is that people do their best and I expect people to understand what they are doing."

He kept going: "I don't understand this whole idiotic concept of 'don't use AI for X'." And: "So no. We're not going to make stupid rules that say 'you can't use tools for X'."

Notice that "if AI is cheating, why aren't compilers?" is the internet's summary, not his sentence. His sentence is sharper. He took the disclosure rule to its logical end and showed where it breaks.

Why compare AI to a compiler at all?

The comparison works because both tools turn your intent into code you did not write by hand. A C compiler turns your C into machine instructions. An AI assistant turns your description into C. In both cases you are responsible for the result, and in neither case does the tool sign the commit.

Torvalds made the same point earlier in 2026. The New Stack reported on May 29, 2026 on his keynote at Open Source Summit North America, where he said: "When I see people saying, 'Hey, 99% of our code is written by AI, I literally get angry." His argument, as reported, was that those same people never credit the compiler for writing effectively all of their machine code.

Here is how the two compare, side by side.

Question	Compiler (e.g. GCC)	AI coding assistant
Writes code you didn't type?	Yes, machine code	Yes, source code
Same input gives same output?	Yes, deterministic	No, it can vary run to run
Can it hand you plausible but wrong code?	Rarely, and that is a compiler bug	Yes
Who signs off on the patch?	You	You
Did the kernel ever ask you to tag it?	No	Yes, until Oct 2026
Does the kernel ask now?	No	No, mention it in the cover letter if useful

The middle of that table is where the analogy gets weaker, and I think it is worth being honest about it. A compiler is predictable. An AI model is not. That is exactly why Torvalds puts the weight on understanding. If the tool can surprise you, you are the only safety check left.

Did Linus Torvalds change his mind about AI?

Yes, his tone has shifted a lot in two years. In an October 2024 interview with TFiR, he said: "My approach to AI right now is I will basically ignore it." Around the same time he called the AI industry "90 percent marketing and 10 percent reality," as It's FOSS reports.

By 2026 the line had moved. On July 14, 2026, on the kernel mailing list, he wrote: "Linux is not one of those anti-AI projects." And at Open Source Summit Europe in Prague on October 9, 2026, speaking with Dirk Hohndel, he said, as reported by The Next Web: "Now I'm at the point where I actually really like using AI."

He attached a warning in the same talk: "I think that you need to be very careful using AI when you're doing something real and important."

So it is not a flip from "AI bad" to "AI good." It is a flip from "ignore it" to "use it, and own what it produces."

How does AI-assisted code get into the Linux kernel now?

The kernel no longer asks you to tag AI use in the commit. It still requires a human to review the code, check licensing, add their own Signed-off-by, and take full responsibility. If maintainers should know how a patch was made, the removal commit says that information belongs in the cover letter.

Here is the history of the rule, from the commit log of Documentation/process/coding-assistants.rst.

Date	Commit	What changed
Dec 23, 2025	78d979d	Sasha Levin adds the AI Coding Assistants documentation
Jul 1, 2026	816d999	Christian Brauner simplifies the tag to "Assisted-by: LLM"
Jul 2026	(proposal)	A first attempt to drop the tag is rejected
Oct 9, 2026	patch posted	Levin proposes deprecation after the Maintainers Summit
Oct 13, 2026	1e03529	Tag removed from the docs and from checkpatch.pl

The removal commit gives the reason in plain numbers. About 10% of the 18,533 non-merge commits in 7.3 through -rc7 carried the tag, while actual LLM use is far more common. A tag that most people skip tells you nothing when it is missing.

Jeff Layton of Red Hat gave another reason, reported by The Register and The Next Web: the tag "basically serves as free advertising for proprietary LLM companies."

The process for a contributor now looks like this:

1. Use whatever tools you want. Compilers, editors, Coccinelle, an LLM. None of them go in the commit.
2. Read and understand every line. This is Torvalds' actual rule, and it is not new.
3. Check licensing. All code must be compatible with GPL-2.0-only, with the right SPDX identifiers.
4. Run the normal checks. The kernel's AI guide asks for a clean checkpatch.pl run and no new build warnings.
5. Add your own Signed-off-by. The guide says "AI agents MUST NOT add Signed-off-by tags" because "Only humans can legally certify the Developer Certificate of Origin (DCO)."
6. Mention tool use in the cover letter if it helps the reviewer. That is where the removal commit says maintainers want this information now.

The commit also states what did not change: the transparency guidance in generated-content.rst, the DCO rules, and the submitter's responsibility rules all stay.

When should you use AI for code, and when shouldn't you?

Use AI when you can fully check what it produced, the same way you trust a compiler because you can test its output. Slow down, or skip it, when you cannot verify the result: unfamiliar subsystems, security paths, or anything you would struggle to explain in review. Torvalds' own word for that second case is "careful."

Here is how I read his position as a practical rule set.

Good fits:

• Boilerplate you could write yourself but don't want to.
• Test scaffolding, scripts, and helper tools around the real work.
• A first draft you will rewrite line by line.
• Finding bugs, as long as you reproduce each one before you report it. The kernel's own AI guide asks for exactly that.

Bad fits:

• Code you are submitting so the reviewer can tell you what it does.
• Anything you would defend in review with "the AI wrote it". That answer fails Torvalds' test.
• Critical paths where a silent wrong answer is expensive and you cannot test every branch.

If that list feels familiar, it is the same argument we made in why coding fundamentals still matter in 2026. The tool changes. The need to understand the output does not.

What does this look like in an actual patch?

Before October 13, 2026, a kernel commit made with an LLM was supposed to carry an extra trailer. Now the commit only has the human sign-off, and any context about tooling moves to the cover letter. Here is a simplified example of both.

Before (July to October 2026):

mm: fix off-by-one in page range check

The upper bound check used <= instead of <, which allowed
one page past the end of the mapping.

Fixes: abcdef123456 ("mm: add page range check")
Assisted-by: LLM
Signed-off-by: Jane Developer <jane@example.org>

After (from October 13, 2026):

mm: fix off-by-one in page range check

The upper bound check used <= instead of <, which allowed
one page past the end of the mapping.

Fixes: abcdef123456 ("mm: add page range check")
Signed-off-by: Jane Developer <jane@example.org>

And the cover letter, if you want to tell the maintainer:

Subject: [PATCH 0/1] mm: fix off-by-one in page range check

I found this with help from an LLM-based review pass. I
reproduced the overflow locally, wrote the fix myself and
ran the existing mm selftests.

The same commit removes Assisted-by: from the sign-off lines that scripts/checkpatch.pl recognises, along with its "Assisted-by requires a value" warning. The only line that matters legally is still Signed-off-by, and only a human can write it.

If you are picking the tool for that first pass, our AI coding tools ranked for 2026 compares the main options.

FAQ

Did Linus Torvalds say AI coding is cheating?

No. "If AI is cheating, why aren't compilers?" is a popular summary. What he actually wrote on October 13, 2026 was a sarcastic rule: "don't use compilers for any of your kernel submissions." His point was that tool bans are absurd and understanding is what counts.

Is AI-generated code allowed in the Linux kernel?

Yes. The kernel has an official AI Coding Assistants guide. AI tools must follow the normal process, the code must be GPL-2.0-only compatible, and a human must review it, add their own Signed-off-by, and take full responsibility for it.

What was the Assisted-by tag?

It was a commit trailer, simplified in July 2026 to "Assisted-by: LLM", that asked contributors to flag AI tool use. It was removed in commit 1e03529 on October 13, 2026, because only about 10% of 18,533 non-merge commits in Linux 7.3 used it, while real LLM use was far higher.

Does Linus Torvalds use AI himself?

By his own account, yes. At Open Source Summit Europe in Prague on October 9, 2026, he said "Now I'm at the point where I actually really like using AI," while warning that you need to be "very careful" with it on real, important work.

Open the last AI-written function you shipped and explain every line out loud. If you can't, that is your work for this week. Then grab the free tools on Art of Code, and read where AI coding actually slows teams down.

Written by Adithya Guttha, Founder of Art of Code.