Rust's LLM Policy Bans Creation, Not Assistance

Five of the teams that maintain the Rust compiler and standard library — compiler, libs, types, rustdoc, and bootstrap — have adopted a formal LLM policy for the rust-lang/rust repository. The core rule fits in a sentence: it's fine to use LLMs to answer questions, analyze, distill, refine, check, suggest, and review. But not to create.

That sentence took nearly four months to land. Jynn Nelson opened the policy PR against rust-forge in mid-April; by late May the debate had generated over 3,000 Zulip messages, and the text merged only after a formal sign-off across all five teams. It was contested to the end — Niko Matsakis, one of Rust's most senior language designers, argued the draft was "worse than no policy" because of what it signals to a generation of contributors who treat LLMs as standard equipment. That it shipped anyway tells you how much strain Rust's review queues are under.

A different reason to say no

Rust isn't the first major project to restrict AI-generated contributions, but it's the first big one to do it for this reason — and the reason matters more than the rule.

Gentoo banned AI-generated code in April 2024, NetBSD followed weeks later, and QEMU declines AI-generated patches outright. Those are provenance arguments: nobody can honestly certify the origin of model output under a Developer Certificate of Origin, so the legally safe move is refusal. At the other pole, LLVM, Mesa, Firefox, and the Linux kernel have converged on disclose-and-stay-accountable permissiveness.

Rust's policy makes neither argument — it explicitly rules copyright out of scope. The problem it targets is social. A polished pull request used to be a costly signal: proof that someone understood the problem and invested effort, which told reviewers where to spend scarce attention. LLMs broke that signal without breaking the artifact. The PR still looks polished; it just no longer means anything. And in a project where review bandwidth — not code production — is the binding constraint, a tool that makes plausible code free is an attack on the economics of maintenance, whatever its copyright status. curl learned the same lesson through its bug bounty, which drowned in AI-generated "slop" reports until Daniel Stenberg started publicly banning submitters.

That's why the policy's slogan is "write better, not faster." Faster is precisely the failure mode.

Where the line actually sits

The tiers are more pragmatic than the headlines suggest. Private use is untouched and undisclosed: ask a model to explain the query system, summarize a 200-comment tracking issue, review your own diff before you push — nobody cares, because nobody else has to read the output. Studying an LLM's solution and then writing your own from scratch is likewise fine.

Disclosure kicks in when output becomes visible: machine-translating your own words, trivial mechanical fixes, bugs an LLM found (after you've verified them yourself), and advisory review bots running on separate, blockable accounts.

The hard bans cover anything a maintainer must read as if a human meant it: comments, issue bodies, PR descriptions, documentation including doc comments and safety comments, and compiler diagnostics. Notably, an LLM review can never count toward a merge decision.

Then there's the escape hatch, framed as an explicit experiment: LLM-generated code may land if it's pre-arranged with a reviewer, avoids soundness-critical territory (the trait system, MIR building, the query system), and is high-quality, well-tested, and fully understood by both author and reviewer. Such PRs get an ai-assisted label. Internal tooling like tidy is the designated sandbox. And there's a genuinely novel mechanism: if LLM-created PRs ever exceed half of merges over a six-week window, a circuit breaker halts new ones for at least ten days. Nobody else's AI policy has a rate limiter.

Policy engineered like code

The scope is deliberately narrow — one repository, excluding submodules, subtrees, and the rest of the rust-lang org — and the text anticipates its own revision. The leadership council is weighing a standing LLM committee, and a project-wide policy RFC is already open. Enforcement is aimed at actions, not tools: reviewers can bounce non-compliant PRs, lying about LLM use is a Code of Conduct matter, and — the underrated clause — so is harassing people you suspect of using one. Anyone who's watched an "this reads like ChatGPT" accusation spiral on an issue tracker knows why that's in there.

The obvious objection is that disclosure regimes can't catch a disciplined liar, and the policy essentially concedes it. That's the right trade. A rule you can't perfectly enforce still coordinates the honest majority, and the CoC hook handles the rest. The weaker point is friction: pre-arranging LLM-assisted work punishes exactly the good-faith newcomers Rust already struggles to onboard, while the drive-by sloppers were never reading CONTRIBUTING.md in the first place.

What to take from it

If you contribute to rust-lang/rust, the practical change is small unless you were pasting model output into public view: keep the assistant for comprehension and self-review, write your own prose, and if you want LLM-written code merged, ask the reviewer before you open the PR and stay out of compiler internals.

If you maintain anything else, this is the document to fork. The assist-versus-create line is a sturdier primitive than tool bans, which age badly and can't be checked, or blanket disclosure, which just shifts cost onto reviewers. The circuit breaker converts an irreversible political fight into a reversible experiment. The anti-witch-hunt clause pre-empts your next moderation crisis.

Most projects' AI policies to date have been position statements — legal hedges or vibes. This one is instrumented: labeled inputs, a rollback lever, a designated amendment path, an owner. Whether or not you agree with where Rust drew the line, it's the first LLM policy designed the way engineers design systems, and that — more than the restriction itself — is what other projects are going to copy.