Open source has long been regarded as a model of collaborative software development, but recent trends suggest that artificial intelligence is fundamentally reshaping its dynamics. The rise of large language models and agentic coding tools is generating a flood of low-quality pull requests, often described as "slop PRs," which are overwhelming maintainers and threatening the sustainability of many projects. This phenomenon is prompting a reevaluation of what open source means in an era where AI can produce plausible code without human understanding.
The asymmetry of review economics
The core problem lies in the brutal asymmetry of review economics. A developer can spend 60 seconds prompting an AI agent to fix typos or optimize loops across multiple files, but a maintainer may need an hour to carefully review those changes for correctness, edge cases, and alignment with the project's long-term vision. When multiplied by hundreds of contributors using personal AI assistants, the result is not a better project but a maintainer who walks away. Mitchell Hashimoto, founder of HashiCorp, has even considered closing external pull requests entirely because he is drowning in AI-generated submissions. This is not a matter of losing faith in open source but of simple math: the cost of reviewing AI-generated contributions far exceeds the value they provide.
Flask creator Armin Ronacher describes this as "agent psychosis," where developers become addicted to the dopamine hit of agentic coding and send agents to run wild through projects. The output is often "vibe-slop" code that feels right statistically but lacks the context, trade-offs, and historical understanding that human maintainers bring. The barrier to producing a plausible patch has collapsed, but the barrier to responsibly merging it has not. This asymmetry is not merely an annoyance but a structural shift that threatens the viability of open source as we know it.
The death of small libraries
Beyond pull requests, AI is also rendering small utility libraries obsolete. Nolan Lawson, author of blob-util, a JavaScript library with millions of downloads, notes that developers no longer need to install such libraries when they can ask an AI to generate the same utility function in milliseconds. The era of the low-value dependency is over because AI can reproduce that functionality on demand. This is a double-edged sword: while it reduces dependency churn, it also eliminates the educational value of reading and understanding someone else's code. Lawson argues that these libraries were teaching tools where developers learned problem-solving by studying the work of others. Replacing them with ephemeral AI-generated snippets trades understanding for instant answers, undermining the teaching mentality that is the heart of open source.
This trend is compounded by Ronacher's earlier suggestion that developers should simply "build it ourselves" rather than pull in dependencies. With AI making it easier to generate code internally, the logical response is to retreat from depending on external libraries. This creates a weird irony: AI may reduce demand for small libraries while simultaneously increasing the volume of low-quality contributions into the libraries that remain. The very tools that were supposed to democratize contribution are instead making the contribution channel hostile to maintainers.
Bifurcation of open source
These pressures are leading to a bifurcation of the open source ecosystem. On one side are massive, enterprise-backed projects like Linux or Kubernetes, which have the resources to build their own AI-filtering tools and ignore the noise. These are the cathedrals, increasingly guarded by sophisticated gates. On the other side are provincial open source projects run by individuals or small core teams who simply stop accepting external contributions. GitHub, the host of the world's largest code forge, is already exploring tighter pull request controls and UI-level deletion options because maintainers are overwhelmed by AI-generated submissions. If the platform itself is considering a kill switch for pull requests, we are no longer talking about a niche annoyance but a structural shift.
The OCaml community recently faced a vivid example when maintainers rejected an AI-generated pull request containing more than 13,000 lines of code. They cited copyright concerns, lack of review resources, and long-term maintenance burden. One maintainer warned that such low-effort submissions risk bringing the entire pull request system to a halt. This is not an isolated incident; it is a pattern that is rapidly eroding the trust and efficiency that made open source possible.
The rise of curated communities
In response, many projects are moving toward radical curation. The future of open source may belong not to the many but to the few who are willing to invest human effort, context, and relationship. The era of the drive-by contributor is being replaced by an era of the verified human. Projects that survive will be those that are hardest to contribute to, demanding a high level of human effort and deliberate, deeply personal development. The bazaar was a fun idea while it lasted, but it couldn't survive the arrival of the robots. Open source is not dying, but the "open" part is being redefined. We are returning to a world where the only people who matter are the ones who actually write the code, not the ones who prompt a machine to do it for them.
This shift carries implications beyond code quality. It affects the social fabric of software development, where mentorship, learning, and community building have traditionally occurred. As maintainers retreat from external contributions, the opportunities for newcomers to learn from experienced developers diminish. The teaching mentality that Lawson believes is the heart of open source is replaced by a focus on self-reliance and internal tooling. The result may be a more efficient but less inclusive ecosystem.
GitHub's response to this challenge will be crucial. The platform is exploring UI-level changes to give maintainers more control, such as the ability to delete AI-generated pull requests more easily. However, such measures treat the symptoms rather than the cause. The root issue is that the barrier to contribution has been lowered to the point where the cost of sorting valuable from worthless has become unsustainable. Without fundamental changes in how contributions are reviewed and valued, the open source model may become a victim of its own success, crushed by the very tools designed to make it more accessible.
In sum, we don't need more code; we need more care. Care for the humans who shepherd the communities and create code that will endure beyond a simple prompt. The future of open source is smaller, quieter, and much more exclusive. That might be the only way it survives.
Source: InfoWorld News