My Second Brain: How I Use Obsidian, Why I Left Roam, and the Getting Things Done Setup Underneath It

I have been running some version of a second brain since 2020. It moved from Roam Research to Obsidian, and the system has gotten more complex over time. The system now holds my daily notes, my task lists (using David Allen's Getting Things Done framework), birthday reminders, meeting notes, and a Kanban-like board for the projects I am shipping (uristocrat.com, skills.uristocrat.com, mixtape.uristocrat.com).

This is the long version of how it works, what I learned from each tool, and how I think about notes, ideas, and projects.

Why I left Roam (and why I am still a believer)

Roam was the first tool that made my brain feel like an external entity. Block-level references, the daily notes pane, the bidirectional linking, and the way a single bullet could live in five places at once without duplication. Roam taught me that the unit of a note is not the page, it is the block.

What I still believe about Roam:

• The block is the primitive. The pages are too coarse.
• Daily notes are the front door. Everything starts today.
• Bidirectional links beat folders for connected thinking.
• The graph is a side effect of good linking, not the goal.

What pushed me to migrate to Obsidian:

• Markdown files. Obsidian notes are plain .md files on disk. Roam notes live in their database, in their format.
• My Obsidian vault is hosted locally and in Obsidian's sync, so I get the local-files guarantee and cross-device sync at the same time.
• Obsidian is more performant on mobile. Roam on my phone was slow enough that capture friction became real.

Obsidian is a markdown editor on top of a folder of .md files. The vault sits on my machine and thus every note is a plain text file. Every link is a wiki-style link [[link]] that resolves to a file in the same folder structure. If Obsidian disappeared tomorrow, I would lose the UI and keep every note.

The shift from Roam to Obsidian was a tradeoff:

• Lost: native block references, the unified daily notes pane, and the cleaner inline editing.
• Gained: local files, faster everything, plugin ecosystem when I want it, and now the vault is readable and writable by any tool I point at the folder, including LLMs like OpenRouter, Claude, and Codex without needing an MCP.

My folder structure

Here is what is actually at the root of my vault:

edakrong/
├── daily-notes/        ← one file per day, YYYY-MM-DD.md
├── GTD/                ← the system, not the data
├── eng-dev/            ← product building board
├── notes/              ← everything else
│   ├── posts/          ← blog drafts (this file lives here)
│   ├── ideas/          ← raw ideas
│   ├── brainstorms/    ← longer thinking sessions
│   ├── meeting-notes/  ← granola exports and meeting captures
│   ├── readwise/       ← book and article highlights
│   ├── journal/        ← personal
│   └── ...
├── Roam/               ← my full Roam export, frozen in time
└── Templates/          ← note templates

A few things to notice:

• There is no archive folder. Old notes stay where they are. Search finds them.
• The Roam/ folder is the full export from when I migrated. I still link to it. It is part of the vault.
• notes/ is one folder deep, then mostly flat.

The daily note is the front door

Every morning, I open today's daily note at daily-notes/2026-05-20.md. That is the only file I open by hand most days. Everything else gets reached through links or search.

The daily note has a fixed structure:

# My Objectives
# This Week's Plan
# Today's Tasks and Schedule
## Personal
## Chores
## Edwin Inc
## Longer Term
# My Notes
# Morning Check-in and Evening Review

The same template carries forward day to day. Tasks live under the right life area, never in a generic to-do list. Captured thoughts during the day go under ## My Notes. The evening review section is where I close the day.

GTD: capture, clarify, organize, reflect, engage

I run a Getting Things Done loop on top of the daily note. The five GTD steps map cleanly:

• Capture happens in the daily note's ## My Notes section, or in notes/inbox/ if it is bigger than a sentence.
• Clarify is a step I do with Claude Code (more on this below). The question is always: is this actionable, and if so, what is the next physical action?
• Organize means moving the clarified item to the right place. A task lands under the right life area heading. An idea moves to notes/ideas/. A reference moves to the right notes subfolder.
• Reflect is the weekly review I run every Sunday. I open the last seven daily notes, scan what got done, what slipped, and what I learned.
• Engage is the actual work, which is the part GTD content writers always skip.

What makes this version of GTD work is that the system has no inbox to triage in a separate app. The inbox is the daily note. The reference filing is the same folder I write in. The "next actions list" is just the tasks section in today's note. There is no context switch between capture and execution.

The eng-dev setup: a kanban for projects, in folders

I build and ship software. So I needed something between "a note" and "a Jira ticket." What I landed on is a folder-based kanban inside the vault.

eng-dev/
├── inbox/         ← raw project ideas
├── approved/      ← decided to build, not started
├── planned/       ← scoped, ready to start
├── in-flight/     ← active work
├── on-hold/       ← paused, with a reason
├── done/          ← shipped
└── roadmap/       ← longer arcs

Each project is one markdown file. Moving a project across the board is mv. That is the entire workflow.

A project note has roughly this shape:

• What I am building and why
• The next physical action
• Decisions made (and the reasoning)
• Open questions
• Links to related notes, code, PRs

I do not use Linear, Jira, Notion, or GitHub Projects for personal work. For my own stack (Uristocrat, Uristocrat-watch, Uristocrat-arb, this blog), the markdown kanban is enough. The reason it works: Claude Code can read the board, write to it, and reason about it. The same agent that helps me think about a project can move it to done/ when we ship.

Notes are the wiki: giving the AI a memory between sessions

AI assistants forget everything between sessions. Every conversation starts from zero. If you have complex projects, a rich personal context, and specific preferences, you are stuck re-explaining yourself, or you get generic responses that miss the point.

My fix is that the notes/ folder is not a dumping ground. It is a wiki. A set of durable pages on the topics I care about that any AI can read at the start of a session. The AI does not just read the wiki, it incrementally builds and maintains it. The pages get richer with every session and every source I add.

Most second-brain advice treats every captured thought the same way. Mine has three buckets and the distinction matters:

• Notes are the wiki. Durable pages on the topics I keep coming back to: my holdco thesis, my acquisition target criteria, my deal scoring framework, my views on operator edge, the open-source AI stack I am betting on, the people in my life. There is an index.md that lists what exists and a log.md that records what got added or changed and why. Notes are flat, searchable, and the AI updates them as a side effect of normal work.
• Ideas are seeds. A one-liner that might become a business, a post, a feature. They live in notes/ideas/. Most of them die there, which is the point. The bucket exists so I do not lose the seed, and so I do not act on it too early. When an idea survives a few weeks of staring at it, I run it through my idea validation skill, and if it passes, it becomes a project.
• Brainstorms are longer thinking sessions. A brainstorm is what happens when I sit with one question for an hour and write through it. They live in notes/brainstorms/. They are not for sharing. They are for me to think out loud and end up somewhere I could not have gotten to in my head.

The reason for keeping these separate: each has a different decay rate. Wiki notes are permanent and get more accurate over time. Ideas are perishable. Brainstorms are time capsules.

Here is how the wiki loop actually runs:

1. I read something worth keeping. A meeting transcript from Granola, a Readwise highlight, a brainstorm, a link.
2. I run my wiki-ingest skill against the source.
3. The skill reads the source, finds the relevant existing wiki pages, and updates them. It does not create a new page for every input. It folds the new insight into the page where it belongs and notes the update in log.md.
4. The next time I open a session with any AI, it reads the wiki first. The context I had two months ago is the context the AI has today.

Why this works:

• The wiki is a small set of durable topics, not a journal. A journal grows forever and gets unreadable. A wiki has fixed pages that get more accurate over time.
• The AI maintains it, not me. Hand-curated knowledge bases die. This one stays alive because the agent does the upkeep as a side effect of how I already work.
• It lives in the same vault as everything else. The agent can cross-reference a wiki page against my project board, my daily note, my Readwise highlights, all in one folder.
• Any AI can read it. Because it is just markdown, I can point Claude, OpenRouter, or Codex at the folder and it works. The wiki is not locked to a single vendor.

This is the missing layer between "the AI remembers nothing" and "the AI is trained on my whole life." A few hundred markdown files of opinionated, current context is enough to make every session feel like a continuation of the last one.

The unlock: Claude Code can read and write to my vault

The single biggest change in the last year is that my vault is now an agent surface. I run Claude Code pointed at the vault folder. It reads my daily note, my project board, my GTD setup, my ideas folder, and the wiki. It writes back into the same files.

What this looks like in practice:

• I say, "Capture this idea about a night nurse placement business." Claude writes a properly structured idea note, links it to related notes, and updates the daily note.
• I say "morning brief." Claude reads my email inbox dump, the daily note template, and last week's review, and proposes one top goal and the tasks under each life area.
• I say, "What's on the board right now?" Claude reads eng-dev/in-flight/ and tells me where each project stands.
• I drop in a meeting transcript and Claude folds the new context into the right wiki pages without me asking which ones.

I do this through Claude Code skills, which are reusable prompts that live in .claude/ inside the vault. Some I wrote, some are community ones. The point is that the vault and the agent are now one system.

In the past, I spent time "building a second brain," which was actually building a procrastination machine. Tagging. Coloring. Migrating. Re-organizing. The goal is not the system. The goal is to capture, think, and ship. With this new approach, I am able to focus on what needs to be done rather than on what could be done.