For the past two years, the conversation about AI in software development has been dominated by a single question:
Are agents already coding well enough?
While we debated benchmarks, context windows, and new models, another problem began to grow almost silently.
Open source projects started receiving an avalanche of AI-generated pull requests.
Many compile.
Many even work.
But that doesn’t mean they’re good contributions.
Last week, the Godot Engine project made a decision that will probably mark a before and after: it will no longer accept AI-generated contributions, including code and, except in specific cases like translations, also AI-written communications.
It wasn’t an ideological decision.
It was an operational decision.
And that makes it much more interesting.
The problem isn’t that the code is bad
Godot’s maintainers were quite clear about this.
The problem isn’t that all AI-generated code is incorrect.
The problem is the cost of reviewing it.
A pull request can:
-
compile,
-
pass the tests,
-
fix the bug,
and still be a bad contribution.
Maybe it breaks internal conventions.
Maybe it duplicates existing functionality.
Maybe it introduces unnecessary complexity.
Maybe it solves the symptom, not the cause.
All of that requires review time.
And that time is still human.
Maintainers are absorbing the cost
This is probably the most important point in the entire discussion.
Coding agents enormously increase developer productivity.
But they can also increase the volume of work for maintainers.
Let’s imagine two scenarios.
Before:
A developer sent:
- 2 PRs per week.
Now:
With Claude Code or Cursor they can produce:
- 10 PRs per week.
Individual productivity improves.
But someone has to review five times more code.
That someone is usually a volunteer.
The new bottleneck
For years we thought that writing code was the scarce resource.
Today it’s starting to seem like the scarce resource is something else.
The attention of reviewers.
Because reviewing code is still deeply human work.
Understanding intent.
Evaluating architecture.
Thinking about future maintenance.
Relating a change to decisions made three years ago.
Agents help a lot.
But they still don’t completely replace that process.
Is this a ban on AI?
Not exactly.
Godot isn’t saying:
“Never use AI.”
It’s saying something quite different.
“Don’t turn our review process into the place where AI learns.”
It’s an important distinction.
Many developers already use agents to:
-
explore code,
-
generate ideas,
-
write tests,
-
create documentation,
-
automate repetitive tasks.
All of that can continue happening.
What Godot is questioning is the mass submission of poorly reviewed contributions.
A problem other projects are also starting to see
Godot is probably the first to formalize such an explicit policy.
But it’s hardly the only project facing this problem.
Any large repository today receives:
-
more contributions,
-
more forks,
-
more issues,
-
more PRs.
If a significant portion of that volume comes from agents, the load on maintainers inevitably grows.
And that forces a rethinking of the governance model.
The paradox of coding agents
Agents make it easier to contribute.
That’s extraordinary.
But they also make submitting a pull request almost free.
When the cost of producing something drops drastically…
…the cost of filtering it usually increases.
The internet has experienced this phenomenon several times before.
With email came spam.
With social media came content moderation.
With AI comes another problem:
contribution moderation.
What could other projects do?
It’s unlikely that everyone will copy Godot’s policy exactly.
But it’s easy to imagine intermediate measures.
For example:
-
require the author to declare AI use;
-
increase requirements before accepting a PR;
-
request evidence of manual testing;
-
tighten reviews for agent-generated contributions;
-
implement automatic checks before a maintainer sees the change.
In other words, shift more work toward the author’s side.
Not the reviewer’s.
What does this mean for developers?
It doesn’t mean stop using Claude Code.
Or Cursor.
Or Codex.
It means using them differently.
An agent should help you produce a better contribution.
Not produce more contributions.
There’s an enormous difference between:
“AI wrote this code.”
and
“I used AI to build a solution that I completely understand.”
Final responsibility still rests with the developer.
And that probably won’t change.
The real turning point
I think the important news isn’t that Godot banned AI-generated code.
The important news is that, for the first time, a top-tier open source project is adapting its governance rules as a direct consequence of massive coding agent adoption.
That changes the conversation.
For two years we discussed how to increase individual productivity.
Now we’re starting to discuss how to preserve collective sustainability.
Because the success of agents brings a new challenge.
It’s not generating more code.
It’s maintaining the quality of code that ends up being part of projects used by millions of developers.
And this probably won’t be the last time we see a major open source project redefine its rules to coexist with AI.
It may just be the first.
Source: Official Godot Engine project policy on AI-generated contributions.