Software licensing had a good run. From the GPL’s viral copyleft to MIT’s permissive elegance, licenses were the legal scaffolding of the software world. They defined who could use code, how, and under what terms. Entire careers were built around open source compliance.

None of it matters anymore.

The Authorship Problem

Licensing assumes a clear author. Someone writes code, they own it, they choose terms. That model made sense when humans wrote software by hand, line by line, with intent and craft.

Now? A developer types a comment describing what they want, and an AI produces fifty lines of working code. Who authored that? The developer who wrote the prompt? The AI company? The millions of programmers whose code trained the model? The answer is legally murky at best and philosophically incoherent at worst.

You can’t license what you don’t own. And increasingly, nobody owns anything.

Three Reimplementations

I’ve implemented a blind astrometry plate solver, the kind of software that looks at an image of the night sky and figures out where the camera was pointing, using nothing but the pattern of stars, three times now.

The first time, I wrote it by hand in Java for a closed-source project. It took me a month. The second time, in Python, also closed-source. Two weeks. Both times I was working from Dustin Lang’s excellent thesis and studying the astrometry.net reference implementation, a genuinely impressive piece of software that I credit as the inspiration for all three of my implementations. Same algorithm, same geometric hashing, same kd-tree lookups, same Bayesian verification.

The third time, I built zodiacal in Rust. I was drunk on a boat in the British Virgin Islands. I handed an AI the reference thesis, Lang’s implementation to study, a star catalog library, and 1,000 images with known correct answers. It did the rest. The result solves 98.5% of test fields in about a second.

Three implementations. Same algorithm. Zero shared lines of code between any of them. Zodiacal cites astrometry.net and Lang’s paper prominently. Credit where it’s due. But credit and licensing are different things.

So what license governs zodiacal? Not astrometry.net’s. I never copied their code. Not whatever license covered my previous Java and Python versions. Those were clean-room rewrites too. Not the AI model’s training data. Good luck tracing which weights contributed to which function. The algorithms are published science, uncopyrightable by design. And the latest implementation was generated by a machine while I was sipping rum in the Caribbean.

Zodiacal’s foundation library, starfield, has a similar origin story. It’s a Rust port of Brandon Rhodes’ Skyfield, a beautifully designed Python library for positional astronomy. Coordinate transforms, precession, nutation, star catalog management, the whole stack. Ported in a couple of weeks. The testing strategy was beautifully simple: a Python bridge that runs both libraries side by side and checks them for agreement. Feed the same inputs to Skyfield and starfield, compare outputs, iterate until they match.

The result is a library that produces identical results to Skyfield, cites it as the direct inspiration, shares zero code with it, and was largely written by a machine using the original as a behavioral specification. Skyfield is MIT-licensed. Starfield is MIT-licensed. But the choice of license is almost incidental. The code was derived from behavior, not from source. No license can prevent someone from reimplementing your observable outputs.

Then there’s pastebom.com. I wanted a hosted service for sharing interactive PCB bill-of-materials viewers. The existing tool, InteractiveHtmlBom, is a great project. I use it all the time and credit it as the direct inspiration for pastebom. I contributed upstream to make it work headless, offered to port the format extractors to Rust. The maintainer had different priorities, which is totally reasonable. Their project, their call.

So I extracted the drastic subset I actually needed and added support for more formats from Altium. I validate the extraction utilities against a library of closed-source design files from my own projects, the same pattern as zodiacal and starfield. Give an AI the file format spec, a pile of real-world files with known correct outputs, and let it iterate. I cite InteractiveHtmlBom on the site because it deserves the credit. But the point stands: the formats are documented, the behavior is observable, and an AI can reimplement a PCB file parser in an afternoon if you point it at the spec. Attribution and gratitude are the right thing to do. But a license couldn’t have stopped any of this, and it couldn’t have compelled it either.

The Real Currency: Ground Truth

Notice what all three projects have in common. Zodiacal had 1,000 images with known correct sky coordinates. Starfield had a Python bridge producing reference outputs from Skyfield. Pastebom had a library of real PCB design files with known correct extractions. In every case, the thing that made AI-driven reimplementation possible wasn’t access to the source code. It was access to ground truth.

Ground truth is the new source code.

An AI can’t write a blind astrometry solver from a vague description. But give it a spec and a thousand images where you already know the answer? It’ll converge on a working implementation. The same is true for coordinate transforms, file format parsers, and practically anything else where you can say “given this input, the correct output is that.”

This inverts the traditional value hierarchy. We used to think source code was the valuable artifact and correctness was a supporting concern. Now the code is the disposable part, regenerable on demand, and the curated collection of known correct answers is the irreplaceable asset. Ground truth is the specification, the oracle, and the training signal all at once. Collecting it requires domain expertise, real-world data, and the hard-won judgment to know what “correct” actually looks like.

If licensing doesn’t protect software anymore, what does? Ground truth. Domain expertise. Taste, knowing what to build when anyone can generate the code. Speed, shipping before anyone can replicate you. These are the new moats, and none of them are things a license file can provide.

So What Now?

We’re entering an era where code is abundant, cheap, and authorless. Licensing regimes built for a world of scarcity don’t survive contact with a world of abundance.

I still choose licenses for my projects. I still cite the people whose work inspired mine. But I do these things out of respect and convention, not because I believe they offer meaningful legal protection. The cultural norms of open source, attribution, gratitude, building on each other’s work, are worth preserving. The legal fiction that a LICENSE file controls what happens to your code is not.

Software licensing is dead. Long live ground truth.