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

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:

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 .