I have a second brain

In A year with agents I wrote about a year of working with them. One thing came back constantly: an agent remembers nothing. Every conversation is the first one.

The first answer, an incomplete one, was the manual in each repo. A file that tells the project what it is, how it is built, what nobody touches. The agent opens a session already knowing all of that.

That settles the technical context of one project. It settles nothing else.

Everything that is not code still had nowhere to live. Ideas. Articles kept for later. Decisions taken with a client and the reasons behind them. What we worked out about a subject last week. It sat in conversations, in notes, in tabs left open for three months. Invisible to an agent, and increasingly invisible to me.

I wanted somewhere that would hold all of it. Above all, somewhere to offload: a kind of journal where I could quickly write down whatever crossed my mind, things to try, articles to keep. Somewhere that keeps everything, structures everything, and reads for me.

The reflex that does not work

My first reflex: pile it up.

One folder, every document in it, and let the AI search. That is what files dropped into ChatGPT do, or a NotebookLM, or any RAG system: for every question the model starts again from the raw sources, finds fragments, recomposes an answer. It works, to be fair.

But nothing stays. Ask a question that means cross-referencing five documents: it redoes the entire cross-reference, from nothing. The work of synthesis is never kept. Tomorrow, same question, same effort, same approximate result.

And above all: you have to know what to ask. A pile of documents waits for the right question. It never comes to find you.

The idea I copied: Karpathy's LLM Wiki

Around then, in April, my Instagram showed me nothing but AI influencers promising the earth. It is horrible. But in among the slop one trend kept coming back, the second brain, and it looked genuinely interesting. I took some random influencer's tutorial, purely to lift the links, and traced it back to the source: LLM Wiki, a text by Andrej Karpathy. A page of ideas, with no tool behind it.

The principle: rather than letting the agent rummage through the sources at every question, you have it maintain a wiki. When a source arrives, instead of indexing it, the agent reads it, extracts what matters, and folds it into a structure that already exists. It updates the pages concerned, revises the summaries, flags where the new information contradicts the old.

Knowledge is compiled once, then maintained. Not recalculated at every question.

I archived it on 14 April. We adapted it a little, and tested it straight away.

The first few days are fairly empty. I throw in links, ideas, and a series to watch, just to check my prompts are doing the job. They are: the brain creates itself a personal section, with a watchlist.

What it actually is

A repo. Markdown, nothing else.

Four levels: an inbox, active projects, long-term domains, reusable ideas. And underneath, an archive.

It looks like any note-taking setup. The structure is ordinary: everything is in the four rules.

The archive is immutable. You never edit what has entered it. You do not rename, you do not delete. It is the least intuitive rule and the most important: it separates the source from the interpretation. A summary can be wrong, be revised, get old. The source stays what it was. Without that separation the brain becomes a text you rewrite continuously, and six months later nobody knows what was actually said.

The index cannot drift. Every addition updates the index and adds a line to the log, in the same operation as the content. Not afterwards. An index kept up to date when we get round to it is wrong within three weeks, and a wrong index costs more than no index at all, because you trust it.

You search before you write. Before creating a note, you check whether the subject exists. If it does, you update it. Three notes on the same subject is worse than none: the agent finds one, often the oldest, and works from that.

Everything is linked. Every note points to its neighbours. An idea points back to the project that produced it, a project points to the ideas it helped make sense of. That is the difference between a pile of files and a memory: the path already exists when you need it.

How it actually flows

The Telegram bot we put together in an hour with Claude, right after setting the brain up. I absolutely needed to be able to drop things in from my phone. An interesting article: I send the link. An idea: I type three words. Something to do: same. In the street, in bed at night, because I often have a load of daft ideas at night. It all lands in the inbox.

Later, we process. I have kept the processing manual, on purpose. I could automate it, but it is a moment for stepping back: we process everything, we look at what can be done with it. I quite like having conversations with my brain, in fact.

The processing itself: Claude Code reads each item in full, then decides: reusable idea, project note, long-term domain, or noise. It extracts what matters, files it in the right place, links it to neighbouring notes. The original goes to the archive, dated. The index is updated. A line in the log.

Nothing magic. A skill, meaning a process written once, carried out the same way every time.

What comes back when you ask for nothing

This is where it gets fun. I drop an article without a word, the brain reads it, and if it holds a solution to a problem I have, or something touching a live project, it makes the connection and tells me. Same for a git repo, a skill worth testing. I asked nothing. That is exactly what a pile of documents will never do: it waits to be questioned.

One case that is genuinely useful day to day: meetings.

A client call. I take the transcript Gemini produced in Google Meet and drop the file in the inbox, without rereading it.

That file runs to several thousand words, and the first third is about screens and computer hardware. The part that matters is buried in the middle: the platform chosen months earlier will not hold the new scope, a decision is needed between two architectures, and an integration with a third-party tool determines everything else.

What comes out of the processing is that. The decision, the constraint forcing it, the options compared, the next actions. Filed under the client's project, linked to what already exists on it.

Months later, the question "why did we move off that platform" has an answer in writing, dated, with its reasoning. I only have to ask my agent, in my working folder: it finds it instantly.

Taking notes was never the problem, I have always done it, and automatic transcription settles it anyway. What changes everything is where they land: in the brain, next to the project's history, its state, the previous meetings. And that all of it resurfaces at the right moment, when you are handling what comes next with the client.

What it does not do yet

Everything I have just described, the brain does on its own, off in its corner. The day you take it out of there and connect it to everything else, the code, the live projects, the clients, something else happens. That is the subject of another article.

The install, the three commands and what I changed from the original method are in a separate article, for anyone wanting to set one up.

Piling up files gives you an attic. A memory is something else: files stored with rules that connect them to each other, and agents that apply those rules, day after day. The rules are mine. The work is theirs.