I see the discussion around AI-generated contributions from a somewhat different perspective. In my opinion, the real problem isn’t the use of AI itself, but rather that our development and review processes haven’t yet adapted sufficiently to what this technology makes possible.
To me, AI is first and foremost a tool. Whether a contribution was written by a human or generated with the help of an LLM says very little about its actual quality. Humans write buggy code, make questionable architectural decisions, and sometimes have only a superficial understanding of an existing codebase, too.
I’d even challenge the idea that contributors must fully understand every detail of their implementation. Of course, understanding is beneficial, but I don’t think it’s necessarily a prerequisite for making a valuable contribution. Someone can identify a problem, come up with a good idea, and use a properly guided AI to develop a useful solution without understanding every technical detail.
Perhaps we should even reconsider what a pull request is supposed to represent.
To me, a PR doesn’t necessarily have to be a finished implementation that gets merged exactly as submitted. It can also serve as a source of ideas. Even if the actual code isn’t good enough, the underlying approach might still be valuable. Why shouldn’t an AI-assisted review process be able to recognize such ideas, explore alternative implementations, and suggest an improved solution to the maintainers?
This brings me to something I feel has been largely missing from this discussion: If AI dramatically accelerates code generation, why shouldn’t we use the same technology to automate the review and improvement of that code?
I absolutely understand the concern that maintainers could become overwhelmed by a growing number of low-quality AI-generated contributions. But concluding that we therefore need to restrict AI-generated contributions seems rather short-sighted to me. Instead, we could rethink and modernize the review process itself.
An interesting real-world example is Copilot Triage, which uses AI to analyze, categorize, and prepare GitHub activity for maintainers. It’s certainly not a fully autonomous review system yet, but it demonstrates the direction these workflows could evolve in.
I can imagine open-source projects eventually providing their own review agents, equipped with project-specific guidelines, architectural decisions, tests, and quality requirements. Such agents could automatically identify poor contributions, further develop promising approaches, and present maintainers with well-prepared recommendations.
Of course, this would require projects to maintain their documentation, architectural principles, and development guidelines much more consistently, potentially even making them specifically accessible to AI agents. But I see that as a benefit in itself, including for human developers.
In the longer term, I can even imagine largely autonomous development workflows, including automated merge decisions within clearly defined boundaries. Naturally, this requires reliable tests, independent validation mechanisms, and appropriate risk assessment. A small bug fix should obviously be treated differently from a fundamental change to compiler semantics.
I increasingly see the human role at a higher level of abstraction: as the visionary who defines the direction of the project. Humans define goals, architectural principles, quality standards, and priorities. AI agents can then explore, evaluate, and implement different solutions within those boundaries. For more significant decisions, maintainers could choose between well-prepared alternatives rather than having to understand every single implementation detail themselves.
I also see enormous potential for open source here. People could make valuable contributions simply because they’ve identified a problem or have a great idea, even if they lack deep technical knowledge of the codebase.
Another aspect we shouldn’t underestimate is the speed at which AI is evolving. The progress we’ve seen this year alone has been remarkable. Things that still seem unreliable today, or require extensive human supervision, could become largely automated within just a few years. It’s difficult to predict how capable AI agents will actually be by then. That’s precisely why I find it problematic to establish long-term rules based primarily on today’s technical limitations.
A restrictive policy might reduce review overhead in the short term, but it also risks shaping our development processes around the limitations of a technology that’s evolving at an extraordinary pace. Instead, we should aim for frameworks and workflows that can evolve alongside those capabilities.
Of course, such infrastructure cannot be built overnight, and nobody should expect volunteer maintainers to automate everything immediately. Nevertheless, I believe open-source projects will ultimately need to adapt to this development.
To me, this discussion feels a bit like debating whether developers should use modern IDEs or stick to Notepad. I actually know someone who prefers the latter. ;-) And that’s perfectly fine, of course. But it would seem rather strange to use that personal preference as a reason to restrict the capabilities of modern development tools in general.
My point is this: Instead of judging AI-generated contributions by the limitations of our existing development processes, we should be thinking about how to adapt those processes to the new possibilities.
What should matter isn’t where the code came from, but the value a contribution can bring to the project, and how reliably we can identify, evaluate, and build upon that value.