The Godot Foundation, which maintains the open-source game engine of the same name, announced this week that it will no longer accept AI-authored code contributions, agent-submitted pull requests, or AI-generated text in contributor communications. PC Gamer wrote it up off the Foundation’s own blog post. The stated reasoning, in the Foundation’s own words: AI cannot take responsibility, and we can’t trust heavy users of AI to understand their code enough to fix it. Contributors can still use AI for what the Foundation calls menial things, if they disclose the use, but a human has to own the submission end to end. Human-to-human communication in the project is expected to remain human-to-human, with a narrow exception for machine translation.
The editorial center is the mechanism the Foundation identified but did not name in its post. The Foundation frames the decision as a mentorship-pipeline problem — PR review is how you find future maintainers, and if the feedback goes into a machine instead of a person, the pipeline collapses. That framing is the polite version. The impolite version is that the review loop has stopped closing. In 1998 if a contributor sent a bad patch to the Linux kernel, Linus would tell them why it was bad, and either they learned or they left. Either way the loop closed. What has changed is not the quality of the submissions or the volume of them. What has changed is that the submitter now takes the feedback, feeds it back into the model, generates a new PR, and the maintainer is talking to nobody. The reviewer’s time is being converted into training data for a process that produces no future maintainer of the project.
The pattern is older than the mechanism. In the eighties and early nineties, contribution was mailing lists and patch files, and the filter was the tooling — you needed to know how to use diff and patch, and if you couldn’t operate the tools you couldn’t contribute. SourceForge in 1999 lowered the barrier. GitHub in 2008 lowered it again. Each collapse of the previous filter produced a new one — contribution guidelines, code of conduct, PR templates, required tests, CODEOWNERS files. Each was a response to the previous barrier collapsing. The current collapse is the largest yet, because a contributor no longer needs to know how to write code — they only need to know how to ask for it. Godot is early to draw the next filter. The Foundation is not the first — the PS3 emulator RPCS3 and the Playdate handheld’s community have already made comparable decisions in the past year — and it will not be alone. The submission is not the contribution. The maintenance is. Godot is the first project to say it out loud at scale.
Topics
- The Godot Foundation’s new contribution policy: no AI-authored code, no agent-submitted PRs, no AI-generated text in human-to-human communication (with machine-translation exception)
- What counts as “menial” under the disclosure carve-out, and why the enforcement mechanism collapses within six months as the tools improve and the tells become harder to detect
- The mentorship pipeline argument the Foundation made explicit — PR review as the apprenticeship mechanism that produces future maintainers
- The loop that used to close: 1998 Linus telling you why your patch was bad, and either you learned or you left; the loop that doesn’t close now
- The four-decade barrier-collapse arc: mailing lists and patch files (eighties-nineties), SourceForge (1999), GitHub (2008), and now the collapse where a contributor doesn’t need to know how to write code
- Contribution versus submission — participation means being around when it breaks; submission means clicking a button
- Why the AI-does-the-review-too counterproposal doesn’t scale — the human still has to own the review, so the AI at best adds a step
- A donation of technical debt: the maintainer inherits the code the contributor cannot fix
- The observable pattern already forming — RPCS3, the Playdate community, Godot, and the projects that will follow
- Institutional-transmission as the load-bearing habit: the unglamorous work (Bugzilla triage, mailing list moderation, PR review) that keeps open-source projects running past year twenty
Goat List Reasons referenced
- #40 — You deliver applications to goats. Goats do not deliver applications to you.
- #39 — Nobody ever needed to draft up a goat-milking requirements document.
- #89 — Goats don’t ever ask stupid questions.
Source Article
Open source game engine Godot will no longer accept AI-authored code contributions: ‘We can’t trust heavy users of AI to understand their code enough to fix it’ — PC Gamer. Reporting on the Godot Foundation’s blog-post announcement of the new contribution policy, the specific mentorship-pipeline argument the Foundation made in its own post about PR review as the mechanism that produces future maintainers, the “AI cannot take responsibility” framing, the “increasingly draining and demoralizing” description of the current inbound-contribution volume, the “menial things” with disclosure carve-out for individual contributor practice, and the observation that other projects (RPCS3, Playdate, others) have already made comparable moves. Additional Register coverage under the headline Godot says bye bye AI, bans vibe-coded contributions covers the same ground with slightly different framing.
Panel
- The Legacy Sysadmin
- The DBA
- The Startup Founder
- The Goat Farmer’s Counsel
Transcript
Full episode transcript
HOST: Welcome back to Stake and Rope, from Goat Security. Today: the Godot Foundation, which maintains the open-source game engine of the same name, announced it will no longer accept AI-authored code, agent-submitted pull requests, or AI-generated text in contributor communications. PC Gamer wrote it up this week off the Foundation’s own blog post. The reasoning, in their words: “AI cannot take responsibility, and we can’t trust heavy users of AI to understand their code enough to fix it.” Contributors can still use AI for what they’re calling menial things, if they disclose it, but a human has to own the submission end to end.
HOST: With me today: the Legacy Sysadmin, who has watched drive-by contributions drown open-source projects since before there was a word for it. The Founder, who I assume has a take on this that involves the word “democratize.” The DBA, who I imagine has some feelings about people submitting code they can’t fix. And the Goat Farmer, as always.
HOST: Legacy, let me start with you. What does this remind you of?
LEGACY SYSADMIN: [sighs] It doesn’t remind me of anything. It is the thing. This is Bugzilla triage in 2004. This is the sendmail mailing list in 1997. This is every open-source project that ever got popular enough to attract people who wanted the resume line without doing the work. The medium changes. The dynamic doesn’t. Somebody’s free time is being converted into somebody else’s LinkedIn post, and eventually the somebody with the free time stops showing up.
HOST: The Foundation frames it as a mentorship pipeline problem. PR review is how you find future maintainers. If the feedback goes into a machine instead of a person, the pipeline collapses.
LEGACY SYSADMIN: That’s the polite version. The impolite version is that every open-source project since the beginning has had maintainer burnout and it always ends the same way. Somebody quits, somebody forks, or the project rots. The Foundation is trying to get ahead of it by drawing a line. Good for them. It won’t be enough, but good for them.
FOUNDER: Okay, hold on. I want to push back on the framing here.
FOUNDER: Because look — the Godot Foundation is a small team, right? They’re resource-constrained. And what they’re calling low-effort slop is actually — think about it — it’s a massive increase in inbound. That’s a distribution problem, not a code problem. They have more people trying to contribute than ever before. That’s the story.
FOUNDER: The answer isn’t to shut the door. The answer is to use AI on the review side too. You’ve got AI submitting PRs, you use AI to triage them, filter the signal, surface the real ones to human maintainers. This is a scaling opportunity. Godot could be the first open-source project to actually solve maintainer burnout with the same tools that caused it. That’s the pitch.
THE DBA: [scoffs] no. The tools that caused it aren’t going to solve it.
FOUNDER: Why not?
THE DBA: Because the problem isn’t volume. The problem is accountability. Who owns the code after it merges?
FOUNDER: The project owns it.
THE DBA: No. The project inherits it. Somebody has to fix it when it breaks. Who’s that person?
FOUNDER: The maintainers, presumably.
THE DBA: So the contributor submits a PR, walks away, and the maintainer is on the hook forever. That’s not a contribution. That’s a donation of technical debt. And now you’re saying the maintainer should also be reviewing it with a machine that doesn’t know what the codebase does. Who owns the review?
FOUNDER: The human, obviously, the AI is just a filter —
THE DBA: Then the human is doing the review. You haven’t scaled anything. You’ve just added a step.
HOST: Founder, I want to sit on this for a second. You said this is a distribution problem, not a code problem. The Foundation’s own words were, quote, “we can’t trust heavy users of AI to understand their code enough to fix it.” That’s not a distribution complaint. That’s a competence complaint.
FOUNDER: [chuckles] I mean, it’s both, though. Right?
HOST: It’s not both. They wrote a specific sentence about a specific problem. Contributors don’t understand what they’re submitting.
FOUNDER: Okay, fair. But the reframe is — that’s an onboarding problem. That’s fixable. You give people better tools, better docs, better mentorship pathways. You don’t turn away contribution, you improve the pipeline.
LEGACY SYSADMIN: The pipeline is the maintainers. That’s what he’s not hearing.
FOUNDER: What do you mean?
LEGACY SYSADMIN: The pipeline for future maintainers is the current maintainers reviewing PRs from people who want to become maintainers. It’s an apprenticeship. That’s what the Foundation said in their post. If you take the mentorship out — if the feedback loop is human-to-machine instead of human-to-human — the project doesn’t produce its next generation. You can’t automate that. You can only kill it.
GOAT FARMER: [sighs] Yep.
GOAT FARMER:
Reason number 40. You deliver applications to goats. Goats do not deliver applications to you.
HOST: Let’s talk about the specific line the Foundation drew. AI is fine for menial things if disclosed. Not fine for actual code contributions or human-to-human communication. DBA, does that line hold?
THE DBA: The disclosure part is where it collapses. Who’s checking?
HOST: The maintainers, on review.
THE DBA: Right, so the same people who are already drowning are now supposed to also detect whether the submission was AI-written. How do they do that?
HOST: Presumably by the tells. Overly verbose, generic patterns, inconsistent with the codebase style.
THE DBA: So it’s a vibes check. That’s not a policy. That’s a preference. And it won’t hold for six months, because the tools get better and the tells get harder. In a year the maintainers won’t be able to tell.
LEGACY SYSADMIN: The tells were never the point. The point is you’re telling people up front: don’t do this. Most people who read a contribution policy are the ones who were going to be reasonable anyway. The policy is a filter, not a gate.
THE DBA: Sure. And the ones who ignore it are the same ones who’d ignore any other policy. So what’s the enforcement?
LEGACY SYSADMIN: There isn’t one. There never is. Open-source runs on people acting in good faith.
THE DBA: And good faith is what’s failing here.
HOST: Founder, jump in.
FOUNDER: Look, I think you guys are being incredibly cynical about what is actually a really exciting moment for open source. AI is bringing people into contribution who could never have contributed before. Non-native English speakers. People without CS degrees. People with disabilities. This is democratization.
THE DBA: Democratization of what, though.
FOUNDER: Of contribution. Of participation in open source.
THE DBA: They’re not participating. They’re submitting. Those are different things.
FOUNDER: How are they different?
THE DBA: Participation means you’re around when it breaks. Submission means you clicked a button.
HOST: Let me pull back for a second. I want to sit on the historical pattern here, because I don’t think we’ve done it justice. Legacy, walk us through the arc. Every generation of open-source contribution has had this fight, in some form.
LEGACY SYSADMIN: Sure. In the eighties and early nineties, contribution was mailing lists and patch files. You had to know how to use diff and patch. That was the filter. The filter wasn’t intentional, it was just the tooling. If you couldn’t operate the tools, you couldn’t contribute. And that was fine, because everybody who could operate the tools was also, roughly, someone who could hold a codebase in their head.
LEGACY SYSADMIN: Then SourceForge in ‘99, then GitHub in ‘08. Each one lowered the barrier. And each time, the maintainers of the biggest projects had to invent new ways to filter, because the old filter — the tooling itself — was gone. Contribution guidelines, code of conduct, PR templates, required tests, CODEOWNERS files. Every one of those was a response to the previous barrier collapsing.
LEGACY SYSADMIN: What’s happening now is the biggest barrier collapse yet. You don’t need to know how to write code to submit code. You just need to know how to ask for it. And the maintainers are inventing the next filter, which is: prove you’re human and prove you understand what you sent. Godot is early. Everyone else will follow.
HOST: Right, and back to the article — the Foundation’s specific complaint is that the feedback loop is broken. They said, quote, “if your feedback on PRs is just being absorbed by a machine and not going towards mentoring a potential future maintainer, it becomes much harder to justify spending your free time on PR review.” That’s the load-bearing sentence in the whole announcement.
LEGACY SYSADMIN: That’s exactly right. It’s not that the code is bad. It’s that the reviewer’s time is being spent on something that produces no long-term value to the project. In 1998 if you sent a bad patch to the Linux kernel, Linus would tell you why it was bad, and either you’d learn or you’d leave. Either way the loop closed. Now the loop doesn’t close. The submitter takes the feedback, feeds it back into the model, generates a new PR, and the maintainer is talking to nobody.
THE DBA: [exhales] yea. That’s the whole thing. That’s the actual problem.
HOST: DBA, this maps to something you’ve said before about accountability being binary. Is that where you are on this?
THE DBA: Yeah. There’s no partial ownership of a piece of code. Either you can fix it when it breaks at three in the morning, or you can’t. If you can, you wrote it. If you can’t, somebody else wrote it and put your name on it. The Godot Foundation is drawing that line correctly. It’s the only line that means anything.
FOUNDER: But you’re describing a really elitist gate, right? You’re saying only people who can debug production code should contribute.
THE DBA: I’m saying only people who can fix what they submit should submit it. That’s not elitist. That’s basic. If you can’t fix it, you’re asking somebody else to. And they didn’t sign up for that.
FOUNDER: So how do new contributors ever get in?
THE DBA: The same way they always have. Start small. Fix a bug you actually understand. Ask questions. Read the code. It takes time. There’s no shortcut.
FOUNDER: But AI is the shortcut. That’s the whole point.
THE DBA: Right. And the Godot Foundation is telling you the shortcut doesn’t work. That’s what the announcement says.
GOAT FARMER: Had that one in ninety-nine.
GOAT FARMER:
Reason number 39. Nobody ever needed to draft up a goat-milking requirements document.
HOST: Let’s land the plane. Closing thoughts. Goat Farmer, you first.
GOAT FARMER:
Reason number 89. Goats don’t ever ask stupid questions.
GOAT FARMER: They don’t submit them either.
HOST: Founder.
FOUNDER: I still think there’s an opportunity here that the panel is missing. Godot is drawing a hard line, and I respect that, but the projects that figure out how to work with AI contribution instead of against it are going to have a huge advantage. The next generation of open-source maintainers is going to be AI-native. They’re going to be running review agents, running test agents, running docs agents. The projects that build that infrastructure now are going to be the ones that scale. Godot is choosing the artisanal path. That’s a valid choice. It’s not the only choice. I’ll write this up tonight.
HOST: Legacy.
LEGACY SYSADMIN: Every open-source project that’s still running after twenty years is running because a small number of people did unglamorous work for a long time. Bugzilla triage, mailing list moderation, PR review. Nobody put those on a resume. Nobody wrote a blog post about them. The people who did that work did it because they cared about the project, and because somebody older had done it for them when they started. What the Godot Foundation is protecting isn’t code quality. It’s the transmission of that habit. If you lose the habit, you lose the project, and you lose it slowly enough that nobody notices until it’s gone.
HOST: DBA.
THE DBA: The Foundation said, “AI cannot take responsibility.” That’s the sentence. Everything else in the announcement is downstream of that. A contributor who can’t fix their own submission isn’t a contributor. They’re a liability the maintainer inherits. Godot did the math and figured out the liability was growing faster than the contribution. That math is only going one direction. Every project is going to have to do it eventually. Godot went first. They won’t go alone.
HOST: [pause] The submission is not the contribution. The maintenance is. Godot is the first project to say it out loud. We’ll see you next time.