When patches get cheap, review becomes the policy
Emacs, LLVM, and the kernel are arguing in public whether AI volume justifies bans, tag removals, and pull-request quotas before maintainer capacity gives out.
The argument is no longer whether a language model may sit beside an editor. It is whether a project can keep accepting what that editor now makes almost free to produce. In the same season, Emacs developers pressed to turn a temporary prohibition into a permanent one, LLVM moved from a liberal human-in-the-loop rule toward bans on generated prose and hard caps on open pull requests, and kernel maintainers agreed to stop requiring an Assisted-by tag that had been meant to make machine help visible. The through-line is not a shared theory of authorship. It is a shared fear that review, not code, is the resource about to collapse.
Copyright used to be the respectable frame. Phil Hagelberg, writing for a group of Emacs developers and users, treats that frame as too narrow. The current Emacs policy disallows LLM contributions, and the group wants that stance kept, but not because the lawyers have not finished. "It would be a mistake to say that because something is legally allowable it must be acceptable," Hagelberg wrote, and then named the harm the legal question leaves out: "Free Software is more than just code. It's built on a foundation of trust and solidarity." The letter points at other communities that opened the door and, in this group's reading, watched trust corrode. Volume is part of that story. A coding agent can study a bug, emit a patch, and claim the symptom is gone without anyone having found the cause. If that loop is cheap, the bug tracker fills with work that looks finished and is not.
Eli Zaretskii does not accept the implied remedy, which is to refuse a class of patches so that maintainers do not have to read them. People who fear a heavier workload, he wrote, "should consider coming aboard to help with that." Rejecting proposals unreviewed, merely because that lightens the queue, is not a principle he is willing to treat as settled. The disagreement is concrete. One side says the flood is itself the harm, because solidarity depends on contributors who can explain what they sent. The other says a maintainer's job has always been to notice bugs, not to manufacture fixes, and that a ban substitutes a category judgment for review.
Richard Stallman draws a third line, and it is about who must still be able to change the code later. "Nothing should be included in Emacs itself, or in ELPA packages, that more or less needs to be maintained using an LLM. It must always be suitable for further development by humans." Asked whether accepting such code would force Emacs maintainers to use the same tools, he answered, "No -- if it would imply that, we can't accept it." He is less alarmed by machine-written explanations. If a model can say what a symbol means in human terms, "that seems ok," because a person could then leave comments other people can read without asking the model again. Critics on the thread call that a category error: the same systems are being trained to pass the questions maintainers ask, so a request for explanation becomes another relay, and review turns into a Turing test that gets harder each year. Stallman called that inference a non-sequitur. The exchange leaves the practical test unspecified. How does a reviewer know the human still understands the change, if the human can forward every follow-up?
LLVM has already lived with the liberal rule and is trying to narrow it where the pain is sharpest. Nikita Popov noted that the project's AI policy "allows essentially all uses of AI, as long as there is a 'human in the loop,' who takes responsibility for the contribution." Experience, he argued, shows that the loop fails first in the words around the code. His RFC "proposes to ban the use of AI-generated or substantially AI-assisted textual communication," including pull-request descriptions and RFC texts, and leaves code policy alone. The complaint is specific: descriptions from new contributors are often extremely verbose, padded with routine testing notes and gratuitous formatting. They "are a drain on our limited reviewer bandwidth," both to read and to massage into something mergeable. Worse, generated prose "deprive[s] the contributor of the opportunity to understand what a PR does by themselves, and express it in their own words," which was supposed to be the sanity check on human-in-the-loop development. Renato Golin added the obvious evasion: a contributor may ask a hosted reviewer to look at a pull request, but only if that person verifies and fixes the problems, rather than handing the comments back to a model.
The council has not waited for a perfect taxonomy. Alex Zinenko, writing for the project council, said the November meeting "considers there to be rough consensus in favor," aimed at decreasing the burden on maintainers, with complex cases to be adjusted later. That is a decision about intent more than a detection method. Nobody has a reliable way to prove that a paragraph was substantially assisted. The policy will be enforced by taste, complaint, and the willingness of reviewers to say no.
Alongside the prose ban sits a blunter instrument. Reid Kleckner, citing fatigue across several overlapping RFCs and the US LLVM developer meeting, proposed pull-request limits for people without write access. "It's very clear that contributors, and especially maintainers, are tired of dealing with the overload of PRs." His current number is a limit of two open pull requests at a time: enough to land a small fix, not enough to open twenty functionally correct cleanups and hunt for a rubber stamp. "Fixing bugs is useful, but the fixes are clogging our open PR dashboards and causing maintainer burnout." He wants the limit on before the next council meeting, then adjusted next year. The objection is equally concrete. A newcomer who must invent a unique bug, rather than pick one from a list, may simply stop showing up. Andrew Kaylor's harder claim is that openness is the wrong scarcity: the project needs people who stick around and become experts, not a lower barrier and more first patches. Mentorship is the polite version of the same gate, and it collides with the same shortage. Asking overloaded reviewers to sponsor strangers spends the hours the quota was meant to save. An independent contributor on the thread accepted a limit as a first filter, then asked for a path that raises the cap as someone proves they stay. That path is not written yet.
The kernel's move looks milder and may be more revealing. Sasha Levin's patch records that "The Maintainers Summit reached consensus to deprecate the Assisted-by tag" and strips the documentation that required it. Attribution had been the compromise: tools could help, the human still signed off under the Developer's Certificate of Origin, and a tag would track how large the machine's role had become. Deprecating the tag does not ban the tools. It abandons the idea that the project can, or should, keep a public ledger of them. If the tag was noise, or if people were not using it honestly, visibility was already a fiction.
The list discussion that followed did not stay on the tag. Troy Benjegerdes and others pressed non-determinism: a model is a casino, not a tool a human can audit. Linus Torvalds called that "a total red herring" and "a complete strawman." Nobody refuses human patches because people are non-deterministic; compilers have differed by version for decades; Monte Carlo methods are old. "So anybody who thinks we shouldn't use LLM as tools because of that reason is just being dishonest. It's just a disguise for 'I don't like AI.'" Joshua Peisach refused the analogy. "An LLM does not think about the words it is spitting out." Humans, he argued, know what they are putting in; a model does not. Jori Koolstra pushed the merit question further: if models someday outwrite expert kernel engineers, does a project that worships technical merit still have a reason to prefer people? That question is not the policy on the table. It is the one the tag fight keeps sliding into, because a process rule cannot settle whether the community is a means to better code or an end in itself.
What is unresolved is the enforcement layer under all three arguments. Emacs has not converted a worried letter into a permanent ban, and its maintainers disagree about whether class rejection is even legitimate. LLVM has rough consensus against generated communication and a proposed quota of two, but a stack of related RFCs still overlaps, and Golin's own image is that these choices are "like descending the gradient": locally better, not known to be the minimum. The kernel has dropped a label without deciding how much machine help a Signed-off-by can honestly cover. In each place the scarce object is the same: an afternoon of a person who can tell a real fix from a plausible one. None of the proposals yet says how that person is supposed to know, at the speed the new tools allow, which side of the line a given patch is on.