Coding Agents Could Make Free Software Matter Again

I’ve been vibe-coding a lot lately. Like, a lot a lot. Maybe not quite the “AI psychosis” Andrej Karpathy recently joked about on No Priors, but not wildly far off either.[1] But the more I vibe, the more a thought recurs, i.e. that AI coding agents may be about to make free software matter more than it ever has. Not open source in the bland corporate sense. I mean free software in Stallman’s sense: software that gives users the freedom to run it, study it, modify it, and share it.

Even for the relatively few who were aware of the distinction, it has felt mostly academic for a long time. SaaS made it hard to care software freedom because most people never saw or touched the source code of software they depended on in the first place. The code lived on someone else’s servers, the vendor handled operations, and the practical question became convenience, not freedom.

Agents change that. If an agent can read a codebase, understand it, and modify it on your behalf, then access to source code stops being a symbolic right for programmers and becomes a practical capability for far more people. Suddenly the difference between software you can change and software you can only beg starts to really matter.

And I don’t just think this in the abstract. I recently tried to get an AI agent to customize a SaaS app for me, and the experience made the whole problem very concrete very fast.

Free software once mattered deeply, but faded when SaaS made those freedoms feel irrelevant.

In 1980, Richard Stallman[2] was a programmer at MIT’s AI Lab, and he had a problem with a printer. The lab had gotten a new Xerox laser printer, and it kept jamming. Stallman wanted to fix the issue — or at least add a feature to notify users when their print jobs got stuck — but Xerox wouldn’t give him the source code. The printer’s software was proprietary.

This seems like a small thing. It was not a small thing to Stallman.

He’d grown up in a computing culture where sharing code was the norm. When you got software, you got the source code, because of course you did — how else would you fix bugs or add features? The Xerox printer incident crystallized something for him: a world where software was locked up, where you couldn’t study or modify the tools you depended on, was a world where users had lost something fundamental.

So Stallman founded the Free Software Foundation and spent the next four decades evangelizing what he called “the four freedoms”:

Freedom 0: The freedom to run the program as you wish, for any purpose. Freedom 1: The freedom to study how the program works, and change it to do what you want. Freedom 2: The freedom to redistribute copies so you can help others. Freedom 3: The freedom to distribute copies of your modified versions to others.

“Free as in speech,” he’d say, “not free as in beer.”

For a while, this message resonated. The 1990s saw an explosion of free software: Linux, Apache, MySQL, PHP — the entire stack that would come to power most of the internet. Companies like Red Hat proved you could build real businesses around it. Eric Raymond wrote “The Cathedral and the Bazaar” and argued that open development produced better software. Microsoft’s Steve Ballmer called Linux “a cancer.” It felt like a genuine ideological battle for the soul of computing.

And then, quietly, the battle became irrelevant, for a pretty boring reason.

But we’ll come back to that in a moment.

The “open source” rebrand preserved code sharing while stripping out the user-rights philosophy.

First, here’s a piece of history that I didn’t know before researching this post. It matters for understanding what’s happening now.

On February 3, 1998, a group of people met at the Foresight Institute in Palo Alto — not a software organization, but a nanotechnology think tank. Christine Peterson, the institute’s executive director, proposed replacing “free software” with a new term: “open source.”[3] Her reasoning was practical: every time you said “free software,” people thought you meant free-as-in-beer, and you’d spend ten minutes explaining the difference instead of talking about the actual software.

A few weeks later, at Tim O’Reilly’s April 1998 “Freeware Summit,” attendees debated naming and voted 9-6 for “open source” over alternatives like “sourceware” and “free software.”[4]

The important thing is what got lost in the rebrand. Eric Raymond and Bruce Perens co-founded the Open Source Initiative that same month, and Raymond published a manifesto called “Goodbye, ‘free software’; hello, ‘open source.'” His key argument: the old terminology made corporate types nervous.[5]

Stallman was not invited to Tim O’Reilly’s “Freeware Summit” in April 1998 — the event that helped cement the new leadership narrative. Linus Torvalds was invited. Larry Wall was invited. Guido van Rossum was invited. Stallman was not.[4]

Why does this matter? Because the “open source” rebrand wasn’t just a marketing change — it was a philosophical amputation. “Open source” kept the code-sharing practices but surgically removed the ethical claim about what users deserve. As Stallman put it: “Open source is a development methodology; free software is a social movement.”[6] Raymond was explicit that “free software” was confusing and made corporate types nervous.[5]

The corporate world loved this. You could use open-source code, contribute to open-source projects, and build an open-source brand identity without ever having to grapple with the question of what users were owed. Open source became a development methodology that corporations could adopt without changing their relationship to their users at all.

SaaS scaled by exploiting a licensing loophole that let vendors avoid sharing their modifications.

But it ultimately wasn’t a political or philosophical debate that really sidelined free software – it was SaaS.

The GPL — the main free software license — required you to share source code with anyone you distributed the software to. The key word is “distributed.” If you never distributed the software — if you just ran it on your own servers and let people access it over the web — the license didn’t apply. You could take free software, modify it, build a business on it, and never share your modifications with anyone.

This wasn’t hypothetical. A high-profile example was AWS offering managed services around projects like Elasticsearch, which triggered very public disputes over value capture, contribution, and license terms.[7] Within the SaaS model, GPL copyleft obligations often do not trigger unless software is distributed, so source-sharing requirements can be sidestepped.[8]

The numbers tell the story of what happened next: through the 2010s and into the 2020s, permissive licenses became increasingly dominant in open-source usage data.[9]

There was an attempt to fix this. The AGPL (Affero GPL) was designed to close the SaaS loophole — if you modified AGPL software and made it available over a network, you had to share the source code.[8] It was a powerful idea. So much so that Google now maintains a broad public policy banning AGPL code inside Google.[10] As Drew DeVault argued,

Google’s anti-AGPL stance wasn’t just a legal precaution — it was strategic: “By discouraging the use of AGPL in the broader community, Google hopes to create a larger set of free- and open-source software that they can take for their own needs without any obligations.”

The AGPL’s limited adoption spawned a cascade of improvisation. MongoDB switched to the Server Side Public License. Redis Labs moved several Redis modules to Commons Clause-style licensing in 2018, and Redis later moved core Redis to dual source-available licensing before adding AGPL in Redis 8. HashiCorp switched Terraform to the Business Source License. Elastic went from Apache to SSPL/ELv2, then added AGPL. Each switch validated the underlying problem while failing to fully solve it.[11]

And honestly? From the user’s p