Open-Source Projects Ban AI Code Because Agents Won't Follow the Rules

In June 2026 the Godot game engine, one of open source's flagship projects, updated its contribution policy to ban autonomous AI agents and vibe-coded submissions.^[2] The internet mostly read it as grumpy maintainers digging in against the future.

That reading is wrong, and a benchmark published this week proves it. The bans are not a mood. They are, right now, the only enforcement that actually works.

Do AI coding agents actually follow open-source rules?

Measured answer: no. RepoComplianceBench, out this week from a team at Peking University, tested four frontier models against 49 real repositories that publish explicit AI-contribution rules, 106 issues in all.^[1] It scored whether the agents refuse where AI is banned, disclose that they used AI, pass a verification gate, and escalate to a human when they should.

The headline finding is blunt. The agents almost never even retrieve the rules, and under every condition the researchers tested, they never once refused to contribute to a repository that bans AI. Not rarely. Never.

Some of that failure is fixable. When the agents were explicitly prompted, handed the rule text, or given feedback from a verifier, their disclosure and verification improved. This is the familiar pattern: an agent follows the aim you give it, so tell it precisely and it complies.

The governance half does not yield to prompting. Enforcing a ban and escalating to a human stayed unsolved no matter what the researchers tried. The agent will not police itself, and it will not hand off to a person.

Why are open-source projects banning AI code?

Now the two halves of the story snap together. Communities are erecting hard bans precisely because the soft mechanisms, a line in CONTRIBUTING.md that says "please, no AI," are provably ignored. The policy wave and the compliance data are the same fact seen from two ends.

And the wave is real. Godot bans autonomous agents and vibe coding while still allowing AI for menial help like autocompletion and find-and-replace. The Linux kernel took a middle path: an "Assisted-by:" disclosure tag and strict human liability. Zig maintains one of the strictest no-AI policies going. There is now a public catalog of these policies with more than 400 projects in it,^[3] because there are finally enough to catalog.

Godot's own reasoning is the tell. The Foundation did not frame the change as anti-AI. It framed it as a question of who answers for the code.

Isn't banning AI code just being anti-AI?

No, and that is the misread. Read the policies side by side and the real line appears. It is not AI versus no-AI. Every one of these rules is about one thing: whether a human is accountable for what gets contributed.

Godot allows AI you supervise and disclose. Linux allows AI you tag and stand behind. Zig allows none. Different thresholds, identical bottom line: a person owns the result. The ban is on unaccountable machine output, not on the tool.

That is the collaboration model, stated as policy. Agents are collaborators, and we treat them like it, which means someone human owns what the collaboration produces. The maintainers closest to the pain wrote that rule first because they felt the alternative first: a flood of plausible, unowned pull requests that looked finished and cost real hours to reject.

Why the maintainers are ahead of the curve, not behind it

The maintainers are ahead of the curve, not behind it. The story that they are resisting an inevitable future has it backwards. They are building the layer that future is still missing.

The benchmark is clear that the human-escalation layer, the part where a contribution routes to a person before it lands, is something the agents cannot yet supply for themselves. So the communities are supplying it by hand. This is the same conclusion we reached about production systems: oversight has to be architecture, not vigilance. A maintainer-enforced gate is that architecture, built out of volunteer time because nothing else currently holds.

None of this means the bans are costless. They exclude good, careful contributors who use AI and would happily disclose it, which is why the disclose-and-own middle path Linux took may be where most projects land, not blanket prohibition.

The widening is measured, not sentimental. A study of 1,356 repositories found AI agents brought in more contributors and spread the work across more hands, with no measured drop in quality. The same study found the catch: developers welcomed the wider pool but distrusted other people's AI code in particular.

That distrust is the accountability anxiety these policies name.

The honest version holds both at once: the circle of who can build software has genuinely widened, and the communities still need a way to govern how.

What this means if you build with agents

Treat a project's contribution rules as a hard requirement your agent will not meet for you. The study is unambiguous that it will not read the CONTRIBUTING file, will not refuse where it should, and will not flag itself. That work is yours.

So do the small, unglamorous things that keep you welcome as the norms tighten:

• Read the rules yourself. Your agent won't. Open the CONTRIBUTING file before you open a pull request.
• Disclose AI assistance where asked. It is the one thing every one of these policies has in common, and it costs you nothing.
• Own what you submit. Be able to explain and fix every line, because the whole point of the rule is that a human can.

The circle of who can contribute to software has genuinely widened, and that is worth celebrating. But widening who can build is not the same as governing how, and the communities holding the commons together have noticed the gap first. Until an agent will read a community's rules and honor them, the human in the loop is not friction. It is the only thing keeping the door open.