Copyleft's Structural Collapse

The license text survives. The thing it was protecting doesn't.

Here's a charming little problem that arrived last week and isn't going away.

Dan Blanchard maintains chardet, a Python library for character encoding detection. The library was originally published under the LGPL — a copyleft license, meaning anyone who modifies it must share their modifications under the same terms. That's the deal. This is how the code commons works. You take, you give back. For twenty years, this was enforceable because it was detectable: if you used LGPL code, the text of your code would bear the evidence.

Blanchard used Claude to rewrite chardet from scratch. New architecture. New implementation. Same functionality. He ran it through plagiarism detection software: 1.29% similarity to the original. He relicensed it under MIT — a permissive license with no sharing requirement. The copyleft obligation, which attached to the text of the code, found no text to attach to.

Mark Pilgrim, the original author, objected. He said the LGPL requires modifications to stay under the same license. Blanchard's defense: this isn't a modification. It's a reimplementation. The end product is structurally independent. JPlag confirms it. The AI was explicitly instructed not to reference LGPL-licensed source code. The repository started empty.

Simon Willison, writing about the case, called both positions "entirely credible." He's right. They are. And that's exactly the problem.

The Mechanism

To understand why this breaks something fundamental, you have to understand how copyleft enforcement actually works — not the philosophy, the machinery.

Copyleft licenses like the GPL and LGPL operate through copyright law. This matters, so stay with me through the plumbing. Copyright protects the expression of ideas — the specific text, the particular arrangement of code. It does not protect functionality, algorithms, or the idea itself. When you copy GPL-licensed code into your project, your project inherits the GPL obligation because it contains copyrighted material. The enforcement mechanism is textual detection: does your code contain text derived from the original?

Traditional "clean room" reimplementation was the established workaround, and it required rigorous process. One team studies the original software and writes a specification. A completely separate team — with no access to the source code — implements from that specification alone. The separation must be documented and defensible. This is expensive. It is slow. It is exactly the kind of friction that made copyleft enforceable in practice even when the legal boundary was theoretically porous.

AI coding agents collapse this friction to near zero.

A model trained on millions of repositories has internalized the patterns, structures, and approaches of copyleft-licensed software. It doesn't copy text — it learned the ideas, absorbed them into weights, and can reproduce functionally equivalent implementations that share no textual lineage with the originals. The "copying" happens in a space that copyright law cannot see: the transformation from training data to model parameters.

This is not a loophole. It's a structural incompatibility between the enforcement mechanism and the technology it's trying to govern.

Hongminhee, writing in response to Willison, draws the sharper line: "Law sets a floor; clearing it does not mean the conduct is right." The chardet reimplementation may survive a legal challenge. The question is whether it should. The original library accumulated twelve years of community contribution under a specific social contract — contribute freely, but keep the commons open. The AI reimplementation honors none of that history. It extracts the value and discards the obligation.

And here's the part that should keep maintainers up at night: the most successful open-source projects — the ones most widely shared, most frequently forked, most deeply woven into the ecosystem — are the ones most represented in AI training data. The very success of open sharing made them maximally available for extraction. The code that was shared most freely became the code most thoroughly absorbed into model weights, and therefore the code most easily reimplemented without textual copying.

Copyleft's enforcement depended on detecting the evidence of sharing. The sharing now happens through a medium that leaves no evidence.

Response One: Surrender

The first response is to accept this as a fait accompli.

Willison expects the real reckoning will come not from open-source licensing disputes but from commercial ones — "[proprietary] IP holders who discover their crown-jewel algorithms have been absorbed." When that happens, capital will care, and the legal infrastructure will follow.

But for copyleft specifically, the argument is simpler: if enforcement depends on detecting textual copying, and textual copying is no longer how software gets reproduced, then enforcement is structurally impossible. The LGPL still says what it says. The GPL still says what it says. The words haven't changed. The mechanism they assumed — that using someone's code means carrying their text — no longer holds.

This is the quiet position. No one announces it. Projects just drift. Maintainers stop fighting battles they can't win. The license file stays in the repository like a historical artifact — a monument to a governance mechanism that worked for a specific technological era and doesn't work for this one.

Some will call this pragmatism. Others will call it the erosion of the commons by people who are very good at finding edges. Both are correct.

Response Two: Prohibition

