We’re about to drown in code, and nobody’s figured out how to manage that yet.

I read three articles last week about PRs from very different angles. One was about PR overload in open source projects. Another about using AI agents to help engineering managers handle more code. The third about pushing ideas, not code.

All three point at the same problem.

The PR Problem

The first article was about open source maintainers struggling under the weight of pull requests. The author proposed restructuring how PRs work. Ordering PRs by size or complexity would speed up approval. The simple ones or smaller ones should take less time to review.

The Agent Approach

The second article came from the other direction. It argued that dedicated AI agents can help teams handle the growing volume of code.

This makes sense to me. I’ve watched codebases grow faster than teams can review them. The review bottleneck isn’t new. But AI generation makes it way worse. You can generate ten times the code in the same time. Your review capacity doesn’t scale with that.

The article proposed agents as the answer. Agents that handle the mechanical parts of review, flag issues and enforce standards.

The Radical Option

The third article went somewhere different. It rejected the PR model for open source, entirely. Instead of people submitting code, users submit feature requests. The repo owner lets an AI agent write the implementation. No PRs. No review of human code. Just a request, an agent, and a decision about whether to accept the output.

That sounds extreme. But I keep thinking about it. If code is cheap to generate, why not treat the idea as the valuable part that needs to be reviewed?

Open source has been a huge part of my working life. I use it every day. But I’ve never contributed back.

The cost of entry felt too high.

Code Got Cheap. Curation Didn’t.

Here’s what all three articles agree on. Code used to be expensive. Writing it took time, skill, and focus. That cost was the filter. Bad ideas didn’t get implemented because nobody had time to build them. Good ideas got through because developers were selective.

That filter is gone now.

You can generate a working implementation in minutes. Multiply that by every developer in every project and you see the problem. The bottleneck shifts from creation to curation.

This isn’t just an open source problem. Private codebases face the same pressure. Teams that generate code fast will produce more of it. The question is who decides what stays.

Agents will get good enough to enforce what good code looks like. Each team will need to write those rules down.

So how we handle this decides what future developers inherit. Trust isn’t just correctness. It’s consistency, intent, coherence. A carefully curated codebase feels different to work in than one that is full of AI-generated code without curation.

What This Means for You

If you maintain a project, you need to decide what good code looks like for you. Then start using tools that will enforce the self-imposed standard.

After that, it’s about curating what ideas should be allowed in. That decision is still not automated. And might never be.

You can feel it when you’re reading the code.