Bobble: my first go at a second brain

My first second brain was called Bobble. I started it on Wednesday 1 October 2025 and, as of this week, I've decided it has gone as far as it can go.

It has 248 commits (saved changes, each with a note of what changed) across five months. It ran my week, coached me through some hard days, sorted household admin and remembered things I'd have forgotten. It also taught me most of what I now know about how these setups fail.

This is an honest account of what Bobble was, what worked, and the wall it hit on 13 February.

Five assistants and a Notion export

The first commit was called "Agent vault foundation". It held five assistants I'd been using in Claude's desktop app (a personal coach, an AI development coach, a communications coach, a jobs-to-be-done coach and a prompt optimiser), plus an export of my Notion workspace and some templates for logging sessions.

The idea was simple. Instead of starting every conversation from scratch, keep the context in files the AI can read. Who I am, what I'm working on, what I've decided. Then move it all from the desktop app to Claude Code, which can read and write files on my laptop directly.

A week later, on 8 October, I moved to Claude Code's own agents system. The next day I restructured the main assistant using a format I'd picked up from a friend, Joshua: every instruction file broken into labelled sections, such as PERSONA, GOAL, CONTEXT, TOOL_USE and PROCESS. That format has stuck. Every instruction file I've written since uses it.

Fourteen days of logins

The next fortnight was the least glamorous part, and the part I'd warn anyone about. From 10 to 24 October most of my commits were about connecting tools: Gmail, Google Drive, Calendar, Todoist and Outlook.

Each one needed an MCP server (a small connector that lets the AI use another app) and most needed OAuth (the "sign in with Google" permission screen). I wrote step-by-step guides as I went, because Google's console kept changing under me. One commit on 10 October is titled "fix: update OAuth consent screen steps for new Google Cloud Console UI". There's another warning about asking for more permissions than you need.

By 24 October all five services were working. I wrote the whole thing up as a 14-day milestone and moved on. Looking back, the main lesson was that connecting things isn't the hard part of a second brain, even though it feels like it at the time. It's just the first part.

The pivot to an operating system

On 10 November I stopped and rethought the whole thing. The commit is titled "architectural pivot to personal operating system", and the reasoning in it still holds up:

• I'd started with live data (calendar and tasks) before the foundations (my career, my goals, what I actually do).
• I'd organised the folder for me to browse, when the main reader was the AI.
• I'd been treating it as a knowledge base, when what I wanted was something that acted on what it knew.

The next day the folder was renamed Bobble and became the single front door: I talk to Bobble, Bobble routes to the right specialist. The main instruction file went from 622 lines to 151. I pulled my career history from two CVs rather than a LinkedIn export, because the LinkedIn version was millions of tokens (the units AI models read in) and the CVs were a fraction of that.

Dan Hopwood's six files

On 15 November I made the change that defined Bobble's memory. Dan Hopwood had shared the setup he used in production, and I rebuilt Bobble's memory around his six-file pattern:

• activeContext: what I'm working on right now
• strategicContext: the bigger goals
• progress: a history of sessions
• systemPatterns: lessons learned
• backlog: ideas waiting their turn
• planning: multi-session projects

The principle at the top of the instructions was "You are stateless - memory bank is source of truth." In plain English: the AI remembers nothing between conversations, so these files are its memory. The same day I cut the folder down hard. One commit removed 303 files and 32,595 lines.

It was a big improvement. Each session started by reading the six files, and the AI knew where I'd left off. On 26 November I narrowed Bobble's job to personal life only (family, health, personal growth, volunteering) and moved business work to a separate project. The backlog dropped from 744 lines to 182.

Rules the AI can't skip

Through November and early December I kept writing guardrails: rules for how the AI should behave. Check the actual date before writing anything time-sensitive. Read a file before editing it. Commit after significant work. Be 95% confident before acting.

They kept being ignored. Not maliciously. A long instruction file is a lot to hold in mind, and the rules near the bottom quietly lose out.

On 7 December I moved every rule I could check mechanically into hooks (small scripts that run automatically before or after the AI does something). Two of them block the action outright: the AI can't edit a file it hasn't read in that session, and it can't write anything until it has run the date command. Others just remind. The commit note says "determinism over hope", and that phrase has stayed with me.

Some rules can't be hooked. Whether the writing is British English, whether the AI has genuinely thought something through, whether it's 95% sure. Those stayed as instructions, and they're still the ones that slip.

Three days later I learned two limits the hard way. I'd declared one hook "permanently fixed" after solving one way it failed, and missed that it blocked its own recovery path. And I found that hooks which run when a session ends can't stop the session ending, whatever they report. Both went into the lessons file.

What it was good at

I don't want this to read as a list of failures, because Bobble earned its keep.

The performance coach was the part I used most. Morning check-ins, evening wind-downs, energy scores out of ten, a quick read of my tasks and messages, and an honest steer on the day. On 5 December I ran my first coaching session from my phone using an app called Happy. Being able to do that from anywhere changed how often I used it.

It also did a lot of practical research. Purchases with a 95% confidence rule before recommending anything. A ski trip worked up in one afternoon. A surf log that wrote each session into Notion. On 10 February I ran a big upgrade: 56 stories (small, testable pieces of work) in one day, which turned the old playbooks into 28 reusable skills and put seven hooks in place. Every story passed.

The wall on 13 February

On Friday 13 February I tested a new coaching assistant on a server I'd been setting up, so I could reach Bobble when my laptop was closed. The session started the normal way: read the memory files, gather live context from my tools, load the skill.

Before I'd asked a single question, 46% of the AI's working memory (its context window, the amount of text it can hold at once) was already used.

The commit that night lists the causes. The lessons file was 940 lines. The strategy file was 545. The backlog was 508. On top of that, the start-up routine pulled in tasks and messages from my tools, and two skills loaded at once. The target I wrote down was under 20%.

This is the key point of the whole five months. The six-file pattern was a good shape. The problem was that every file only ever grew. Every session added a lesson, a backlog item, a progress note. Nothing ever left. I'd pruned before (303 files in November), and the growth came back. Pruning treats the symptom. The cause is that the structure has no idea what's current and what's history.

What I'm doing about it

My next build will go into MetaNova, a separate project I started on 21 December. Before I write a line of it, I've written down what the next memory design has to do differently, because the six-file shape on its own isn't enough:

• Load only what the task needs. A short top-level file, with each area of life or work carrying its own instructions that load only when that area comes up. A coaching check-in shouldn't drag in my business backlog.
• Add records rather than rewriting documents. Decisions, lessons and progress kept as dated entries, one per line, so the AI can read the recent ones and leave the history alone until it's needed.
• Keep the start-up small and measured. Under 20% of working memory before the first question, checked rather than hoped for.

I'm not deleting Bobble. It still runs my personal side for now, and the coach in particular will carry over. But the memory design behind it has reached its limit, and I'd rather start the next one knowing why.

If you're building your own

If you're setting up an AI assistant with your own notes, here's what I'd do from day one, based on these five months.

1. Write for the AI, not for you. Decide that the main reader of the folder is the assistant, and organise it the way it needs to find things.
2. Start with foundations, not feeds. Who you are, what you do and what you're aiming for come before calendars and inboxes.
3. Watch how much the start-up costs. Ask the AI how much of its working memory is used before your first question. If it's heading past a fifth, something is growing that shouldn't be.
4. Give every file a way to shrink. If a file only ever gets added to, it will eventually crowd out everything else. Separate what's current from what's history.
5. Hook the rules you can check. If a rule can be checked by a simple script, make it a script. Keep instructions for the judgement calls.

If you've hit a similar wall with your own setup, I'm happy to compare notes.