Linux Kernel and Rust Project Adopt Landmark AI-Generated Code Policies in 2026

In 2026, two of the most influential open-source projects on the planet—the Linux kernel and the Rust project—each adopted formal policies to govern AI-generated code contributions. Though their approaches differ in scope and strictness, both converge on a single principle: humans remain fully accountable for every line of code submitted under their name.

Here is a breakdown of each policy, the reasoning behind it, and what it signals about the future of AI-assisted open-source development.

Linux Kernel: Project-Wide Policy with Subsystem-Level Hardening

The Linux kernel adopted its first project-wide AI policy in April 2026, formalized with Linux 7.0, through an official AI Coding Assistants document at Documentation/process/coding-assistants.rst . The policy establishes four core rules:

• Human-only certification: AI agents must not add Signed-off-by tags. Only a human can certify the Developer Certificate of Origin (DCO) .
• Full human liability: The human submitter bears full legal and technical responsibility for every line of AI-generated code, including bugs and security flaws .
• Mandatory attribution: Contributions must include an Assisted-by: tag specifying the AI tool name, model version, and any auxiliary analysis tools used .
• Standard process applies: AI-assisted patches must still follow kernel coding style, submission guidelines, and licensing requirements .

Subsystem maintainers also have discretion to impose stricter rules. In August 2026, Johannes Berg, maintainer of the kernel's wireless networking subsystems (802.11, mac80211, WWAN, rfkill), announced a notably firm stance on AI/LLM-generated patches :

• "Three-second review" rule: Any patch that does not pass as obviously correct within three seconds of review will be ignored outright .
• No iterative back-and-forth: He refuses to engage in review cycles to fix AI-generated patches .
• Rejection of low-quality "slop": Patches that are not trivially correct are rejected with no further discussion .

This policy followed Greg Kroah-Hartman's rule that the drivers/staging/ subsystem rejects all LLM-generated patches except for genuine security fixes .

Why the Linux Kernel Took This Approach

The kernel community identified three core problems driving the policy:

1. Review bandwidth crisis: Maintainers are overwhelmed by a flood of AI-generated patches, many of which are superficially polished but semantically wrong or dangerous .
2. Signal degradation: Polished patches no longer reliably indicate genuine effort, understanding, or long-term contributor interest .
3. Accountability: The community concluded that human accountability is non-negotiable—the machine cannot certify legal origin or take responsibility for bugs .

Rust Project: Five-Team LLM Policy (August 5, 2026)

On August 5, 2026, five Rust teams adopted a formal LLM policy for the rust-lang/rust monorepo . The policy is explicitly not an official project-wide stance and applies only to the core repository and the adopting teams .

What Is Permitted (with disclosure)

• Using LLMs to answer questions, analyze code, or learn the codebase for one's own understanding .
• Private code or prose review by a contributor .
• Bug discovery that the contributor verifies themselves .
• Machine translation of content .

What Is Prohibited

• Submitting LLM-generated documentation, including doc comments and safety comments .
• Posting LLM-generated GitHub comments, issue bodies, pull-request descriptions, compiler diagnostics, or substantial source code comments .
• Publishing LLM-authored code unless prior reviewer consent has been obtained and the use of an LLM is explicitly disclosed .
• Submitting AI-generated content without understanding or review .

The policy's working summary: "It's fine to use LLMs to answer questions, analyze, distill, refine, check, suggest, review. But not to create."

Why Rust Took This Approach

Jynn Nelson, the policy author, outlined three core problems in the official announcement blog :

1. Polished technical products no longer indicate effort and understanding: LLMs can produce clean-looking patches that the submitter does not understand, breaking the social signal that a careful PR represents genuine human investment.
2. Review bandwidth is already overwhelmed: There are 1,281 open PRs on rust-lang/rust. Making code easier to write without increasing reviewer capacity exacerbates a pre-existing bottleneck.
3. Mechanical copy-pasting wastes everyone's time: Contributors pasting review comments into an LLM and then pasting the LLM's response back onto GitHub erodes trust and bypasses human deliberation.

The policy was also motivated by a desire to move from informal, inconsistent moderation to clear, published rules that reviewers can point to and new contributors can find .

Broader Implications for Open-Source Governance

Both policies reveal a common pattern and a shared set of governance challenges:

Dimension	Linux Kernel	Rust Project
Scope	Project-wide policy + subsystem-level hardening	Five teams, core repo only
Human accountability	Absolute: submitter bears all legal/technical liability	Absolute: no AI-generated content without disclosure and understanding
AI-generated code	Allowed with attribution and human sign-off	Effectively banned unless pre-approved by a reviewer
AI-generated prose/docs	Not a focus of the policy	Strictly prohibited
Subsystem discretion	Maintainers can go further (e.g., wireless "3-second rule")	Scope-limited by team adoption

What This Signals

• The "review crisis" is the central tension. Both projects recognize that LLMs dramatically increase the volume of contributions without increasing the number of qualified reviewers. This is the single biggest governance stressor .
• Signal collapse is real. Both communities note that polished PRs once signaled effort and understanding; LLMs have broken that signal .
• Formalization is replacing ad-hoc moderation. Both projects moved from informal rules to codified policies precisely because inconsistent enforcement was confusing to contributors and exhausting for maintainers .
• Subsystem autonomy matters. The Linux kernel approach allows individual maintainers to set stricter rules, as Johannes Berg did for wireless. The Rust approach is team-by-team adoption .
• There is no consensus on AI itself. Rust's policy explicitly acknowledges there will never be a project-wide consensus on AI, so the policy focuses narrowly on contribution mechanics rather than making a moral judgment about LLMs .