The cURL project shut down its bug bounty program in January 2026. Daniel Stenberg, after six years of running it, pulled the plug because fewer than 5% of submissions described real vulnerabilities. The rest was noise. AI-generated noise that looked professional on the surface but crumbled under the slightest scrutiny. A month later, Mitchell Hashimoto banned AI-generated code from Ghostty entirely. Steve Ruiz went further: tldraw now auto-closes all external pull requests. In July, the Godot Foundation rewrote its contribution policy to prohibit autonomous AI agents and vibe-coded submissions outright.
The social fabric of Open Source is fraying. Not slowly. Visibly.
Two Movements, One Label
People use "open source" as if it describes one thing. It describes two, and the distinction matters now more than it ever has.
Richard Stallman launched the GNU Project in 1983 around a moral claim: software should respect the user's freedom. The freedom to run it, study it, modify it, share it. This was an ethical position first, a development methodology second. The GPL existed to prevent enclosure — to make it legally impossible for someone to take free software and lock it back up. Stallman was explicit: "Think free as in free speech, not free beer." The point was liberty, not cost.
Then in February 1998, after Netscape announced it would release Navigator's source code, Tim O'Reilly convened the Freeware Summit in Palo Alto. Eric Raymond, Bruce Perens, and about twenty others voted to adopt a new label: "open source." Christine Peterson had originally suggested the term. The explicit goal was to drop the ethical language that made corporate adopters nervous and reframe the concept as a development methodology and a business strategy. Raymond wrote it plainly at the time: the "serious push to get free software accepted in the mainstream corporate world" required abandoning the moral baggage.
The Open Source Initiative that emerged was a marketing operation as much as a technical one. Same licenses, mostly. Radically different framing. Stallman's movement said: you have a moral obligation to keep software free. O'Reilly's movement said: open development produces better software, and you can build a business on it.
What made both models work as production systems was a coincidence of economics. Software was expensive to create. The people who could create it well had both disciplinary mastery and available time; often academics, often engineers at institutions that gave them autonomy to pursue problems. Collaboration scaled the only way it could in that era: by adding more skilled humans. The maintainer's job was to control scope and quality. The scarcity of capable contributors was the natural governor.
That governor is gone.
The Flood
GitHub's 2025 Octoverse report showed developers creating more than 230 new repositories every minute and pushing nearly one billion commits that year, a 25% increase over 2024. A CodeRabbit analysis of 470 open-source pull requests found that AI-generated contributions contain 1.7 times more defects than human-authored ones. Logic errors appear 75% more often. Security vulnerabilities at nearly three times the rate. I/O performance issues at eight times the frequency.
A 2025 GitHub maintainer survey of 8,000 active maintainers found that 67% reported a meaningful increase in low-quality AI-generated pull requests. Thirty-one percent had already implemented policies restricting AI contributions. The elimination of what one researcher called "effort backpressure" — the time and understanding historically required to submit a patch — has increased low-quality inbound noise by an estimated ten times or more.
The volume is up. The signal-to-noise ratio is catastrophically down. And the thin layer of human maintainers responsible for triaging this flood is burning out.
Three Things Worth Considering
1. The Right to Refuse
Projects that outright refuse AI-generated code are perfectly within their rights to do so. More than that: the value proposition of human-crafted software is likely to increase, not decrease, for certain non-generic use cases where speed to the user isn't the primary objective.
Think of it like small-batch beer. It will be better than its industrial counterparts for those who care about the craft. It will cost more. Good examples will be harder to find. But the people who seek it out will value it precisely because a human made deliberate choices at every step, not because a machine optimized for token probability produced something statistically plausible.
Godot's policy is a template here. They drew a specific, enforceable line between light assistive use and bulk AI generation, backed by mandatory human-review requirements. This isn't Luddism. It's quality control applied to a new category of input.
2. The Trust Problem
This one is harder. Projects probably need to spend a lot more time ignoring pull requests from people they don't personally know.
It is an unfortunate side effect of the current era that distinguishing between a human contributor and a bot farming GitHub activity has become genuinely difficult. The AI-generated PR looks grammatically correct, follows the template, and passes surface-level review. The contributor's profile shows activity. Everything appears legitimate until you spend thirty minutes verifying that the change actually does what it claims to do, and discover it introduces a subtle regression the submitter cannot explain when questioned.
There may be good news on the horizon. Cloudflare and GoDaddy announced a partnership in April 2026 around the Agent Naming Service (ANS), an open standard using DNS and PKI to verify when an AI agent is genuinely acting on behalf of a specific human. By June, Cloudflare shipped cryptographic identity verification for AI agents based on the W3C Web Bot Auth specification. The infrastructure for distinguishing human from machine in automated interactions is being built. But we are not there yet for code contributions at scale.
In the interim, the pragmatic move is smaller trust circles. This disrupts the concept of Open Source as a community of strangers collaborating toward a common goal. But it preserves the idea of open source as software: code you can see, audit, modify, and run. The access doesn't change. The contribution model narrows.
3. The Uncomfortable Liberation
Here is the part that challenges us most. AI has, in many ways, done exactly what Stallman's movement wanted to accomplish. It has liberated the software.
Not in the way anyone expected. Not through licensing. Not through community governance. Through sheer productive capacity. The cost of creating functional software has collapsed. The moat that made O'Reilly's open-source collaboration model necessary — that software was too expensive for any one person to build alone — has been breached by tools that let a single developer produce what once required a team.
For a period of time, people had learned how to use open source (free as in beer) as a way to make money. Entire multi-billion dollar organizations were built on that model: offer the software for free, sell the support, the hosting, the enterprise features. MongoDB, Redis, Elastic, HashiCorp — all built empires on open-source foundations. Redis switched to a restrictive license in 2024, then returned to AGPL in 2025. The licensing churn tells you everything about how uncomfortable the deconstruction has become.
But the economic disruption of the business model doesn't change the point of open source. The point was never the money. The point was that software should be free to use, study, modify, and share. AI hasn't destroyed that principle; it has made it more achievable than ever, while simultaneously making the social structures we built around it less viable.
The Distinction That Matters
It turns out the 1998 split was prophetic, just not in the way anyone anticipated. O'Reilly's version — Open Source as community process, as business model, as the social machinery of pull requests and meritocratic contribution — is what's under genuine stress. The economics that sustained it have shifted. The social norms that governed it are being overwhelmed by volume. The companies that monetized it are scrambling to change their licenses.
Stallman's version — that software should be transparent, modifiable, and free to use — is not only surviving, it is being supercharged. Open-source AI models deliver 90% cost reductions over proprietary APIs with near-parity performance. The liberation of software from corporate lock-in is accelerating, not retreating. AI is the most powerful engine for "free as in speech" software the world has ever produced, precisely because it makes the creation of transparent, modifiable, shareable code trivially accessible to anyone with a problem to solve.
So What
None of this means there's no business left in free-as-in-beer software. There is. But the mechanics are changing.
The old model was straightforward: give away the code, sell the expertise required to run it at scale. That worked when the code was complex enough that expertise was scarce. AI compresses that scarcity. When any developer can generate, customize, and deploy software that previously required a team of specialists, the value migrates. It moves from "we'll run the thing you can't run yourself" toward "we'll solve the problem you haven't identified yet." From operational leverage to intellectual leverage. From hosting to insight.
Redis returning to AGPL after its licensing detour isn't capitulation. It's recognition that the moat was never the license; it was the pace of innovation. The companies that will thrive in open source going forward are the ones that understand this: you don't monetize access to the code. You monetize the velocity of what comes next.
The human fundamentals haven't changed. People still have the right to free software. People still have the right to earn a living building it. What's changed is the mechanism connecting those two rights. The old mechanism was community contribution and corporate patronage. The new mechanism is still being written, and the organizations that figure it out first will define the next era of software economics.
AI is disrupting how we perceive and use software economically. It is not disrupting the underlying human needs: to create, to share, to earn, to build on each other's work. Those needs are permanent. The structures we built to serve them are not.
While Open Source is certainly struggling, it might just be that the future truly is open source. We just need to learn the new mechanics.