Building in public You know the risk before you start.
Everyone tells you: do not build something the platform could ship.
You build it anyway, because you need it and nobody has it.
Then one Tuesday the release notes arrive.
What the months actually looked like I want to be precise about the cost, because the cost is the reason the release notes hit the way they did.
Two hours of sleep on a normal night — not one heroic week, the normal shape of the last few months.
Work during the day, build in the evening, debug until the birds started.
Weekends were the good days, because nobody interrupted.
What got built in that time: a memory layer for AI coding assistants.
It saves what was learned after a fix and reads the relevant parts back before the next task.
It runs over MCP, so it works in whatever editor you happen to open.
It survives restarts, model upgrades and switching tools.
I did not build it as a business idea.
I built it because I was tired of explaining my own four servers to an assistant every single morning.
The hour the release notes landed Anthropic shipped memory into Claude Code.
Not "context improvements", not "a longer window".
The word in the release notes was memory — the same word I had been using for months to describe the thing I was building.
I read it twice.
Then I sat there and did the arithmetic that everybody in that position does: months of evenings, the sleep, the weekends — against one line in someone else's changelog.
The thought was not complicated.
It was three words long.
Who needs mine?
If you have never had a platform ship your feature, the closest thing I can describe is finding out the thing you have been carrying uphill was already at the top.
Not that it was wrong.
That it was unnecessary.
I did not open the editor that evening.
That is the honest version.
I read the docs, I read them again, and I went to bed early for the first time in months, which is a strange way for a bad day to end.
Why the fear was rational, not dramatic It would be easy to write this as an overreaction, and it was not one.
The fear had a clear structure, and naming it is useful for anyone standing where I stood.
Distribution.
A feature inside the tool wins by default.
It is there when you install, it needs no account, it needs no configuration.
Mine needed a decision from the user.
Trust.
A memory that holds your codebase knowledge is not a small thing to hand to a stranger.
The vendor already has your code in the context window.
I had to earn what they already had.
They know their own harness.
Anything I do from the outside is a guest in someone else's house, and the house rules can change in a release.
None of those three went away, by the way.
They are still true.
This is not a story where the threat turns out to be imaginary.
The question I could not answer that night Here is where the evening actually turned, and it was not optimism.
It was a question I could not answer, which is a much better reason to keep going than hope is.
I had spent months building this thing, and I could not say — out loud, in one sentence — what it did that the vendor's version did not.
Not because there was no answer.
Because I had never needed one.
My use case was my four servers and my own forgetfulness.
I had never once asked what the thing was for beyond me.
That is a genuinely uncomfortable position: you cannot tell whether you have been made redundant, because you never described what you were in the first place.
So I did the only thing that produces an answer instead of a feeling.
I wrote a test.
The test you can run on any memory, including your own It asks one question: does a fact learned in one session come back in the next one, without help?
Teach it something only true in your world — a fact it must have stored, not one it could guess.
Then close everything, come back, and ask.
Write down what you expected before you run it.
That part matters, because a memory that returns something plausible feels like a hit until yo