Around the mid-2010s, “free software” quietly vanished from most developer conversations.
What replaced it was “open source.” Open source felt gentler, more business-friendly, less like an ideological crusade. MIT licenses outnumbered GPL on GitHub by wide margins. Startups used open source as a growth strategy. Big tech companies wielded it for ecosystem lock-in. “Free software” sounded like a relic from another century, something only bearded zealots like Richard Stallman cared about when they insisted on calling it GNU/Linux.
Then coding agents arrived, and things got interesting.
A recent discussion on Hacker News caught attention for a simple thesis: when AI agents can read, modify, and compose arbitrary codebases, “source freedom” stops being a philosophical stance and becomes an actual capability. The argument sounds abstract at first, but it touches on a structural shift that’s already underway.
A Forgotten History
To understand why coding agents might change the fate of free software, we need to trace how this movement ended up marginalized.
In 1983, Richard Stallman launched the GNU Project. Two years later he founded the Free Software Foundation with a core principle: software users should have four freedoms to run, study, modify, and distribute. The GPL license was the legal implementation of this philosophy, with its “copyleft” clause requiring any derivative work to also be open source.
This vision had its glory days in the 90s and early 2000s. The Linux kernel ran on GPL. GNU tools powered internet infrastructure. Firefox broke Internet Explorer’s monopoly. During that era, the free software movement really did feel like a revolution, wrapped in idealism and backed by technical achievements.
The turning point came in the late 2000s. Several things happened at once. Cloud computing rose, and software shifted from “installed on your computer” to “running on someone else’s server.” This made GPL’s copyleft clause ineffective in the SaaS model since you weren’t “distributing” software, so GPL’s obligations never triggered. GitHub launched in 2008 and turned “open source” into social currency and career capital, but GitHub culture favored permissive licenses like MIT and BSD over copyleft ones. The mobile internet explosion brought closed ecosystems like the App Store into dominance, leaving almost no room for free software principles on mobile platforms.
By the 2010s, “open source” had completely displaced “free software” as the mainstream narrative. The difference is subtle but matters. Open source emphasizes development methodology: public code enables efficient collaboration. Free software emphasizes user rights: you should control the software you use. When open source became a marketing tool for large companies, the dimension of “user rights” quietly disappeared.
Stallman became an awkward figure. His technical judgments proved right on many fronts, from warnings about cloud computing to opposition to DRM to insistence on privacy. But his communication style and personal controversies pushed him further to the margins. The free software movement lost its evangelist and its storytelling power.
By the early 2020s, the landscape looked like this: open source was everywhere, but the core concern of free software, user control over software, was actually retreating. Your phone, your cloud services, your AI tools gave you less control than twenty years earlier, not more.
What Coding Agents Change
Then AI coding agents appeared. Starting in 2025, tools like Claude Code, Cursor, GitHub Copilot, and OpenAI Codex evolved from “code completion” to “autonomous programming.” They could read entire codebases, write new features, fix bugs, run tests. By 2026, coding agents stopped being toys and became part of many developers’ daily workflows.
What does this mean for free software?
Start with the most direct impact: the contribution barrier dropped dramatically.
The free software movement always faced a dilemma: source code might be open, but a massive gap exists between “being able to read source code” and “being able to effectively modify it.” Take a large open source project like the Linux kernel or Chromium, with codebases ranging from millions to tens of millions of lines. Even if you have the right to modify it, very few people actually can. You need to understand the architecture, get familiar with code style, know which files relate to each other, get the build and tests working. This barrier turned “freedom to modify” into a privilege for a small expert class.
Coding agents are dismantling this barrier. You can have an AI read an entire codebase, ask it “how does this feature work,” then say “help me change it to do this instead.” AI doesn’t get intimidated by code volume, doesn’t hesitate because it’s unfamiliar with project style, doesn’t spend three days setting up a development environment. It compresses the most time-consuming step of “understanding code” from weeks to minutes.
This means the “freedom to modify” guaranteed by GPL has, for the first time, a real possibility of large-scale implementation. Previously, an average user dissatisfied with some GPL software theoretically had the right to fork and modify it but practically couldn’t. Now, the same user can have a coding agent help them do it. Freedom shifts from a paper right to an actual capability.
The second impact goes deeper: the moats around closed-source software are weakening.
The business logic of closed-source software rests on an assumption that code complexity itself is a barrier. Even if competitors know what your product does, rewriting an equivalent replacement from scratch requires massive engineering investment. This assumption starts to wobble in the coding agent era.
When AI can rapidly understand requirements, generate code, and iterate optimizations, the cost of “building from scratch” is falling sharply. An open source alternative no longer needs a large team spending years catching up to a closed-source product’s features. A small team plus coding agents might produce an 80% feature-equivalent alternative in months. This doesn’t mean closed-source software will disappear, but its competitive advantage is shrinking.
The third impact concerns “composition.” One of the four freedoms in free software is “freedom to distribute modified versions.” In the coding agent era, this freedom gains amplified value. AI excels at combining different open source components into new solutions. It can borrow a module from this project, take an algorithm from that one, then glue them together. If these components are all free software, this composition is legal and encouraged. If any are closed source, composition hits licensing obstacles.
So from a purely pragmatic angle, free software licenses actually become an advantage in the coding agent era because they let AI use, modify, and combine code without barriers.
Old Problems Don’t Automatically Disappear
At this point, it’s easy to slip into optimistic narrative: coding agents arrived, free software is reviving, long live open source.
But the free software movement didn’t decline just because “contribution barriers were high.” It faces a series of structural problems that coding agents can’t solve.
Funding is the biggest one. Free software projects have long suffered from the tragedy of the commons: everyone uses it, nobody wants to pay. Before the Heartbleed vulnerability exploded, OpenSSL’s entire project had an annual budget under one million dollars, yet it protected most encrypted communication on the internet. The Log4j maintainer was asked to work overtime for free to fix a serious vulnerability. These stories repeat.
Coding agents can help write code but can’t help pay the bills. An AI can submit pull requests but can’t pay server costs, handle legal disputes, or make final security audit decisions. If the funding model for free software projects doesn’t change, more AI contributions might actually increase the burden on maintainers because every PR needs human review.
Governance problems are equally thorny. The governance structures of large open source projects, who has merge permissions, who decides technical direction, how conflicts get resolved, evolved over years and still frequently break. Coding agents won’t make governance simpler. If AI starts submitting code at scale, who’s responsible for AI-generated code? If an AI submission introduces a security flaw, who’s liable? These questions currently have no answers.
Then there’s quality. AI-generated code might be functionally correct but could fall short on maintainability, security, or architectural consistency. If an open source project gets flooded with low-quality AI-generated PRs, maintainer workload doesn’t decrease but increases. The Linux kernel community is already discussing how to handle AI-generated patches, with considerable caution.
New Tensions
The biggest paradox free software faces in the AI era might not be these old problems but an entirely new tension.
AI companies train models on massive amounts of open source code. Public code on GitHub, Stack Overflow Q&A, open source project documentation all become part of training data. Much of this data sits under GPL or other copyleft licenses. But the trained models themselves are closed source. You can’t inspect model weights, can’t modify their behavior, can’t freely distribute them.
Does this count as “freedom”?
From a legal angle, current consensus leans toward “training doesn’t constitute a derivative work,” so GPL’s copyleft clause doesn’t apply. But from the spirit of the free software movement, this is massive irony: code assets accumulated over decades by the free software community get used to build some of the most closed software systems in human history. You contributed code, AI companies took it to train models, then sell you the models, and you have zero control over them.
What Stallman opposed in 1983 was exactly this asymmetry: someone uses your labor to build a system you can’t control. Forty years later, the same pattern repeats at larger scale.
This tension has spawned new attempts. Some are pushing for “open source AI” definitions requiring model weights, training data, and training code to all be public. Meta’s LLaMA series took a semi-open route, with weights public but usage restricted. Others are exploring new licensing frameworks trying to extend copyleft principles to AI models. But these attempts are all early-stage, far from consensus.
The Developer World Is Changing
Setting aside grand narratives, for regular developers, the impact of coding agents on open source ecosystems is already happening.
Contribution methods are changing. Previously, contributing code to an open source project meant fork, clone, set up environment, read code, write patch, submit PR, wait for review. This flow could take days to weeks. Now, more developers use coding agents to accelerate the process: having AI help understand the codebase, generate initial patches, even help write tests. GitHub already shows a clear trend of increasing PR volume, but with greater variance in average quality.
Project maintenance is changing. Some projects now use AI for preliminary PR review, checking code style, running tests, identifying common issues, reserving human reviewer energy for architectural decisions and security audits. This is reasonable division of labor, but it means maintainers need new skills: not just writing and reviewing code, but managing AI toolchains and setting quality standards for AI contributions.
The meaning of forking is changing. Before coding agents, forking a large project was basically a “nuclear option,” meaning you’d bear the full cost of independently maintaining a complex codebase. Few forks survived long term. But if coding agents can substantially lower maintenance costs, forking might become more viable. This is good for free software because “freedom to fork” becomes more practical, but potentially challenging for project governance because splitting becomes easier.
License choice considerations are changing. If you believe coding agents will make code composition and reuse more frequent, then choosing a license that allows free combination, whether MIT or GPL, has more strategic value than a restrictive license. Conversely, if you worry about AI companies freely using your code to train models, you might lean toward stricter licenses, even new types specifically targeting AI training like some emerging “AI-restrictive” clauses.
The New Meaning of Freedom
Back to the original question: will coding agents really make free software rise again?
My assessment is no, not in its original form, but the concept of “freedom” will become important in new ways.
The free software movement in Stallman’s era focused on “do you have the right to view and modify source code.” In the coding agent era, the answer to this question has changed, not because laws changed, but because the gap between “having the right” and “having the capability” got filled by AI. When anyone can understand and modify code with AI help, whether source code is open shifts from a matter of principle to a practical matter: open code can be better utilized by AI, while closed code faces diminishing barriers against AI.
The new “freedom” questions are no longer just about source code but about the entire AI technology stack. Can you control the AI models you use? How is your data being used? Can you audit and modify decisions AI makes? These questions are more complex and more urgent than “is the source code open.”
The most valuable legacy of the free software movement might not be the GPL license or GNU toolchain, but the fundamental question it posed: who controls the technology you use? In the AI agent era, this question deserves more serious attention than ever before.
Coding agents don’t guarantee free software’s revival. They do guarantee that dismissing “freedom” as outdated ideology is no longer viable. When AI can read and modify any code, when technical barriers fall while control barriers rise, Stallman’s old warnings start sounding less like paranoia and more like foresight.
The conversation about software freedom isn’t ending. It’s just getting started again, with higher stakes.
Stay updated with our latest AI insights
