← Back to feed

The Rust compiler project on August 5 published a formal policy governing how LLMs can be used when contributing to rust-lang/rust — the monorepo housing the Rust compiler, standard library, and tooling. Five teams (compiler, language, libraries, devtools, infra) adopted it simultaneously.

It is not a blanket ban on AI tools. It is a formal partition: LLMs are allowed as thinking aids, banned as creation tools.

The Core Rule

“It’s fine to use LLMs to answer questions, analyze, distill, refine, check, suggest, review. But not to create.”

That sentence, from the policy document published at forge.rust-lang.org, is the operative line. Asking an LLM to privately review your draft code before submitting it: allowed. Submitting code the LLM wrote without engaging with what it does: banned.

The policy uses a four-tier structure:

Status	Applies To
✅ Allowed	Any use where only you see the output: asking questions, summarizing issues privately, reviewing your own drafts
⚠️ Conditional	Must disclose: trivial mechanical changes, machine translation, review bots, clearly-experimental PRs
❌ Banned	LLM-created comments, docs, diagnostics, code submitted for real review; replacing human judgment with LLM judgment
🔨 Code of Conduct	Lying about LLM usage

Comments, documentation, and diagnostic messages are categorically banned from LLM generation. That is stricter than most industry policies. The unconditional disclose-or-ban structure removes the grey area: if you used a model to write anything that appears in a PR, you say so.

Why Now

The policy author cites three failure modes that accumulated until a formal policy was unavoidable.

Polished PRs no longer indicate effort. The project’s culture has historically been reluctant to close PRs, treating them as evidence someone put serious work in and wants to contribute. When a model can produce a well-formatted, test-passing PR in seconds, that signal breaks. Reviewers cannot distinguish deep understanding from a copy-paste job, and the project’s default posture of mentorship and incremental engagement stops being appropriate to apply uniformly.

Review bandwidth. At the time of writing, rust-lang/rust had 1,281 open PRs — already a strain on reviewer capacity. Most review work is deciding whether an approach is correct, not just catching bugs. An increase in PR volume without a matching increase in qualified reviewers compounds an existing problem. The policy notes that “shotgunning PRs at reviewers incurs a high mental cost.”

Mechanical copy-pasting. Reviewers were encountering contributors who, in response to a review comment, pasted it into an LLM and pasted the output back into the PR without engaging with the underlying point. The interaction created the appearance of responding to feedback while bypassing the reasoning the feedback was asking for.

The policy is not an attempt to catch every violation. Its stated goal is removing plausible deniability: forcing a choice between following the policy and knowingly violating it.

What Changes for Contributors

For most contributors, little changes. Using an LLM privately — to understand an unfamiliar code path, to draft text you then rewrite, to generate solutions you learn from and replace with your own implementation — remains fully allowed.

The policy carves out explicit exceptions for experimental work. PRs labeled S-experimental, tagged as PERF benchmarks, or marked with r?ghost comments can include LLM-generated code, because those PRs serve infrastructure purposes (crater test runs, performance data collection) rather than merging into the codebase.

Machine translation is conditionally allowed with disclosure. A contributor who writes a comment in their native language and uses an LLM to translate it to English is welcome to do so, as long as they note it. This is the kind of LLM use the policy’s authors consider respecting the community’s norms.

What is explicitly banned: having an LLM write a diagnostic message, comment, or doc string and submitting that output. The ban on LLM-generated diagnostics is notable — diagnostics are one of Rust’s major UX strengths, and the project is protecting the craft standard of that output.

The Broader Significance

Rust joins a growing list of open-source projects grappling with LLM contributions, but its approach is distinct. Banning AI tools outright is one option. Having no policy is another. Rust chose a third path: formalize the norms that were already developing informally, make them public so new contributors know the rules, and give reviewers something they can point to when closing a PR.

The deeper argument in the policy document is about what open-source contribution is. Code is the smallest and least important part of a PR in the project’s view. What matters is that the author understands what the code does, can plan how it will change, can engage in the design discussion, and is available for the follow-up work that any non-trivial change requires. A model can produce the code. It cannot do any of those other things.

The policy is for rust-lang/rust specifically, not for the Rust project at large. Other repositories in the Rust ecosystem govern themselves independently.