The Godot Foundation is changing how developers can contribute to its open-source game engine after a growing backlog of pull requests began putting serious pressure on the people responsible for reviewing them.
Godot has become one of the most widely discussed open-source game engines in recent years, attracting developers of all experience levels. That growth is positive for the project, but it has also created a difficult operational problem: far more code is being submitted than the core team can reasonably review.
The rise of generative AI has made that imbalance even sharper. Writing or modifying code is now easier and faster for many contributors, but the number of experienced maintainers available to inspect, test, discuss and approve that code has not increased at the same pace.
For Godot, the challenge is no longer simply how to welcome more contributors. It is how to protect the project from becoming overloaded by submissions that lack context, ownership or long-term maintainability.
Why Pull Request Volume Has Become a Problem
Open-source projects depend heavily on experienced volunteers and core maintainers. These people do far more than approve code. They test changes, spot hidden compatibility issues, check whether a feature fits the project's long-term direction, and often help newer contributors understand why a certain approach may not be suitable.
That work takes time.
When large numbers of pull requests arrive at once, especially from contributors unfamiliar with the codebase, the review queue can quickly become unmanageable. A pull request may look small on the surface but still require significant investigation before it can be merged safely.
The issue becomes even more difficult when generated code enters the workflow. AI tools can produce sizeable changes in seconds, but maintainers still need to inspect every line carefully. They cannot assume that generated code is correct, secure, efficient or compatible with Godot's existing architecture.
In other words, AI can increase code output much faster than it increases review capacity.
The Hidden Cost of Reviewing AI-Generated Code
For many open-source maintainers, reviewing contributions is not only about keeping the software stable. It is also part of mentoring future contributors.
A junior developer who receives feedback from an experienced maintainer can learn how the project works, improve their technical skills and eventually become a trusted contributor themselves. That long-term learning process is one of the reasons open-source communities can remain healthy over many years.
However, that value is reduced when the submitted code is heavily generated by an AI system.
A language model does not retain feedback in the same way a human contributor does. It cannot take responsibility for a future bug fix, explain architectural decisions with full confidence or build long-term familiarity with the project. The maintainers may spend hours reviewing and correcting a submission, only to find that the contributor cannot fully explain the code or maintain it later.
That creates frustration for the people doing the review work. It also risks turning an educational and collaborative process into a repetitive filtering exercise.
New Contributors Will Need to Build Trust First
Under Godot's updated approach, newer contributors will face clearer limits on the kinds of changes they can submit.
A developer with three or fewer merged pull requests will be considered a new contributor. Rather than immediately working on major features, these contributors will be encouraged to focus on areas such as bug fixes and documentation improvements.
This is not meant to shut out new developers. Instead, it creates a more gradual path into the project.
Documentation work and smaller bug fixes can help contributors understand Godot's coding style, development workflow, architecture and review expectations. It also gives maintainers a chance to see whether a contributor communicates well, responds to feedback and understands the changes they are proposing.
More complex architectural work will require approval from the core maintenance team before a contributor begins. This helps prevent major changes from entering the review queue without enough planning, context or technical justification.
A Firm Position on Autonomous Coding Agents
Godot is also drawing a stronger line around autonomous AI agents and prompt-driven development.
According to the new governance direction, contributors who use autonomous systems to generate and submit work without proper human ownership could face a permanent ban from the repository. The message is clear: contributors must understand the code they submit and be prepared to maintain it.
Godot is not banning every form of AI assistance. Limited tools for routine development tasks may still be acceptable. Examples include code completion, regular expression generation or bulk text replacement.
However, contributors using such tools are expected to disclose that usage in the pull request discussion. Transparency matters because maintainers need to understand how the change was produced and whether the contributor can confidently explain and support it.
The foundation's position is that automation can assist developers, but it cannot replace responsibility.
Human Communication Still Matters
The policy is not limited to source code. Godot also plans to restrict AI-generated text in issue discussions, technical proposals and pull request conversations.
For maintainers, reading and responding to large amounts of machine-generated discussion can be just as draining as reviewing generated code. A technical conversation is supposed to involve people who understand the problem, can answer questions and are willing to take responsibility for the proposal.
Machine-generated replies can make discussions longer without making them more useful. They may sound polished, but that does not guarantee that the contributor understands the design, the trade-offs or the potential impact on other parts of the engine.
Translation tools will still be allowed when they help a human contributor communicate in English. The key distinction is that the original ideas, explanations and decisions must come from a real person.
Protecting Open Source Without Closing the Door
Godot's move reflects a broader problem facing many open-source communities. AI tools are making it easier than ever to produce code, but they are not creating more experienced reviewers, maintainers or project leaders.
The foundation is trying to strike a balance. It wants to reduce low-effort automated submissions while still leaving room for genuine new contributors to learn, participate and eventually take on larger responsibilities.
The updated rules may feel strict, but they are designed to preserve something essential: a sustainable community where human contributors remain accountable for their work.
For an open-source project as large and widely used as Godot, protecting maintainer time is not just an administrative concern. It is necessary for the long-term health, stability and future development of the engine itself.
Comments