A few weeks ago I wrote about a registry for AI images.
The idea was pretty simple tbh — when an image is created, you log a fingerprint somewhere, so later if it shows up again you can trace where it came from. Not guessing after the fact, but having actual receipts.
The more I thought about it, the less interested I became in the image part.
Images are only half the story. The real wildfire is text.
Every day now, millions of paragraphs appear online with no origin story. Some are written by humans. Some are written with AI. Some are written by humans pretending to be AI. Some are written by AI pretending to be human. Most of them are simply… floating. Detached from the moment they were written. Detached from the process that produced them. Detached from the question everyone eventually asks when something spreads far enough:
Where did this actually come from?
That question used to have an answer. If you read an article in a newspaper in 1994, you knew roughly where it came from. You knew the institution. The editor. The process. The constraints. The reputational risk. Today the pipeline looks more like… fog.
Someone posts a thread. Someone screenshots it. Someone rewrites it as a newsletter. Someone paraphrases it as a blog. Someone feeds it to a language model. Someone else copies the result into a LinkedIn post. Ten thousand people read the final version. Almost nobody knows where the first sentence was born.
After sitting with that for a while, one thought kept coming back.
What if writing needed receipts too? Not censorship. Not watermarking.
Not some anxious system trying to guess whether a paragraph “sounds AI.” Just a way for writers to leave a trace at the moment of creation. A timestamp.
A fingerprint.
A small piece of proof that says:
This existed here, at this time.
That idea stuck with me longer than I expected. Eventually, I decided to test it. And that’s what Scripli is.
Scripli is simply testing a very unglamorous idea: when you write something, the system captures the process of writing — not the text itself. No content is stored. Nothing is read. Just signals from how the writing happened.
From that, it generates a small, verifiable record that a real writing session took place, at a specific time. Later, if questions come up — whether something was written by you, whether it existed before — you have something to point to. Not a guess. Not a probability score. A record. In other words: provenance. The same idea people discuss for images. But applied to writing — and grounded in the process, not the output.
At first glance, this sounds like plagiarism detection.
It isn’t.
Plagiarism tools are built to catch wrongdoing. They compare text. They look for overlaps. They make judgments. Scripli doesn’t do that. It doesn’t analyze your writing. It doesn’t try to decide anything. It just records that a writing event happened — and seals that record so it can’t be altered later.
Why does this matter? Because the internet is entering a new phase. We have more writing than ever. And less memory about where it came from. Ideas move faster than authors. Paragraphs detach from their origins and start living independent lives. Someone reads something that resonates and asks:
“Who wrote this?”
The answer is often unclear. Or worse — confidently wrong. The default response is to build better detectors. People love detectors. Systems that scan text and declare whether it was written by a human. Systems that promise certainty. But all of them share the same limitation.
They are guessing.
Even when they are right, they are still guessing. Scripli takes a much less exciting approach. Stop guessing. Start recording.
The more I’ve worked on this, the more something has become clear to me.
The hard part isn’t technical. Capturing writing signals is doable. Generating certificates is doable. Even verification is fairly straightforward.
What’s actually difficult is the cultural side of it. Receipts only matter if people decide they matter. If writers treat provenance as normal — the way photographers eventually accepted metadata — then something like this becomes useful.
If nobody cares, it becomes an empty archive.
And technology doesn’t decide that.
Habits do.
And that leads to the real question behind all of this: will the internet rebuild a memory for authorship? Or will everything slowly dissolve into anonymous streams of text — generated, remixed, and redistributed faster than anyone can trace?
I don’t know.
Scripli is just a way of measking that question out loud. It’s the same idea, applied to writing. Small. Imperfect. Probably incomplete. But interesting enough to try. Because right now, the internet has a new problem.
It remembers everything.
Except where things started.
And that might be the one memory we need most.