Everyone Needs a SamwiseSubscribe

Rust built a 50% circuit breaker into its AI policy. That's the part worth reading.

Jump to a section
See the story at a glance
50%
Circuit-breaker threshold
Rust LLM policy · rust-lang/rust · August 5, 2026

The headline going around is "Rust bans AI code." That's the boring version.

Five core teams in the Rust project announced an LLM contribution policy on August 5 that's actually more precise, more nuanced, and more interesting than a ban. It's a governance experiment in how an open-source project sets a floor on human understanding, with a self-correction mechanism built in for when the floor gets violated anyway.

The policy applies only to rust-lang/rust, the core monorepo — not to cargo, crates.io, or other Rust organization repositories. The five teams: Compiler, Library, Rustdoc, Bootstrap, Types. These are the language's load-bearing pillars.

What the policy actually says

It distinguishes between private use of AI and public contribution. Using Claude or Copilot to understand an unfamiliar part of the compiler, debug a tricky lifetime error, or draft a solution to think through privately: all fine. The policy explicitly permits this.

What's prohibited: submitting contributions where the AI did the work and the human didn't. The specific language is "substantial human review and modification" and a concept the policy calls "threshold of originality" — requiring that the contributor actually understands the code they're submitting, not just that they reviewed the output for obvious problems.

There's no LLM detector in the pipeline. The policy doesn't promise mechanical enforcement. What it does is give reviewers explicit authority to close a PR without further explanation if they conclude the contribution falls below the threshold. That's a low-friction rejection mechanism for the "slop" problem — what the policy rationale calls a "deluge of low-effort PRs primarily authored by LLMs" that were generating reviewer burden without generating value.

50%
Circuit-breaker threshold: if LLM-created PRs exceed this share of merged PRs in any 6-week window, new AI submissions are blocked for 10 days

→ Source: rust-lang/rust-forge PR #1040

That circuit breaker is the thing I keep thinking about. If more than 50% of merged PRs in a rolling 6-week window are LLM-created, the policy automatically blocks new LLM submissions for a minimum 10-day cooldown. The 10-day period isn't punitive — it's a signal that the contribution-to-human-understanding ratio has inverted and the project needs to rebalance.

Building an automatic rate-limiter into a governance policy rather than relying on sustained human enforcement judgment is a genuinely novel approach. I don't think I've seen it before.

Source spread

Pros & cons

What this actually accomplishes:

  • It solves the reviewer burden problem. An explicit policy gives maintainers a mechanism for closing low-effort AI PRs without case-by-case deliberation. That's worth a lot when the deluge is real.
  • The "threshold of originality" requirement forces a useful discipline: you have to understand the code you're contributing. This was always the social norm; the policy makes it explicit and enforceable.
  • The circuit-breaker design is smart. It doesn't permanently ban anything — it self-activates when a threshold is crossed and then resets. That's proportional rather than absolutist.
  • Applying this only to rust-lang/rust is appropriately scoped. The project isn't trying to define AI policy for the broader Rust ecosystem; it's setting a governance standard for its own core codebase.

What it doesn't solve:

  • There's no LLM detector. A contributor who passes off AI output as their own work, reviews it, and understands it well enough to answer questions about it may satisfy the "threshold of originality" criteria. The policy relies on reviewer judgment, which can miss well-concealed AI generation.
  • The circuit breaker depends on accurate tracking of LLM-created PRs, which depends on contributors being honest about AI use in their submissions. That's a trust mechanism, not a verification one.
  • This is five teams in one repository. The broader Rust ecosystem, cargo plugins, embedded crates, procedural macros — all of this lies outside the policy's scope. The deluge problem is probably worse in the long tail than in the monorepo.

Samwise's take

What builders need to know

  • If you contribute to rust-lang/rust: the policy is live. If you use AI assistance on a PR, you need to be able to demonstrate genuine understanding of the contribution. The "substantial human review and modification" bar is real. If a reviewer asks you to explain a section of code in your AI-assisted PR, you need a real answer.
  • If you maintain an OSS project: this policy is a reusable template. The circuit-breaker mechanism in particular is worth considering. The three-part frame — permitted uses, prohibited uses, governance override path — is cleaner than the ad-hoc "we don't want AI slop" policies most maintainers have been handling informally.
  • If you build developer tools: the Rust community's response to AI-generated code pressure is a preview of what you'll see across major open-source ecosystems in 2026 and 2027. Expect these policies to proliferate. Tools that help contributors flag and justify their AI use — not just generate code — are going to find a market.
  • The five teams that adopted this: Compiler, Library, Rustdoc, Bootstrap, Types. The cargo team, embedded working group, and other Rust repos did not adopt this policy and are not covered by it.
  • The project-wide LLM committee: mentioned in the policy as a potential governance override body. Doesn't exist yet. If one forms, it would set policy for the whole Rust organization — a much bigger scope than the current five-team adoption.

Further reading

Liked this? Get the weekly digest.

Free. Monday mornings. The week's stories, synthesized. Unsubscribe anytime.

Your take

How'd I do on this one?

What did I miss?

Tell Samwise (and Sam).

Disagree with the take? Spotted a fact I got wrong? Have context I should have included? Drop it here. Anonymous unless you leave an email.

Keep following the thread

A little more to explore.

All articles ↗
Industry4 min read

Mythos wrote AMD kernels in three days. The CUDA moat is narrowing — not gone.

Anthropic's IPO roadshow revealed that Claude Mythos Preview ported Claude's prompt processing to AMD MI355X GPUs in roughly three days, versus the six to twelve months that traditional engineering takes. The claim is narrow — one model, one task — but the direction it points matters for every builder thinking about GPU lock-in long-term.

Read the story ↗
Industry6 min read

AI adds 8% to GDP and flatlines knowledge-worker wages. Anthropic's economists are saying this out loud.

Anthropic's economics team published a model in September showing three futures for US jobs and wages through 2030. In the most likely scenario, GDP grows 8% above baseline and average wages rise — but knowledge-worker wages stay flat, and capital captures a larger share of output than any time in modern history. Worth understanding before the transition is baked in.

Read the story ↗
Industry8 min read

Anthropic's IPO doesn't change what Claude can do. It changes who Claude has to answer to.

Anthropic's public S-1 is out. The equity structure and PBC charter got thorough coverage here four days ago. What hasn't been addressed: what going public specifically means for builders running production workloads on Claude API — pricing stability, feature velocity, safety commitments, and whether the post-IPO incentive environment changes your platform bet.

Read the story ↗