Open source maintainers have been arguing about LLM-generated patches for three years. Some close them on sight. Some welcome them. A few major projects have decided that the answer is somewhere in between, and the Rust project has now put forward the most layered version of that middle path so far. According to the announcement, the policy is built around a tier table, a hard tripwire, and a new label, and it has been adopted in the core repository that hosts the compiler and the standard library.
The headline to take away is that Rust did not ban AI. It restricted a specific set of uses, drew a line at AI-authored text in human-submitted artefacts, and added a circuit breaker that pauses AI-tagged merges when the share crosses 50 percent over a six-week window. Every other project that adopts a similar policy will face the same set of questions, and Rust has produced the most workable first draft.
A tiered table, not a ban
The shape of the policy is a three-tier table. The bottom tier permits use without disclosure. The middle tier permits use with disclosure. The top tier forbids use outright, declared or not. What makes the policy unusual is that the top tier is not reserved for the worst behaviour. It covers things that an LLM can in fact do well, but whose output cannot be published under a human name.
At the bottom of the table, contributors are free to ask an LLM about the codebase, ask it to explain how a subsystem works, or run a private session where most of the output is discarded. None of that touches the project.
The middle tier is where the policy does the work that matters. Machine translation of a foreign-language contributor comment is allowed. A trivial fix that is recognisable as LLM output is allowed. A self-verified bug hunt where an LLM narrows the search and a human verifies the patch is allowed. The label is disclosure, and disclosure is what gives the project real telemetry on what is actually happening.
At the top of the table, contributions are blocked regardless of disclosure. An LLM cannot write your comments, file your issues, or compose your pull request description under your name. Documentation, safety comments, and compiler diagnostics are all off-limits as LLM-authored text. A pull request that has been reviewed only by an LLM, or has not been reviewed by the author themselves, does not meet the bar.
The ai-assisted label
The interesting wrinkle is a new label, ai-assisted, for code that goes beyond the disclosure tier. An LLM-written patch that has been coordinated with a reviewer in advance, that is unlikely to introduce a Rust safety regression, that is fully tested, and that is understood by both the author and the reviewer, can ship under that label. Every contributor is still on the hook for explaining every line.
The label is the bar between “this is allowed with disclosure” and “this needed a real conversation with a reviewer.” It is also the bar that the circuit breaker reads.
The circuit breaker
A six-week moving window counts AI-tagged merges against the total. If the share crosses 50 percent, new AI-tagged merges are paused until the team reviews the trend. The threshold is set deliberately to trip in obvious cases, not to optimise for any particular AI adoption rate.
The mechanic is the part of the policy that other projects will borrow first. Most code review queues are not yet flooded with AI-generated patches, but a few are, and the right policy response when that happens is not a slow re-litigation of the rules. A tripwire that activates itself is a cheaper intervention.
The policy is explicit that the threshold and the recovery process will evolve as the team learns what real submission rates look like. The tripwire is the start of a conversation, not the end of one.
NetworkManager’s simpler version
NetworkManager shipped its own policy recently, attributed to Red Hat engineer Josephine Pfeiffer, and it is the cleanest refusal of the layered approach on record. The new section in CONTRIBUTING.md is a flat ownership statement: the author owns 100 percent of every line they submit, large machine-generated merge requests without human line-by-line review get closed without merge, and the maintainer who writes the change is the one who has to explain it in a review thread. Source: the project’s contributor documentation.
NetworkManager has no ai-assisted label, no disclosure tier, and no circuit breaker. The policy is “you own every line, or it does not ship.” The contrast with Rust is useful: the same problem, a different policy response.
Codeberg’s structural response
Codeberg, a non-profit git hosting platform, has taken a third path. Members recently voted to ban projects built mostly from AI-generated code, citing server strain and the cost of storing generated content that does not get maintained. That is a structural response rather than a per-pull-request response, and it sits closer to a hosting policy than a coding policy.
The three responses, Rust’s tiered table, NetworkManager’s line of ownership, and Codeberg’s project-level ban, are three different ways of saying the same thing: low-accountability AI-generated content is starting to outpace the human attention that review and maintenance require.
What the policy still leaves open
The Rust announcement closes with a note that the policy is meant to be a starting point. Three questions are flagged for the next revision:
- Whether contributors are doing interesting and useful things with LLMs, or just the same low-effort patches at higher volume.
- Whether contributors are learning to become Rust contributors, or are submitting without understanding what they are submitting.
- Whether contributors are making repeat contributions, or are one-shot generators.
Repeat contributions are the practical signal. A one-off LLM-generated patch is a low-effort contribution that consumes reviewer time. A second, third, and fourth patch from the same contributor is a different signal. The policy is built to capture that signal.
The policy is also silent on a few edges. How an LLM review should be attributed in a human comment is not specified. Whether ai-assisted applies to a patch that was started by a human and finished by an LLM is not specified. Whether the label applies to a patch that was started by an LLM and finished by a human is not specified. Each of these is a place where the policy will need a clarification eventually.
Trade-offs
A tiered policy does not come free.
- Contributor burden grows. Every contributor has to think about which tier a piece of work falls into, and every reviewer has to verify the label. That is a real cost for a volunteer project.
- Labels will be under-declared. Self-reporting is the only enforcement without an automated detector, and an under-declared label is a slow compliance failure.
- The 50 percent threshold is a tripwire, not a strategy. If AI quality genuinely improves, the threshold is too tight. If it does not, the threshold is too loose.
- The policy is silent on code review by LLMs. An LLM review is a tool, not a substitute, but the policy does not say how to attribute or quote an LLM review in a comment thread.
- Adjacent tooling is out of scope. The bots that triage issues, the bots that suggest labels, and the bots that draft pull request descriptions are all governed by their own project rules.
What this changes for open source
The pattern is starting to converge. Rust has the most careful policy so far. NetworkManager has the simplest. Codeberg has a structural response. The interesting question is whether a future version of the Rust policy will be adopted as a template, or whether each project will keep writing its own copy.
For a contributor, the practical takeaway is that the rules are getting stricter, that the project whose repository you are sending code to is the one whose rules apply, and that “I generated this with an LLM and it works on my machine” is no longer a finished answer. The sliding scale from “fine” to “banned” is being written down, project by project, and the next time you open a pull request, the policy will likely be one click away.