Polish Stopped Being Evidence

Rust adopted an LLM policy on Tuesday and the coverage mostly framed it as a ban. It isn't one. Read the actual text and it's something more interesting and considerably less comfortable: a formal acknowledgment that a signal engineering has leaned on for decades stopped carrying information, and that nobody has a replacement.

The facts first, because they're specific. On August 5, five teams adopted a policy covering the rust-lang/rust monorepo — not the whole project, not the language, one repo. The core line is stated plainly: it's fine to use LLMs to answer questions, analyze, distill, refine, check, suggest, review. Not to create. Private use needs no disclosure. Public LLM-generated text — PR descriptions, issue comments, doc-comments, diagnostics — is out. And LLM-authored code isn't banned at all. It's conditioned: pre-arrange a reviewer who agrees to take it, disclose it, test the edge cases, stay out of soundness-critical paths, and both author and reviewer have to actually understand the thing.

The sentence that matters is in the reasoning, not the rules. Polished PRs no longer indicate effort; authors of polished PRs no longer necessarily understand their code.

The proxy broke, not the code

Sit with that for a second, because it's a first-principles claim about how open source ever worked at all.

Review capacity has always been the binding constraint. Rust says so directly — more people want to write code than review it — and puts a number on it: 1,281 open PRs at time of writing. No maintainer reviews 1,281 patches on the merits. They triage. And triage runs on proxies, the loudest of which is polish. Clean diff, sensible naming, tests present, coherent commit message. That combination used to be expensive, and its expense was the entire point. It cost real hours, and someone willing to spend those hours had almost certainly understood the problem first. Polish wasn't the quality. Polish was the receipt.

LLMs made the receipt free while leaving the understanding exactly as expensive as it was in 2015. So the correlation snapped, and every intake process built on it is now running on a gauge that reads full no matter what's in the tank.

This is a signaling problem, not a code-quality problem, and confusing the two is why most of the commentary missed. Nobody at Rust is claiming machine-written patches are bad. The policy explicitly allows them. What broke is the cheap screen — the thing that let a handful of volunteers keep a queue that size from becoming a queue nobody could enter.

The rate limiter is the part worth stealing

Here's the piece I genuinely didn't expect, and it's buried in the forge doc where almost nobody will read it.

They wrote a circuit breaker. Verbatim: if more than half of PRs merged in a 6-week window are LLM-created, we disallow merging new LLM-created PRs until we go back below 50%, with a minimum cooldown of 10 days.

That is not a rule. That's a control system. Measured variable, threshold, actuator, hysteresis. Accepted PRs get an ai-assisted label so the ratio is actually measurable, which means the whole thing is instrumented before it's enforced — you can't trip a breaker you can't read. It's admission control on a saturated queue, and it's the correct response to saturation for the same reason it's correct in networking: a queue past capacity doesn't get better if you ask the senders politely. You apply backpressure at the entrance or the whole system degrades for everyone, including the traffic you wanted.

Most orgs facing this same pressure wrote a paragraph in a wiki about "using AI responsibly." Rust wrote a feedback loop with a defined trip point and a cooldown. One of those survives contact with a bad quarter.

Your pipeline has the same pileup

Generalize it, because Rust is just the instance with the honest documentation.

Any pipeline where one stage got 100x cheaper and the next stage got nothing is now broken at that boundary. Code generation collapsed in cost. Code review did not. Job applications collapsed in cost — the screening did not. Vendor RFP responses, security disclosures, support tickets, inbound sales email, first-round design docs. Every one of those has a cheap-to-produce upstream and a human-bound downstream, and every one of them was quietly load-balanced by the effort it used to take to enter.

That effort was a tax nobody voted for and everybody depended on. It's gone. Theory of constraints says throughput is set by the bottleneck and speeding up anything upstream of it just grows the pile — which is precisely what a 1,281-PR queue looks like when generation goes free.

The fair objection is that this ages badly. Model output keeps improving, the "understanding" requirement starts sounding like credentialism, and in three years a policy demanding a human vouch for every patch will read like a guild protecting itself. Maybe. But notice what Rust actually asked for. Not quality — quality is already covered by the same bar human patches face. They asked for a named person who will answer questions about the code next month when it breaks. That's accountability, and accountability doesn't get cheaper as models get better. If anything the demand for it goes up, because the volume it has to cover goes up.

Stop screening on artifacts. The artifact costs nothing to produce now and tells you nothing about who made it. Screen on the thing that's still expensive: whether someone will stand behind it in six months, under their own name, when the failure is inconvenient.

The receipt got cheap. The purchase didn't. Check which one you've been collecting.

— Dustin