For nine months, the Linux kernel asked contributors to tag AI-assisted patches with Assisted-by:. In October 2026, maintainers decided to remove that requirement. The reason was neither that AI is bad nor that it is good. The tag told them nothing. The decision shows why policies that force disclosure of AI use tend not to work, and what is left when they go.

How the policy came and went

The policy began with consensus at the 2025 Maintainers Summit. It was documented by a patch submitted December 23, 2025 and approved by Jonathan Corbet in January 2026, landing as Documentation/process/coding-assistants.rst in Linux 7.0. It said that anyone using "any sort of advanced coding tool" in creating a patch should acknowledge it with an Assisted-by tag in the commit message.

Then, in July 2026, an initial proposal to remove the tag failed. At the time, even Greg Kroah-Hartman supported keeping it. The mood turned in October.

[Policy timeline]

2025-07       AI labeling proposal takes shape
2025-12-23    Related patch submitted (approved by Jonathan Corbet)
2026-01       coding-assistants.rst documented, part of Linux 7.0
2026-07       First removal proposal -> failed (Kroah-Hartman backed keeping it)
2026-10-08    Maintainers Summit in Prague reaches consensus to deprecate
2026-10-09    Sasha Levin posts a patch removing the documentation requirement
2026-10-13    Revised patch (three reasons) + Torvalds's public rebuttal
2026-10-14~16 Corbet merges into docs-next / press coverage spreads

Why the label lost its meaning

The core argument is in the numbers. Through Linux 7.3's -rc7, there were 18,533 non-merge changesets, a record, and only 1,884 of them, about 10%, carried an Assisted-by tag. Actual AI use is believed to be far higher. Contributors skip the tag for different reasons: some do not know the rule, some deliberately hide their AI use, and few maintainers ask about it.

Jeff Layton of Red Hat summed up three reasons to remove the tag.

[Reasons to remove the tag (Jeff Layton)]

1. Not everyone follows the policy
   -> a missing tag does not mean no AI, and a present one proves nothing

2. It is free advertising for proprietary LLM companies
   -> tool and vendor names accumulate in commit messages

3. It is unclear why the kernel collects the information at all
   -> even when present, it does not inform maintainer decisions

Sasha Levin, who introduced the tag, said much the same. Without a tag you cannot tell how a patch was made, and for developers who use AI for almost everything, a tag carries little information either. A device meant for transparency failed to deliver transparency.

Torvalds's rebuttal: rules that ban tools are stupid

The debate heated up around Laurent Pinchart's objection. On October 13 he wrote that he was unhappy removing the tag without another required disclosure mechanism, since submitters would otherwise push back on the question. He rejected the "unenforceable" argument: the rule sets expectations.

Linus Torvalds's reply was blunt. The gist:

[Torvalds's position, summarized]

- The whole idea of "don't use AI for X" rules is idiotic
- The same logic would give "don't use compilers for your kernel submissions"
  -> meaning you cannot understand code unless you write it in assembler
- What matters is not which tool you used but whether you understand the code
- So no, the project will not make rules that say "you cannot use tools"

This connects to his on-stage conversation with Dirk Hohndel (October 9, Open Source Summit Europe, Prague). Torvalds said he once thought AI was "just not very good" and that has changed. AI now finds real security bugs in the kernel, he said, and flaws in drivers "that nobody has touched in 20 years." On the whole, AI "is improving our code base." He also named the cost: AI is "stressing maintainers out to the point that it's a problem." About three quarters of the talks at the Maintainers Summit were about making AI tools less stressful, he said — including Sashiko, an agentic review system whose reviews now appear on the mailing list.

What survives once the label is gone

The key point is that removing the label is not the same as abandoning scrutiny.

[What changes, and what does not]

Changes
- The Assisted-by tag requirement in the commit message is removed
- checkpatch.pl no longer handles it
- How AI was used moves to the cover letter (the email with a patch or series)

Does not change
- The demand for transparency itself remains (location moves from commit to cover letter)
- Responsibility stays with the submitter
- AI agents must not add a Signed-off-by line

The patch was merged into the documentation branch (docs-next) and still needs to reach mainline. Reporting suggests good odds, since Torvalds and Kroah-Hartman support it, but it is not yet a completed change. It is worth noting that the decision curates a labeling rule; it does not ban any tool or distribution.

What developers take away

The debate turns "should I disclose that I used AI" into a more useful question: "what proves that I understood and verified this change?"

[Evidence to leave on an AI-generated PR]

- [ ] Rationale: what was the problem and why this approach
- [ ] Test evidence: what tests ran and what they returned
- [ ] Failure conditions: where this change breaks
- [ ] Review scope: which parts remain not fully understood
- [ ] Sign-off responsibility: a Signed-off-by goes on by a person who understands it

A disclosure tag can disappear. The standard by which a reviewer accepts or rejects code, and the submitter's responsibility, do not. The fact that AI wrote something is neither evidence of quality nor a disclaimer.

Conclusion: version control cannot force understanding

The kernel's decision is cold-eyed. Nobody followed the tag, and even when they did, it gave no information. So it goes. What remains is the standard that was always there: do you understand the code, did you verify it, can you take responsibility for it. The rule points at people, not tools.

So the skill that matters is not how well AI writes code but the ability to design, review, and debug it. Leaving a record on an AI-generated PR of why the change is needed, how tests confirm it, and where it fails becomes trust itself. This thread continues in The Six Layers of Code Review in the Claude Code Team and Org-Wide Code Review and Copilot Billing, and the fundamentals of commits, branches, and history are in Practical Git and Version Control.

Further reading

References

Go deeper with a course

Remove the label and responsibility still sits in the commit and the review. Working through branch protection, commit messages, history, and reverting by hand shows why recording who changed what still matters.