Memory Ep. 1: Claude kept forgetting, so I built us a shared brain

The first thing that frustrated me about working with Claude daily was not the quality of the output. It was the amnesia.

Every new session started from zero. I had to re-explain who I was, how I liked to work, what project I was on, what we had already tried and discarded. The context was completely volatile. By the time I had re-established enough background to do something useful, I had already spent twenty minutes just rebuilding the mental state from the day before.

So I started paying more attention to how Claude actually handles memory.

CLAUDE.md

The first thing I found was CLAUDE.md. Claude Code reads it automatically at the start of every session, from your home directory and from the root of whatever project you are working in. It is the closest thing to persistent memory that exists in the default setup.

I started with a basic file. Name, role, preferences. Then I kept adding things. How I like code structured. What I do not want in responses. Context about the systems I work with.

The pattern that emerged made sense: general things in the user-level CLAUDE.md, specific things in each project. The project-level file knows about the codebase, the architecture decisions, the quirks. The user-level file knows about me.

That worked better. But it still was not enough.

The problem is that CLAUDE.md is a static document. It captures what you know at the time you write it, and then it sits there. It does not grow with the work. Every interesting conclusion we reached, every problem we dug into and finally understood, every decision with context behind it, none of that was going anywhere unless I manually updated a file.

I wanted Claude to remember the journey, not just the starting point.

The tweet

At some point I came across a tweet explaining how to connect Claude Code to Obsidian. I had never used Obsidian before. The idea was simple: give Claude access to a vault and let it read and write notes there, so information could accumulate across sessions.

I read it a few times and something clicked. This was the missing piece. Not another config file, but an actual knowledge base. A place where things could be stored with structure, linked together, and retrieved when relevant.

I started experimenting.

Going all in

My first approach was radical. I rewrote my user-level CLAUDE.md with one central rule: stop writing to memory files and CLAUDE.md updates. Everything goes to the Obsidian vault instead.

The vault became the canonical source of truth for everything Claude needed to know about me, my work, my projects, my preferences. General profile in one place. Technical preferences in another. Project notes, people, decisions, references, all with their own structure and linked together.

I also built a skill called /recap. At the end of each session, I run it and Claude goes back through everything we discussed, extracts what is worth keeping, and writes it to the vault as a daily note. Problems we found, conclusions we reached, things to follow up on. A proper diary of the work, written automatically.

The first time I ran it and then started a new session with that context loaded, the difference was immediate. Claude knew what we had been working on. It remembered the decision we had made the day before and why. It could reference a problem we had discussed a week ago without me re-explaining it from scratch.

It felt less like talking to a tool and more like working with someone who had been paying attention.

The common brain

That is the mental model I settled on. Not “my notes that Claude can read” but a shared brain. A place that belongs to both of us, where the work accumulates and neither of us has to start from zero.

The vault has grown a lot since those first experiments. The structure has changed, the rules have become more precise, the skills around it have multiplied. What started as a rough experiment is now the foundation of how I work every day.

But that is a story for another post.