Every post in this series exists because of one habit: when something went wrong, or right, or surprised me in some way that mattered — I wrote it down.
Not in a diary. Not in a Notion doc I'd lose track of. In a structured memory file that every future session would automatically have access to. A persistent layer that travels with the AI across contexts, so the next session doesn't start from scratch.
That system — fifty-odd feedback files, dozens of project files, a mechanism that loads the relevant ones at the start of every session — is what made this series possible. The lessons weren't in my head waiting to be recalled. They were in the files, fully formed, because I'd written them down the day they landed.
The before state
Before the memory system, every session started with an implicit re-negotiation. What's the standard for docs? What's the commit message convention? What's the current status of this project? The AI could be told, and would follow the instruction precisely — and then, next session, it needed telling again. The rules didn't compound. They reset.
The cost isn't dramatic. It's a slow tax on every session: a few sentences of context, a re-established preference, a repeated correction. Multiply that by sixty sessions and the cost is a substantial amount of working time spent re-establishing ground truth instead of building on it.
The fix is boring but it works: write the rule down once, in a place that's always loaded. Then you never have to say it again.
What compounding actually looks like
The fifty-plus feedback rules in the memory system aren't arbitrary. Each one has an origin — a specific session where a specific thing went wrong and I decided it wasn't going to go wrong the same way twice. The documentation rule came from the session where the README wasn't there. The autonomy rule came from the session where I had to explicitly establish what fires automatically and what asks first. The version-numbering rule came from realising I couldn't tell which spec was current.
Every rule is a lesson amortised over every future session. The first time, it costs you the mistake plus the time to write the rule. Every subsequent time, it costs nothing — the rule is just there, in the context window, shaping the behaviour without any ceremony.
That's compounding. The lessons don't fade; they accumulate. The system gets better not because the AI gets better, but because the instructions it operates under get more precise, more hard-won, more specific to what you actually need.
The meta-lesson
This series is twelve posts. Each one traces back to a real moment — a broken production deploy, a document that credited the wrong AI, a strategic realisation that nine products needed to be parked. The war stories are real because the memory files are real, and the memory files are real because writing things down was the one discipline I got consistent about.
The practical advice is simple enough to fit in a paragraph: when something bites you, write a one-paragraph rule before you close the session. Include why it matters and how to apply it. Store it somewhere persistent. Let your tools load it automatically. Don't rely on remembering it.
That's the whole system. It doesn't require a sophisticated setup. It requires the habit of treating your own hard-won experience as worth preserving — which, it turns out, is not the default. The default is to move on, trust that you'll remember, and find yourself in the same situation six weeks later wondering why it feels familiar.
The AI didn't teach me this lesson. It made the lesson stick, because the written rule actually had somewhere to go. Without the memory system, a written rule is a sticky note on a monitor you'll stop seeing in three days. With it, the rule is infrastructure.
Closing the loop
Eleven lessons. One meta-lesson that contains all of them.
Write things down. Make the writing useful. Put it somewhere that travels with the work. Let it compound.
That's what sixty days of building with an AI actually taught me.
This is the final post in "What I Learned Building With Claude" — twelve lessons from sixty-odd days of AI-assisted building at Digital Vision. If one of these was useful, the one worth starting with is post 1: verify everything.