On Wednesday the Rust project published an LLM policy governing contributions to rust-lang/rust, the monorepo behind the compiler. Five teams adopted it; Rust contributor Jynn Nelson wrote it. It is deliberately not a project-wide position — it covers one repository and four groups: reviewers and moderators, authors posting LLM-generated code, people who find bugs with a model, and people who quote one in an issue or comment.
The number that explains the whole thing is buried mid-post: 1,281 open pull requests to rust-lang/rust at the time of writing. Rust has always had more people who want to write code than people willing to review it. Models made writing cheap and left reviewing exactly as expensive as it was. “Most of the work of reviewing is not simply catching bugs,” Nelson wrote. “A great deal of it is deciding whether this direction is a good approach.”
The policy summarizes itself in one sentence: “It’s fine to use LLMs to answer questions, analyze, distill, refine, check, suggest, review. But not to create.” Generate whatever you want privately; disclosure kicks in the moment you post something the project is expected to read. Machine translation, trivial changes, bug discovery and LLM-assisted review of someone else’s work all require disclosure. Undisclosed model output in PR descriptions, docs and GitHub comments is out.
The inversion nobody expected
Most AI contribution rules are written as a floor — keep the slop out. Rust wrote a ceiling. LLM-created code changes are allowed, but only if they are “pre-arranged, non-critical, high-quality, well-tested, and well-reviewed,” with disclosure. LLM PRs must have tests, full stop, regardless of how hard that is. And models must not generate soundness-critical changes unless the author is already a domain expert — and even then it’s discouraged.
Read that as a pricing decision. A human PR buys goodwill: it signals someone spent time, understood the problem, and might stick around. An AI PR signals none of those, so the project charges more for it in tests, pre-arrangement and disclosure. Nelson names the loss directly: a polished, well-tested, detailed PR used to be the evidence of effort. It isn’t anymore, “and in the case of autonomous agents, there is no longer someone on the other end at all.”
Our take: This is the first serious open-source AI policy that treats review capacity, not code quality, as the scarce resource — and it’s the right read. The failure mode Rust is defending against isn’t bad code; it’s good-looking code that nobody understands, arriving faster than humans can judge it. Note what Rust refused to do: no ban. Zig has a strict no-LLM rule and the Linux kernel treats AI as just another tool; Rust has no dictator to pick either, so it built a disclosure regime instead. Nelson concedes the policy has unenforceable parts and says flatly, “I do not think every rule in this policy is wholly good.” That honesty is why it will get copied. The bright line isn’t “we can detect AI” — it’s “you must declare it,” which lets moderators act on behavior instead of running a witch hunt on writing style. Every maintainer staring at an inbox they can’t drain now has a template.
What to watch
- The PR template. Rust plans to ask authors directly whether their code was LLM-generated. That single checkbox is the enforcement mechanism — and the dataset that decides how the policy evolves.
- Whether it goes project-wide. Nelson wants rules covering chats, forums and repos without their own policy. The leadership council is weighing an LLM sub-team so future changes don’t need 30 people’s sign-off.
- The anti-accusation clause. “Style is not evidence; please do not accuse people of using an LLM.” Harassment over model use is banned outright. Whether that holds in practice is the real test.
- Copycats. Apple already capped its bug-report inbox for the same reason. Expect large projects to converge on disclosure-plus-tests rather than prohibition.
The pattern is worth sitting with. In a single week, an appeals court decided a user, not a vendor, is responsible for what an agent does, and the most safety-obsessed language community on earth said the same about code: whoever’s name is on it owns it. Nobody is banning the tools. They’re assigning the liability.