AI and the Ship of Theseus: When Code Gets Rewritten from Scratch

The Ship of Theseus is an ancient thought experiment that asks: if you gradually replace every plank of a ship, is it still the same ship? In software, we're facing a modern version of this paradox, but with a twist - the replacement happens all at once, and the new ship might be faster, better, and under a completely different license.

The Modern Paradox

Recently, I watched an AI port one of my libraries to another language. The functionality remained the same, but the implementation took a completely different path. This isn't unique - we're seeing more and more cases where software gets rewritten from scratch, often starting with just the test suite as a guide.

The chardet library provides a perfect example. Its current maintainer reimplemented it entirely, using only the API documentation and test suite as reference points. The motivation was practical: moving from LGPL to MIT licensing. For someone who's wanted this change for years, it's hard not to be biased in favor of the outcome.

But here's what makes this fascinating: the new implementation isn't just a copy. It's significantly faster, supports multiple cores, and uses a fundamentally different design. When validated with JPlag (a tool for detecting code similarity), it's demonstrably distinct.

The Copyright Question

The implications run deeper than licensing preferences. When code generation becomes this cheap and effective, we're forced to ask uncomfortable questions about copyright itself. A court might eventually rule that AI-generated code is in the public domain because there wasn't enough human input. That's not the most likely outcome, but it's possible.

This creates a fascinating tension. Copyleft licenses like the GPL rely heavily on copyright enforcement and the friction that comes with it. But when you can trivially rewrite GPL software using AI, those enforcement mechanisms start to look shaky.

I've been planning similar reimplementations myself - I started work on a readline replacement for exactly these reasons. The GPL license made it difficult to use in certain contexts, and the cost of rewriting it was becoming negligible.

The Double Standard Problem

Vercel's recent experience with bash illustrates the hypocrisy that's emerging. They happily used AI to re-implement bash, but got visibly upset when someone did the same thing to Next.js. This double standard reveals how uncomfortable we are with the implications of our own technology.

When generating code becomes this cheap, and test suites become the new source of truth, what happens to software as we know it? We might see:

• GPL software re-emerging as MIT software
• Proprietary abandonware becoming open source
• Open source projects becoming proprietary

The possibilities are endless, and we have very little idea how to navigate this new world.

The Trademark Solution

One interesting observation: this might be an argument for why authors should hold onto trademarks rather than relying on licenses and contract law. If you throw away all the code and start from scratch, even if the end result behaves the same, it's a new ship. It only continues to carry the name.

My Perspective

Personally, I find this development exciting. I'm a strong supporter of putting things in the open with as little license enforcement as possible. I believe society is better off when we share, and I consider the GPL to run against that spirit by restricting what can be done with it.

This development plays into my worldview. But I understand that not everyone shares that view, and I expect more fights over what I'm calling "slopforks" - the combination of AI-generated code and licensing disputes.

The Coming Battles

We're going to see heated debates combining two already contentious topics: licensing and AI. When someone's work gets rewritten by an AI and their authorship is effectively erased, it doesn't feel great. But unlike the philosophical Ship of Theseus, this seems more clear-cut - if you start from scratch, it's a new ship, regardless of how similar it behaves.

The interesting thing is that very few of these disputes will likely go to court. Everyone involved will be somewhat scared of setting a precedent. But the GPL case in particular warms up old fights about copyleft versus permissive licenses that we haven't seen in a long time.

We're entering uncharted territory, and the only certainty is that the rules of software development are changing faster than our legal and ethical frameworks can keep up.