AI-Generated Pull Requests Are Flooding Open Source: The RPCS3 Problem & How to Fix It

On May 11, 2026, the RPCS3 team — maintainers of the most popular PlayStation 3 emulator — did something unusual. They politely asked the community to stop flooding their repository with AI-generated pull requests. Not angrily. Not with a ban hammer. Just a quiet, exhausted plea: please, we can't keep reviewing code that nobody actually understands.

This isn't an isolated incident. It's a canary in the coal mine for a problem every open-source maintainer is starting to feel: AI coding tools have made it trivially easy to generate code, but the flood of low-quality AI PRs is becoming an existential burden on the people who keep open source running.

The RPCS3 Incident: A Polite Warning

The RPCS3 project is a technical marvel — a software-based PlayStation 3 emulator that has taken over a decade of painstaking reverse engineering. Every line of code in that codebase represents hours of research, testing against thousands of games, and deep understanding of the Cell Broadband Engine architecture. It is not a project that benefits from someone asking Claude Code to "add PS3 game compatibility for insert title here" and submitting the result as a PR.

Yet that is exactly what has been happening. The RPCS3 team reported a noticeable uptick in PRs that looked plausible on the surface but were, upon inspection, not grounded in the actual complexity of the project. The code compiled. It might even have seemed correct. But it missed context, edge cases, and the architectural constraints that only come from deep engagement with the codebase.

The HN discussion around this story was telling. One developer described the dilemma perfectly:

"I've gotten scared of making PRs to open source projects. I used Codex 5.5 to build a feature I wanted. It works perfectly on my machine. But I don't want to submit slop, and I don't have time to properly engineer it. So the feature lives on my machine alone."

Good intentions + AI tools = low-quality PRs. The math doesn't work for maintainers.

The Bigger Trend: AI Coding Tools Have Lowered the Barrier to Contribution — and That's a Problem

Let's be clear: AI coding tools like Claude Code, Cursor, GitHub Copilot, and DeepSeek TUI are genuinely transformative. They let developers ship software faster than ever. But they also make it dangerously easy to generate code that looks right without being right.

This creates a new class of code contribution that is uniquely painful for maintainers:

• Plausible but wrong — The code compiles and passes basic tests, but contains subtle logic errors or performance regressions that only an expert can spot.
• Context-free — The AI has no understanding of the project's architecture, history, or design decisions. It produces code that would make sense in a vacuum but doesn't fit the actual codebase.
• Untestable — Generated code often doesn't include tests, or the tests it generates are tautological (testing that the function returns what it returns).
• Hard to review — AI-generated diffs tend to be large and touch many files, making them a nightmare for human reviewers.

The "vibe coding" trend that Simon Willison has written about amplifies this: when developers rely on AI to generate code without fully understanding it, they become incapable of reviewing their own contributions.

The Maintainer's Burden: Reviewing AI Slop Costs Real Time

Open-source maintainers already work under crushing pressure. The "Roads and Bridges" report (2017) famously described open source as a "crisis of maintenance" — and that was before AI. Now, every AI-generated PR adds to the review queue. Every plausible-looking diff costs 15–30 minutes of a maintainer's time to evaluate.

Consider the math:

• A popular project like RPCS3 might receive 5–10 AI-generated PRs per week
• Each requires at least 15 minutes of expert review (conservative estimate)
• That's 1.25–2.5 hours per week of pure waste
• Over a year: 65–130 hours of maintainer time, burned on code nobody asked for

And those are the PRs that get reviewed. Many more simply get closed unread, leaving contributors frustrated and maintainers feeling guilty.

This dynamic creates a negative-sum game: the contributor feels good about "participating in open source," the AI company gets free training signal from the interaction, and the maintainer absorbs all the cost.

Why AI PRs Are Different from Bad Human PRs

Open source has always had low-quality contributions from well-meaning beginners. But AI PRs are different in important ways:

1. Scale — AI generates code orders of magnitude faster than a human. The volume is unprecedented.
2. Confidence mismatch — The submitter has no skin in the game. They didn't write the code, they just prompted for it. They can't defend the design decisions in review.
3. No learning curve — A human who submits a bad PR might improve. An AI bot doesn't learn from maintainer feedback (unless the maintainer trains it, which is more unpaid labor).
4. Harder to reject — The code isn't obviously broken. It's subtly wrong. Rejecting it requires explaining why, which takes more time than a simple "this doesn't compile."

As Addy Osmani's Agent Skills project argues, we need to teach AI coding tools to follow the invisible scaffolding of professional software engineering — writing specs, planning changes, verifying results, and securing human review — before submitting PRs.

Real Solutions: How to Use AI Coding Tools Responsibly

The goal isn't to ban AI from open source. The goal is to use it responsibly. Here's how:

1. Understand Every Line Before You Submit

If you used an AI coding tool to generate a PR, take the time to read every line of the diff. If you don't understand what a function does, or why a change was made, don't submit it. Your inability to explain the code in review is a red flag.

2. Write Tests First

Before asking AI to generate code, write the tests yourself. This forces you to think about what the code should do, rather than accepting whatever the AI produces. The Agent Skills for production coding guide has more on this workflow.

3. Keep Changes Small

AI-generated diffs tend to be large. Resist this. Submit small, focused PRs that change one thing at a time. This makes review manageable and increases the chance of acceptance.

4. Include Context in Your PR Description

Explain what the PR does, why it matters, what testing you've done, and what assumptions you made. A good PR description can save a maintainer 10 minutes of investigation.

5. Be Ready to Defend Your Changes

If a maintainer asks a question about your code, you should be able to answer it without running to the AI for help. If you can't, the code doesn't belong in the project.

6. Start with Issues, Not PRs

Before writing any code, open an issue describing what you want to do. Get maintainer feedback on the approach first. Many AI-generated PRs are rejected not because the code is bad, but because the feature doesn't fit the project's direction.

7. Use AI-Assisted Code Review Tools

Tools like 9Router can help route code through automated quality checks before it reaches human reviewers. This acts as a first-pass filter for AI-generated contributions.

8. Leverage Structured Workflows for Your AI Agent

If you're using a coding agent like Claude Code or UI-TARS-desktop, configure it with structured workflows — like those from Agent Skills — that enforce spec writing, test creation, and review before any PR is generated.

The Responsibility Is on Us

The RPCS3 team's polite plea is a wake-up call. Open source runs on volunteer labor. Every AI-generated PR that requires maintainer time to review and reject is a tax on that goodwill. Eventually, people burn out and walk away.

AI companies have a role too. They should:

• Add friction to PR generation — require users to confirm they've reviewed the diff
• Include AI-generated flags in PR metadata so maintainers can triage
• Invest in tools that help maintainers evaluate AI contributions

But the biggest responsibility sits with us, the developers who use these tools. AI can write code. It can't write maintainable, reviewable, project-appropriate code — not without human judgment. If we treat PRs as cheap because they were easy to generate, we'll choke the very ecosystems we depend on.

Let's prove that we can use AI tools without abusing the communities that make this possible. The RPCS3 team asked politely. The rest of us should listen.