by alterom | 2026-03-10 01:57:20+00:00
The article makes the same point; the quote was taken out of context.

The point the author was making was that the intent of GPL is to shift the balance of power from wealthy corporations to the commons, and that the spirit is to make contributing to the commons an activity where you feel safe in knowing that your contributions won't be exploited.

The corporations today have the resources to purchase AI compute to produce AI-laundered work, which wouldn't be possible without the commons the AI it got its training data from, and give nothing back to the commons.

This state of things disincentivizes contributing to the FOSS ecosystem, as your work will be taken advantage of while the commons gets nothing.

Share-alike clause of the GPL was the price that was set for benefitting from the commons.

Using LLMs trained on GPL code to x "reimplement" it creates a legal (but not a moral!) workaround to circumvent GPL and avoid paying the price for participation.

This means that the current iteration of GPL isn't doing its intended job.

GPL had to grow and evolve. The Internet services using GPL code to provide access to software without, technically, distributing it was a similar legal (but not moral) workaround which was addressed with an update in GPL.

The author argues that we have reached another such point. They don't argue what exactly needs to be updated, or how.

They bring up a suggestion to make copyrightable the input to the LLM which is sufficient to create a piece of software, because in the current legal landscape, creating the prompt is deemed equivalent to creating the output.

You can't have your cake and eat it too.

A vibe-coded API implementation created by an LLM trained on open source, GPL licensed code can only be considered one of two things:

— Derivative work, and therefore, subject to the requirement to be shared under the GPL license (something the legal system disagrees with)

— An original work of the person who entered the prompt into the LLM, which is a transformative fair use of the training set (the current position of the legal system).

In the later case, the input to the LLM (which must include a reference to the API) is effectively deemed to be equivalent to the output.

The vibe-coded app, the reasoning goes, isn't a photocopy of the training data, but a rendition of the prompt (even though the transformativeness came entirely from the machine and not the "author").

Personally, I don't see a difference between making a photocopy by scanning and printing, and by "reimplementing" API by vibe coding. A photocopy looks different under a microscope too, and is clearly distinguishable from the original. It can be made better by turning the contrast up, and by shuffling the colors around. It can be printed on glossy paper.

But the courts see it differently.

Consequently, the legal system currently decided that writing the prompt is where all the originality and creative value is.

Consequently, de facto, the API is the only part of an open source program that has can be protected by copyright.

The author argues that perhaps it should be — to start a conversation.

As for who the benefactors are from a change like that — that, too, is not clear-cut.

The entities that benefit the most from LLM use are the corporations which can afford the compute.

It isn't that cheap.

What has changed since the first days of GPL is precisely this: the cost of implementing an API has gone down asymmetrically.

The importance of having an open-source compiler was that it put corporations and contributors the commons on equal footing when it came to implementation.

It would take an engineer the same amount of time to implement an API whether they do it for their employer or themselves. And whether they write a piece of code for work or for an open-source project, the expenses are the same.

Without an open compiler, that's not possible. The engineer having access to the compiler at work would have an infinite advantage over an engineer who doesn't have it at home.

The LLM-driven AI today takes the same spot. It's become the tool that software engineers can and do use to produce work.

And the LLMs are neither open nor cheap. Both creating them as well as using them at scale is a privilege that only wealthy corporations can afford.

So we're back to the days before the GNU C compiler toolchain was written: the tools aren't free, and the corporations have effectively unlimited access to them compared to enthusiasts.

Consequently, locking down the implementation of public APIs will asymmetrically hurt the corporations more than it does the commons.

This asymmetry is at the core of GPL: being forced to share something for free doesn't at all hurt the developer who's doing it willingly in the first place.

Finally, looking back at the old days ignores the reality. Back in the day, the proprietary software established the APIs, and the commons grew by reimplementing them to produce viable substitutes.

The commons did not even have its own APIs worth talking about in the early 1990s. But the commons grew way, way past that point since then.

And the value of the open source software is currently not in the fact that you can hot-swap UNIX components with open source equivalents, but in the entire interoperable ecosystem existing.

The APIs of open source programs are where the design of this enormous ecosystem is encoded.

We can talk about possible negative outcomes from pricing it.

Meanwhile, the already happening outcome is that a large corporation like Microsoft can throw a billion dollars of compute on "creating" MSLinux and refabricating the entire FOSS ecosystem under a proprietary license, enacting the Embrace, Extend, Extinguish strategy they never quite abandoned.

It simply didn't make sense for a large corporation to do that earlier, because it's very hard to compete with free labor of open source contributors on cost. It would not be a justifiable expenditure.

What GPL had accomplished in the past was ensuring that Embracing the commons led to Extending it without Extinguishing, by a Midas touch clause. Once you embrace open source, you are it.

The author of the article asks us to think about how GPL needs to be modified so that today, embracing and extending open-source solutions wouldn't lead to commons being extinguished.

Which is exactly what happened in the case of the formerly-GPL library in question.