For five months I typed the same request at the end of marathon sessions: “give me a savepoint.” The word showed up in twenty-plus conversations before it ever became a system. The name came from saving video games as a kid. Same instinct: you’re about to lose your progress, so you save your state before the session ends.

The reflex existed before the protocol. The protocol just formalized what I was already doing. That’s punk infrastructure: you build what you need because the existing tools don’t provide it, and the thing you build is rough and functional and solves one specific problem that nobody else has bothered to solve.

The first version failed immediately. v1.0 was YAML frontmatter: loose, reflective, and it stripped out the concrete content it was supposed to preserve. The protocol reproduced the exact loss it was built to prevent. I was writing paragraphs of journaling instead of capturing the decision. The format was too open. It drifted into narrative and lost the turning point.

v2.0 used triple-pipe attributes. Still too verbose. You could write paragraphs in the content block, and I did, and the paragraphs were the problem. The format allowed the same failure mode in different syntax.

v3.0 came from a front-end instinct: CSS selectors and HTML attributes, applied to thought. A self-closing tag. Atomic. One line of content. One moment captured. If you can’t say it in one line, it probably wasn’t a savepoint. It was a note.

That constraint is the punk move. A savepoint is not a note. Notes capture information. Savepoints mark inflection. The moment thinking changed shape. If you can write it without stopping, it probably wasn’t a turning point.

The word “punk” is deliberate. This protocol wasn’t designed in a research lab. It was built in the middle of work that was actively failing. I was losing my thinking across sessions. The tools stored everything that was said. Nothing marked where the thinking turned. So I built a markup language for cognitive turning points using whatever I had: conversation transcripts, version control, the same structural thinking I use on everything else.

It’s punk because nobody asked for it. The tools don’t provide it because the tools don’t think about the problem. AI platforms store conversations. They don’t mark where understanding shifts. Note-taking apps store notes. They don’t distinguish between information and inflection. The gap was invisible until I’d lost enough thinking to notice the pattern.

The Savepoint Protocol went through three versions, each one failing in a way that taught me what the constraint actually needed to be. The v1 failure (the format reproduced the loss it was built to prevent) was the most important. It proved that the problem wasn’t forgetting. The problem was that unstructured capture drifts toward narrative, and narrative buries the turning point instead of marking it.

Sixty thousand documents of ideation history later, the savepoints are the trail system through the archive. I can search across three years of conversations and find the exact moment a decision locked in. The exact session where the plate metaphor crystallized. The exact conversation where I realized the first version was failing.

That’s infrastructure. Built by hand, from necessity, in the middle of the work. The same way I built the kitchen systems, the CLAUDE.md governance, the voice protocol. Each one started as a reflex. Each one became a protocol when the reflex proved it solved something real.