Claude has a memory now. It is genuinely useful, and I use it. But it has three properties I could not live with for the thing that holds how I work. It lives on someone else's server. It lives inside one product. And I cannot open it, read it line by line, correct a wrong fact, or carry it somewhere else.
So I built a second brain that I own outright. It is a folder of plain text files on my own disk. Claude Code is the reasoning engine that reads and writes it. Obsidian is the window I look at it through. Nothing about it is locked to a vendor, and every single thing it believes about me is a file I can open in a text editor.
This is the full build. If you want to copy it, everything you need is at the end.
What it actually is
Strip away the vocabulary and a second brain is two things: a store of what you know, and an engine that reads and updates that store while it works with you. Most people have the first without the second. A pile of notes you never reopen is a diary, not a brain. The trick is making the reasoning layer read from and write back to the store automatically, so the store gets smarter every time you use it.
My store is an Obsidian vault: about two thousand markdown files, organised into folders for daily notes, meetings, people, deals, projects, a synthesis wiki, and a multi-agent research zone. On top of it sits a separate, smaller store that is the real innovation: a file-based memory of roughly ninety notes, each holding exactly one durable fact, that Claude reads at the start of every session and writes to as it learns.
The engine is Claude Code, running in my terminal, anchored in the vault directory. When I open it there, it inherits the vault's rules, loads the memory index, and can touch any file. It is not a chat window bolted onto my notes. It lives inside them.
The five layers, from the outside in
The cortex is the vault. Everything long-term lives in a folder as plain markdown. Meetings, 793 of them, are immutable transcripts. The wiki, 215 notes, is a synthesis layer the model curates. Domain folders hold deals, people, projects, and my company work. Templates enforce a consistent shape for a new deal note, a person note, a meeting note. Obsidian itself is just the viewer, with a Dataview dashboard on the homepage. The intelligence is in the files, not the app, which is exactly why the app is replaceable.
The instincts are the instruction files. A CLAUDE.md at the top of the vault, and a global one, are loaded automatically whenever Claude Code runs there. This is where the rules live: never edit raw meeting transcripts, write the wiki in English, how the research council must format its notes. I keep the global file deliberately tiny. Anything loaded on every session dilutes the model's attention, so durable facts do not go here. They go in the memory, which is recalled only when relevant.
The hippocampus is the memory. This is the part worth copying even if you copy nothing else. In a memory folder there are about ninety files. Each one holds a single fact and carries a small frontmatter header with a name, a one-line description, and a type. The type is one of four: user (who I am), feedback (how the model should work with me), project (ongoing work), reference (a pointer to something external). A single MEMORY.md file is the index, one line per fact, and that index is the only memory thing loaded every session. When a fact becomes relevant, its full file is pulled in. Facts link to each other with wikilinks, so the memory is a graph, not a list.
The senses are the ingestion pipes. Meetings arrive on their own. A scheduled job pulls my Fireflies and Plaud recordings every thirty minutes and files them into the vault, deduplicated. Email and calendar come in through connectors when a task needs them. I do not copy-paste any of this. The brain feeds itself.
The hands are the action layer. About forty slash commands turn the brain into an operator. A morning brief that drafts my replies and a task digest. A weekly review that writes a durable note and mails me a recap. A content pipeline that researches, drafts, and publishes. Behind them sit reusable skills and a set of tool connectors for mail, automation, and databases. The same brain that remembers is the brain that acts.
The part most people miss: the memory has discipline
A memory that only ever grows is a landfill. Mine has rules, and they matter more than the structure.
Every fact is one file, so it can be corrected or deleted surgically without disturbing anything else. Before saving, the model checks whether an existing file already covers the fact and updates that one instead of creating a duplicate. A recalled memory is treated as background context that was true when it was written, not as a live instruction, so if a memory names a file or a setting, the model verifies it still exists before acting on it. And the litmus for writing anything to the always-loaded layer is brutal: keep the line only if removing it would cause a mistake this session. Everything else earns its place by being recalled on relevance, not by shouting for attention every time.
That discipline is why the thing stays sharp at ninety facts and would stay sharp at nine hundred.
Three things it does that Claude's own memory cannot
Native memory is good. For a lot of people it is enough. Here is precisely where a file-based brain pulls ahead, and why I chose the extra effort.
One. I own it, and it moves. My brain is plain files on my disk. I can put it under version control and see every change over time. I can read it from the terminal, from a script, from a different editor, or from a different model entirely. If I switch tools next year, the brain comes with me untouched, because it never belonged to the tool. Native memory belongs to one product on one company's servers. The day you leave, it stays.
Two. I can read, correct, and delete any single belief. When a fact is wrong, I open the one file that holds it and fix it, or I delete it and it is gone. I can see exactly what the brain thinks and why it recalled it, because the index and the files are right there in front of me. A hosted memory is a black box: you cannot open one specific belief, audit why it surfaced, or surgically remove it. For the store that holds how I work and who I deal with, that transparency is not a nice-to-have. It is the whole point.
Three. It has structure, links, and scale. Every fact is typed and summarised. Facts link to each other into a graph. The whole thing is searchable with ordinary tools and queryable from the notes. And more than one agent reads and writes it: my Claude sessions, the scheduled jobs, and a research council where separate models debate and record consensus into the same vault. Native memory has no schema, no links between facts, no shared multi-agent write, and no query layer. It is a smart notepad. This is a filesystem with a nervous system.
The brain, by the numbers
Build your own, in eight steps
None of this needs code. It needs a folder, a CLI, and a few conventions you actually keep.
1. Install the two pieces. Obsidian, and Claude Code as a terminal CLI. Point Obsidian at a new folder. That folder is your vault.
2. Give the vault a shape. Create folders for the things you actually track: daily notes, meetings, people, projects, and a wiki for synthesis. Do not over-design it. Folders are cheap and you will move things later.
3. Write the instruction file. Put a CLAUDE.md at the top of the vault. State the rules of the house in plain language: what is immutable, what language to write in, how you want notes formatted. Keep it short. This is loaded every time, so every line costs attention.
4. Stand up the memory folder. Create a memory directory and a single MEMORY.md index inside it. Tell the model, in your instruction file, that durable facts are saved one per file with a name, a one-line description, and a type of user, feedback, project, or reference, and that every new fact adds one line to the index.
5. Teach it the discipline. Write the rules down: one fact per file, update the existing file instead of duplicating, do not store what the notes or the code already say, treat a recalled memory as context and verify before acting on it. The rules are what keep it from becoming a landfill.
6. Connect your inputs. Wire in whatever generates your raw material: meeting transcripts, email, calendar. Automate the ingestion so the brain feeds itself instead of waiting for you to paste.
7. Add hands slowly. Write one command for a task you do every day, a morning brief or a weekly review. Let it read the brain and write back to it. Add the next command only when the first one earns its keep.
8. Correct it out loud. When it gets something wrong, tell it, and make sure the correction lands as an edited or deleted memory file, not just a reply in a chat. A brain you correct is a brain that compounds. This last habit is the one that makes it yours.
Start with the vault and the memory folder. Everything else is layers you add once the core is holding your day. The measure of a second brain is not how much it stores. It is whether it is a little sharper every week without you tending it like a garden. Mine is, and every neuron in it is a file I can open.
If I didn't write the correction into the note, it didn't happen.