For the past couple of years, the software industry treated AI-generated code like text typed in an incognito tab. You prompted a model, pasted the output into your editor, committed it under your name, and pushed it to production. Nobody asked where it came from, whether it echoed a GPL-licensed repository, or who was on the hook if it broke.
That era is ending. With the EU AI Act now in force, major model providers are rolling out invisible watermarking and cryptographic provenance for their outputs. The idea is that soon the code your agent writes will carry a verifiable fingerprint, so anyone can trace which model produced it and who signed off.
I did not wait for that. I have been tracking AI provenance on this site by hand the entire time, and looking at what my low-tech version gives me is the clearest way I know to explain what the automated version is really for.
Provenance already lives in my git history
I built desaputro.com with AI doing most of the typing, and I made one rule from the first commit: if AI helped write a change, the commit says so. In practice that is a single trailer line at the bottom of the commit message:
Co-Authored-By: Claude Opus 4.8 <[email protected]>It is not exotic. It uses the same Co-Authored-By convention teams already use for pair programming. But the effect is real. Right now, 140 of the 367 commits in this repository carry that trailer. Roughly a third of the history is explicitly marked as AI-assisted, and every one of those commits still has me, a human, as the author on the line above it.
That pairing is the whole model in miniature. The author line says who is accountable. The co-author trailer says what helped. Six months from now, when I am staring at a bug and running git blame, I do not have to guess whether a suspicious block was something I reasoned through myself or something an agent generated while I was moving fast. The record tells me. When I review my own history, I can see exactly where to be more skeptical.
Why the hand-rolled version is not enough
Doing this by hand is honest, but it is coarse and it is voluntary. My trailer says "AI helped here." It does not say which model version wrote which line, what prompt produced it, or whether the snippet was synthesized fresh or half-remembered from a repository whose license I would never agree to. And it works only because I choose to add it. Nothing enforces it, and nothing stops a contributor on a bigger project from leaving it off entirely.
That gap is exactly what real code watermarking is built to close, and it turns out watermarking code is harder than watermarking an image. You cannot just nudge some pixels. Every character has to stay valid syntax that compiles cleanly. So the industry is leaning on two techniques.
The first is statistical token biasing. The model subtly biases its choices among functionally identical options, things like variable naming or the ordering of operations. To the compiler the code behaves the same, but a scanner can check the statistical fingerprint and say, with real confidence, that a given snippet came from a particular model.
The second is cryptographic attestation in the pipeline. Agent platforms attach signed metadata to commits, so the history carries a verifiable record of which model generated a diff, what prompt drove it, and who authorized it. That is my Co-Authored-By trailer grown up: no longer a courtesy I remember to add, but a signature that cannot be quietly dropped.
Why this matters beyond my repo
On a personal site, sloppy provenance is a small risk. On shared infrastructure it is a legal one. Throughout my sixteen years in IT, one constant has been accountability around dependencies. We run license scanners, we audit third-party packages, we sign off on a software bill of materials so a proprietary codebase stays legally clean. Anonymous AI code walked straight past all of it.
This is the same pressure that pushed Oracle to ban AI-generated contributions from OpenJDK. For core infrastructure that millions of applications depend on, untracked code is not a productivity win, it is unbounded exposure. Verifiable provenance is the technical answer that lets those projects use AI without betting the license chain of custody on trust.
For day-to-day work it changes a few things. Legal teams can stop banning AI tools out of fear, because scanners can confirm generated code meets policy before it merges. Open-source maintainers can flag unreviewed AI pull requests automatically instead of finding out the hard way. And accountability sharpens: if an agent introduces a vulnerability, the audit log shows which human directed it and approved it. You still own what you ship.
It is just professional hygiene
Some developers see watermarking as surveillance. I see it as the industry catching up to something I already found worth doing by hand. We sign human commits to verify who wrote them. Marking AI authorship is the same instinct pointed at a new kind of author.
Knowing where your code came from is not a tax on building fast. It is what lets you build bigger without the fear that something in the foundation is not yours to use. I do the cheap version today, one trailer line at a time. The industry is building the rigorous version. Both are saying the same thing: a tool can write the code, but a human still has to answer for it.