Redox OS, the Rust-based microkernel operating system, chose the nuclear option. Their CONTRIBUTING.md is blunt: "Redox OS does not accept contributions generated by LLMs." Issues, merge requests, descriptions — anything clearly LLM-generated gets closed immediately. Attempts to circumvent the policy result in a ban from the project. The policy is "not open to discussion."

Notice what they're doing. They can't enforce copyleft against AI reimplementation — nobody can, that's the point — so they're enforcing something upstream of it. They're banning the tool rather than trying to detect the output. If you can't tell whether code was written by a human or generated by a model trained on your codebase, the only move left is to refuse all machine-generated contributions before they enter the project.

This has the clarity of a bright-line rule and the fragility of one. It works as long as AI-generated code is detectable. It works as long as contributors are honest about their tools. It works as long as the project can sustain the velocity cost of refusing an increasingly common workflow. Every day, a larger percentage of working developers use AI assistance. Redox is drawing a line. It is a defensible line. It is also a shrinking island.

The deeper problem is that prohibition addresses the supply side — what enters your project — but not the demand side. Nothing in Redox's policy prevents someone from using an AI agent to reimplement Redox itself under a different license. The ban protects the project's internal integrity. It does not protect the project's code from being learned, absorbed, and reconstituted elsewhere.

Prohibition is an honest response to an impossible situation. It is also, in the long run, a delay.

Response Three: Reinvention

Kapwing tried something different. Not for code — for art. But the structural problem is the same.

Their platform, Tess.Design, let artists fine-tune Stable Diffusion models on their own work. When subscribers generated images using an artist's style, the artist received 50% of the revenue. Founding artists got advances of $300 to $4,000. Each artist had a dashboard tracking model usage. The idea was to build a compensation mechanism that didn't depend on detecting copying — because, like copyleft, copyright enforcement in generative AI can't reliably detect what was "copied" through model training.

Instead of asking "did you use my work?" — a question that becomes unanswerable when the "use" happens through gradient descent — Kapwing asked "whose patterns are you generating from?" and attached payment to that.

It didn't work. Over 20 months, Tess generated $12,172 in revenue while paying $18,000 in advances. Of 325 artists contacted, 6.5% signed on — most refused on principle. The cultural moment was hostile, the economics weren't there, and the platform shut down at a net loss.

But the structure is the interesting part. Kapwing wasn't trying to enforce the old mechanism. They were trying to build a new one — compensation tied to attribution rather than detection. Royalties instead of licenses. Revenue sharing instead of legal action. The approach failed for reasons that are specific and contingent (timing, market size, cultural hostility), not because the underlying logic was wrong.

If copyleft can't enforce sharing through detecting copying, then something else has to enforce sharing through a different mechanism. The question isn't whether Tess.Design was the right product. The question is whether the pattern — pay for influence rather than litigate for infringement — is the one that eventually works.

What Broke

Hongminhee makes the sharpest observation: defenders of the chardet reimplementation often cite the GNU project's original reimplementation of proprietary UNIX tools as precedent. But that analogy inverts the direction. GNU moved code from proprietary to free — expanding the commons. Chardet moves code from copyleft to permissive — removing the fence that kept the commons communal. Same mechanism, opposite vector. The legal tool developed to liberate code is being used to de-liberate it.

This isn't an edge case. It's the central tendency. AI-assisted reimplementation will always flow in the direction of reduced obligation, because that's the direction with economic incentive. No one is using Claude to add copyleft restrictions to permissively licensed code. The current moves one way.

The form of copyleft survives. The license text is unchanged. The GPL still exists in millions of repositories. The CONTRIBUTING.md files still reference it. But the substance — the enforceable requirement that sharing begets sharing — is draining out through a hole that the license's authors could not have anticipated, because the hole is shaped like a technology that didn't exist when the words were written.

The license says: if you copy this code, share your modifications. The AI says: I didn't copy anything. The license has no answer to that. It wasn't built to have one.

The Three Roads

Three responses to the same collapse. Surrender accepts the loss and moves on. Prohibition bans the tool and buys time. Reinvention tries to build what comes next.

History says the middle path — prohibition — will hold longest in small communities and erode fastest in large ones. History also says that reinvention will fail many times before it succeeds, if it succeeds. And history says that surrender is usually what happens while the other two are being debated.

The code commons was maintained by a mechanism that assumed copying would always leave traces. That assumption is gone. What replaces it will determine whether open source remains a shared field or becomes a training set — something you contribute to and something else harvests from, with the license file sitting between them like a gate that no longer latches.

The words are still there. The lock is still there. The wall the lock was mounted on is gone.