No shared playbook: FOSS projects diverge on policing AI patches and prose

Five major free software communities are writing AI contribution rules at the same time, and they are not converging. The shared pressure is familiar: reviewer queues swollen with verbose, low-signal submissions, maintainers already short on time, and tools that make it cheap to generate both code and the prose that wraps it. What differs is where each project draws the line, who must disclose what, and whether automated review itself counts as policy or just tooling.

The fight is no longer abstract ethics. It is about who spends scarce human attention, and whether a contributor who leans on a model still has to do the work of understanding and explaining the change.

Prose first, code later

LLVM’s current policy is, as nikic put it when opening a fresh RFC, “fairly liberal” so long as there is a “human in the loop” who takes responsibility. Experience with that model has pushed him toward a sharper cut: ban “AI-generated or substantially AI-assisted textual communication,” including pull request descriptions and RFC texts, while leaving code assistance alone. The stated pain is concrete. Reviewers are drowning in “extremely verbose” descriptions packed with “unnecessary information” and “gratuitous formatting,” which both take longer to read and need “substantial massaging” before merge. Offloading the write-up also skips what nikic calls an important sanity check: the contributor understanding the change well enough to say it in their own words.

rengolin sharpened the fairness point. Asking a third party to write the description “offload[s] the understanding to the tool and push[es] the onus of proof onto reviewers,” which is “already provably pushing reviewers away.” jrtc27 framed the social expectation in blunter terms. Even a perfect style harness does not excuse “firing them off to another human to spend their precious time on when you have not done the same,” which is “just rude,” and writing the message yourself is how you demonstrate you engaged with the diff.

Pushback inside the same thread treats the ban as unenforceable theater. void argued that models can be steered with project-level instruction files toward brevity and local voice, and that a hard rule will mainly produce lightly edited machine drafts passed off as human. The detection problem is real: who arbitrates “AI slop” when punctuation habits get treated as tells? chandlerc’s counter-instinct is moderation doctrine rather than better prompts. Open source, in his view, needs to “delete and ban quickly to preserve the quality of the community” instead of extending endless benefit of the doubt, and to “own” that this is “less welcoming” because “we can’t welcome spam sustainably.” shafik and rnk locate the same root cause upstream of any single rule: code review bandwidth was already scarce; LLMs “caused pain exactly where we can least afford to deal with it,” and maintainers already know who submits extractive work without feeling empowered to act.

Tags, load-shedding, and choice

The kernel is moving in a different direction on paperwork while fighting the same flood. A patch from Sasha Levin implements Maintainers Summit consensus to deprecate the Assisted-by tag and strip the documentation and checkpatch machinery that required it. Attribution theater is being dismantled; responsibility still sits on the human Signed-off-by.

Parallel traffic on the lists is less about disclosure strings and more about triage. Theodore Ts’o put the maintainer choice starkly: faced with a flood of newcomer patches, the options are “load-shed, or (b) burn out,” and load-shedding is the better bad outcome. AI-assisted prioritization may mis-order work, but the alternative is exhausted humans. Lyude Paul and others keep returning to the missing-maintainers problem rather than more non-deterministic review bots. Linus Torvalds dismissed one recurring objection outright: “the whole ‘deterministic’ part is a total red herring,” a strawman for “I don’t like AI,” given that compilers, Monte Carlo tools, and humans are already imperfect in different ways.

Kernel practice also differs from project-wide bans in a structural way. Subsystem maintainers can choose whether automated review mail (Sashiko and similar) goes only to themselves, to submitters, or to the list; submitters can drop the mail. Ted has described that flexibility as a win for overloaded trees: automated notes in hours beat multi-week silence on low-priority bugs, without forcing every participant into the same pipeline.

When the queue reviews you

Debian’s conflict landed on the opposite surface: not contributor-generated prose, but the project’s own NEW processing. Johannes Schauer Marin Rodrigues announced he would stop uploading to NEW after discovering, without announcement, that uploads were being run through an LLM workflow whose output carries a disclaimer that it “was not written by a member of the DFSG team and has not been checked by one.” His options, as he framed them, were to spend free time on possibly wrong machine text or to ignore it and feed token statistics. He argued that wall-to-wall LLM processing by a central team sits badly beside a General Resolution that said Debian “neither endorses nor prohibits” generative AI and that large-scale automated actions still need established expectations and communication.

Others rejected the call-out. Marc Haber preferred “a wall of polite ai generated text 30 minutes after my upload” to a short rejection “after four months.” Colin Watson noted the DFSG team’s turnaround was already improving before the obvious LLM layer. Chris Hofstaedtler insisted the issue is process: tools that change what uploaders receive should be discussed, not discovered. Comparisons to the kernel’s opt-in review bots only underlined the governance gap. Debian had a GR; the kernel did not. Silence, several developers argued, is a poor substitute for either.

From blanket ban to buckets

QEMU is rewriting a hard prohibition that “no longer reflects reality.” Paolo Bonzini’s non-RFC policy series starts from the fact that useful AI-assisted series already arrived in good faith before agent instruction files existed. The goal is not speed for its own sake but avoiding what Warner Losh called “free as in puppy” contributions that dump long-term technical debt on maintainers.

The draft splits use into tiers: background completion and review with no disclosure; small fixes (roughly under ten lines) allowed with disclosure; partial generation inside larger human-driven work generally allowed; and large, heavily model-written functional work only with pre-arrangement, higher standards, and maintainer consent. Provenance risk is treated as layered mitigation rather than a single pure certificate. Cover letters, commit messages, and replies to review are reserved for humans. Agent-oriented instructions are being tuned so models refuse out-of-policy requests and remind operators about pre-approval. Daniel Henrique Barboza separately asked for mailing-list “rules of engagement” when replies may themselves be translated or drafted by models, so reviewers know whether they are parsing a person or a pipeline and can drop idioms that bots mishandle.

One problem, four constitutions

Thread the four stories together and the incompatibility is the story. LLVM is poised to outlaw AI prose while still blessing AI code under human responsibility. The kernel is deleting an AI attribution tag and letting maintainers opt into automated review as load management. Debian is arguing over whether unannounced LLM queue review by a core team violates the spirit of a project-wide “neither endorses nor prohibits” settlement. QEMU is replacing a ban with attestation, size thresholds, and mandatory human text at the discussion layer.

Underneath sit the same unresolved questions. Is the scarce resource explanation quality, patch correctness, or reviewer trust? Can disclosure scale when lightly edited machine text is easy and detection is political? Does “human in the loop” mean authorship of every paragraph, legal responsibility under a DCO-style sign-off, or pre-negotiation with maintainers before a large dump lands? Is automated review a personal productivity aid, a subsystem preference, or a project endorsement that needs a vote and an announcement?

No cross-project norm is in sight. Each community is optimizing for its own burnout pattern and its own history with spam, copyright anxiety, and welcome. The tools will keep getting cheaper. The policies are diverging faster than the submission pressure is easing.