Building Your Second Brain, Part 5: The Capture Loop
Every post in this series so far assumes you already have an idea worth writing about. The spec has to spec something. The editorial loop has to edit something.
The series so far, a piece at a time:
- Making Your Second Brain AI-Compatible: the migration out of OneNote into markdown, front matter and wikilinks, so Claude could read the vault at all.
- When AI Moves In: routing tables, search tools and CLI scripts, so AI could operate inside the vault instead of just reading it.
- The Spec That Wrote This Post: planning a post before a word of it gets written.
- The Editorial Loop: an adversarial reviewer that strips the AI tells out of a draft.
- The Capture Loop: this one.
This post is the origin story, where the input comes from.
The Idea Problem
Ideas don’t arrive on schedule. They show up in the shower, in the middle of a meeting, while reading something completely unrelated to what you’re supposed to be doing. And they leave just as fast. By the time you’re back at your desk with a free moment, the idea that felt sharp an hour ago is gone.
Most of my good ideas used to die that way. They weren’t bad, I just had nowhere to put them the second they appeared.
So the first job is catching the idea before it evaporates.
Ubiquitous Capture
My inbox is the daily note. One file per day, named for the date, 2026-07-14.md, sitting in the vault root. Anything that crosses my mind goes into it the moment it happens, half-formed and badly worded. No structure, no folders, no deciding where it belongs. The only rule is zero friction, because friction is what kills capture.
Most of it gets dictated. I use Wispr Flow and just talk, usually while walking, and the text lands in the daily note. The phone runs GitSync, which commits and pushes the whole vault folder on its own, when I close Obsidian or on a schedule, so a thought I dictate on a trail is already waiting in the repo by the time I sit down and pull.
Dump the whole chain of thought, not just the idea. The conclusion on its own is useless three weeks later, because the reasoning that got me there is exactly what I can’t reconstruct. So I ramble. I say why it occurred to me, what it reminded me of, which part I’m unsure about, what it might connect to. It’s embarrassing to read back, and it’s the most valuable thing in the capture, because months later that ramble is the only record of how I was actually thinking.
The reason this works is background thinking. You catch a rough thought, then you go back to living your life, and your brain keeps chewing on it without you. A few hours later a second piece shows up, then a connection to something you read last week. Those go into the same daily note. The idea gets richer while you’re doing the dishes.
This is the one advantage we still have over the models. AI has no shower, no walk, no idle stretch where connections form on their own between unrelated fields. I wrote a post about that. Capture is how you cash in on it, you offload the remembering to a file so your brain is free to keep making the connections it’s actually good at.
By the end of a week the daily notes hold a pile of raw material. Some of it is gold, most of it is noise, and none of it is sorted. That’s where the processing comes in, and it’s where almost every “second brain” setup I’ve seen goes wrong.
The Clarification Standard: What Everyone Else Gets Wrong
I’ve read a lot of the Claude + Obsidian setups going around. Most process the inbox by sorting: read the items, decide which folder each one belongs in, move it there. Some ship it as a skill, some as a prompt, some as a CLAUDE.md workflow, but the shape is the same: sort the notes, empty the inbox. A few go further and run a real clarify step, asking what the item is before it moves.
Almost none of them search what you already wrote before filing it.
That’s the step that changes the outcome, because an idea only means something against what’s already in your head. Route an item without checking the destination and you’ve just relocated the problem. The idea is now sitting in a someday-maybe folder, which in GTD is the incubation list for things you might do but aren’t committing to now, the one you’re supposed to re-read at every weekly review. Skip that review and it’s exactly as dead as it was in the daily note, except now it looks handled.
The fix I use is the GTD two-minute rule, bent for knowledge work. The original is about doing: if a task takes less than two minutes, do it now instead of tracking it. Mine is about understanding first, before an item leaves the inbox I spend up to two minutes working out what it actually is. Then the original rule still applies on top, if whatever falls out of that takes less than two minutes, I do it right there instead of writing it down for later.
Understanding means three questions, in order:
- Does the destination already cover this? Search the vault first. More of my captures than you’d expect turn out to be a note I already wrote down, sometimes better, months ago. If it’s a duplicate, that’s a finding, not a failure.
- What is this, really? A next action, a new angle on an existing project, a duplicate, or an open question I can’t resolve yet. Naming the type decides where it goes.
- Is there a next action to surface? If the idea implies something to do, that action gets written out explicitly so future-me doesn’t have to reconstruct it.
Each type gets a home. A next action goes on the relevant project, a new angle updates the note that already covers it. A duplicate gets merged into the original and deleted, an open question I can’t resolve yet becomes its own note that waits for more captures.
The difference shows up fast. Take a real capture of mine, dictated in June: “cognitive debt, technical debt and also taste debt/rot.” Sorted the folder way, it lands in blog-ideas as a one-liner and sits there forever. Processed with clarification, two minutes of searching turned up something I didn’t expect. The vault had plenty to say about cognitive debt, and plenty to say about taste, but the two bodies of work had never touched each other, they only ever met through index pages. The search didn’t find the note I was looking for. It proved the note didn’t exist, and that the capture was the bridge between two things I’d been circling for months. Those three concept notes got written that same day because the search is what showed they were missing, and the post came out of the gap. The only variable was whether I looked before I filed.
Git as the Safety Net
Clarification lets me be aggressive about deleting.
Once I’ve understood an item and found it’s a duplicate, or already resolved, or just not worth keeping, I delete it. No someday-maybe limbo where ideas go to look busy. I can do that without flinching because the vault is a git repo. Git is the version-control system most engineers use for code: every time you commit, it saves a snapshot of your files, and each commit carries a message where, by convention, you write down why you made the change.
The convention I follow is one idea, one commit. When I process a capture, the commit message records where it went and why, the motivation behind the idea and the decision I made about it. Deleting a duplicate writes down that I found one, with a pointer to the original.
Months later I can ask the history where something went:
git log -i --grep "taste debt" # commits whose message mentioned it
git log -S "taste debt" # commits where the text was introduced or removed
The first searches commit messages, and the -i matters more than you’d think, without it you miss every commit that capitalised the thing differently. The second is the pickaxe: it finds commits where the number of occurrences of the text changed, so I can see the exact moment a note’s text was written or deleted, and read the reasoning I left at the time. An idea I killed in March is fully recoverable in July.
Obsidian will keep old versions for you, File recovery is on by default and snapshots every few minutes. What a snapshot can’t tell you is why. It gives you the text back without the thinking, and the thinking is the only part I actually need when I come back months later. The git history is a knowledge layer of its own, every decision I made about every idea is queryable. That’s a post of its own (Part 6).
The Loop Closes
The path, capture to publication:
Capture the rough thought in the daily note → Clarify it against what already exists → Route it to a project, a concept note, or the trash → Spec it when it’s ready to become a post (Part 3) → Draft it → run the Editorial Loop (Part 4) → Publish.
The taste-debt post traced that exact path. It started as one dictated line in a daily note, got clarified into the bridge between two clusters that had never met, and got routed into three concept notes that didn’t exist before the search. It sat there for a few weeks collecting more captures, then became a spec, a draft, and a published post. I can walk back through every step in the git log because each one is a commit.
And then it feeds itself. A published post brings reader replies, a comment that disagrees, a question I didn’t answer, my own second thoughts reading it live. Those are new captures. They go back into the daily note, and the loop starts over.