Your second brain with Claude Code + Obsidian

I talk to an AI agent every day. The problem with every AI agent I’ve ever used is that each new conversation starts from zero — no memory of what we worked on yesterday, no context about my life or my business, no record of the decisions we already made. This is the setup I built to fix that. A second brain in Obsidian, an agent in Claude Code, and a set of hooks that quietly keep them in sync. Every session starts smart.

The problem this solves

Most people’s experience with AI goes like this: you have a great conversation with ChatGPT or Claude on a Tuesday. You work through something hard together — a strategy, a decision, a draft of something. By Friday, you remember the conclusion but not the details. You open a new chat to ask a follow-up question, and the AI has no idea who you are, what you’re working on, or what you agreed to on Tuesday. You have to re-explain everything. Every. Single. Time.

That’s not a bug in the AI. It’s how the technology works. Chat conversations are stateless. When you close the tab, the context is gone. The model has no permanent memory of you.

Which means the burden of memory falls entirely on you. You have to remember what you told it. You have to re-load the context every time you want to continue. And you slowly learn to stop asking follow-up questions at all, because re-explaining is annoying enough that it kills the follow-up. You leave enormous amounts of value on the table.

A second brain fixes this. The idea is simple: you keep a structured folder of notes on your own computer that holds your context — who you are, what you’re working on, what you’ve decided, who the players are, what happened last session — and the agent reads from and writes to that folder automatically. The memory stops living inside the AI and starts living in your files, which are permanent. You stop re-explaining. The conversation becomes continuous, even across days and weeks and months.

That’s what this workflow does, and honestly it’s the single most valuable habit I’ve built for my own work this year.

The stack

The setup is deliberately boring, because boring is sustainable.

• Obsidian — a free Markdown note-taking app that keeps your notes as plain .md files on your computer. No cloud lock-in, no proprietary format, no subscription required. If Obsidian ever shuts down, your notes are still just a folder of text files you can open in any editor.
• The vault — a folder on your computer that contains all of your Obsidian notes. Mine lives under a OneDrive folder for automatic backup and syncing between my PC and phone.
• Claude Code — the AI coding agent that can read and write files in that folder.
• Hooks — small scripts that run automatically at the beginning and end of every Claude Code session, injecting my vault’s current context at the start and saving a summary at the end.
• A CLAUDE.md file at the root of my home directory — a long Markdown document that tells the agent how I work, what to remember, what to do at the start of every session, and what conventions to follow.

That’s the whole stack. No database, no vector store, no fancy embeddings. Plain text files and a few hundred lines of glue scripting.

The shape of the vault

The vault is organized to match how I actually think about my life, not how a developer would organize a project.

• AI/ — the shared brain. CONTEXT.md is a living one-pager about me, my businesses, my goals, and the people in my orbit. Open Loops.md is my pending-work dashboard: critical blockers, active sprints, content roadmap, technical fixes, things parked for later.
• Daily/ — one note per day, automatically created by a hook at the end of every Claude Code session. Contains what I worked on, decisions I made, and captures from the day.
• Business/ — project notes, strategy documents, voice guides, client intel. Anything with a longer shelf life than a daily.
• Personal/ — life planning, ideas, habits, apartment details, travel, running, reading.
• Inbox/ — quick captures I haven’t filed yet. Things I thought of in the shower. Things I want to come back to. Things I don’t know where to put.
• Templates/ — reusable note skeletons. New project, new client, new decision.

The point of this structure is not elegance. It’s that I can tell a brand-new Claude Code session “read my context” and get an accurate snapshot of who I am and what I’m doing in about five seconds. The agent doesn’t have to guess. It has a file.

The hooks that do the magic

Claude Code supports a concept called hooks: small scripts that run automatically at specific events during a session. I use three of them to keep the second brain and the agent in sync.

Session-start hook

When I open a fresh Claude Code session, a hook runs that reads my vault’s CONTEXT.md and Open Loops.md and injects the content into the conversation as context. The agent sees it before my first message. By the time I type anything, it already knows I live in Vancouver, what my businesses are, what I’m actively working on, and which projects are blocked.

The effect is uncanny the first time you feel it. I open a new session, say “what should I work on today?”, and the agent answers with real specificity — it knows my sprint, it knows the blocking items, it knows what I shipped yesterday. There’s no warm-up conversation. Every session starts hot.

Session-end hook

At the end of a session, another hook runs. It appends a one-line summary of what we did to today’s daily note (Daily/YYYY-MM-DD.md), creating the file if it doesn’t exist. This means I have, for free and without any discipline on my part, a searchable journal of every Claude Code session I’ve ever run. “When did we set up the intake form?” is now a one-line grep, not a memory task.

Post-tool-use hook

After every tool use (every file read, every edit, every command), a third hook runs that saves an observation about what happened into a local memory database. The next time I ask a question like “how did we solve X last time?”, the agent has a searchable record of the steps — not just the summary.

The three hooks together mean that every session automatically contributes to the vault. Memory isn’t a thing I have to remember to save. It saves itself.

CLAUDE.md: the instructions the agent reads first

The other half of the setup is a single file called CLAUDE.md, parked at the root of my user directory, that Claude Code reads at the start of every session before anything else. Think of it as a standing briefing for the agent.

Mine contains things like:

• Where my vault lives, and the filesystem path
• The session-start protocol: read CONTEXT, read Open Loops, surface relevant items proactively
• How I want work tracked mid-session: update checkboxes in Open Loops and in the source note simultaneously
• How I want work saved at the end of a session: daily note, context update, open loops trim
• My voice guide location and the rule to read it before writing any user-facing copy
• A list of tools and conventions: how I commit, which phrases to never use, how to format wiki-links between notes
• Security rules: scan skills before running them, explain the intent of any system-modifying command before running it

It’s a long file, and that’s the point. It encodes a year’s worth of “the last time we did this, it went badly” into durable instructions that every future session inherits. When I notice I’ve had to correct the agent twice for the same thing, I add a line to CLAUDE.md and I never have to correct it a third time.

This is the single highest-ROI habit in the whole setup: every time you correct the agent, ask yourself whether the correction should become a permanent rule. If yes, write it into CLAUDE.md. A week later, your agent has learned to stop making the mistake entirely.

What a real session feels like

Let me walk you through a morning, concretely.

I open Claude Code in the terminal. The session-start hook fires — I see nothing, but the agent now has my full vault context in its first message. I type “good morning. what’s on the critical list this week?”

The agent answers with the actual top-three critical items from my Open Loops dashboard — not generic advice, but my real blocking work: verify a DNS record in Resend, pick the first Workflows anchor post topic, push a driver fix I’ve been avoiding. It asks if any of them are more urgent than what I came in for.

I tell it which one I’m attacking. It opens the relevant source note to load the full context of that item, without me having to explain anything. We work on it together for an hour. When we’re done, I say “save and close.”

The session-end hook fires. The daily note gets a one-line entry: “09:14 — Resent the DNS verification records, Resend dashboard now shows two of four green. Still waiting on DKIM.” Open Loops gets updated: that critical item is now annotated with the partial progress. The vault now holds the state of my morning in a form I can pick up again tomorrow or next week.

When I come back the next morning and open a new session, the agent already knows the DNS records are partially verified. I don’t have to re-explain. We pick up where we left off.

That’s the feeling. It’s small and quiet and it changes everything about how I work.

Prompts and patterns I run

The morning check-in

Good morning. What’s on the critical list this week? Anything blocking that I should know about before I pick my target for today?

Why: it uses the Open Loops structure to surface blockers instead of me having to remember them. The active reminder is a feature for anyone with more than one project.

The pick-up-where-we-left-off

Yesterday we were working on [project]. Read the relevant notes in the vault and summarize where we left off — last decision made, next action, anything waiting on me.

Why: it forces the agent to actually read the source notes, not pretend. “Last decision, next action, waiting on” is a clean three-part summary that usually surfaces the thing I’d have forgotten.

The decision capture

We just decided [X]. Save that as a decision note in Business/Decisions/. Include: the decision, the alternatives we considered, why we picked this one, what would cause us to revisit. Link it to the project note.

Why: decisions that don’t get written down get rediscovered six months later under a new name. Capturing them — including the alternatives and the trigger for revisiting — is the single most valuable thing you can do with an AI second brain.

The weekly retro

Read this week’s daily notes in the vault. Write a one-paragraph summary of what I worked on, what shipped, what stalled, and what I’ve been avoiding.

Why: the daily notes are where the observation data lives, but they’re noisy. The agent does the pattern-matching for you. “What I’ve been avoiding” is the part that matters most and the part I’d never write on my own.

What breaks

The vault gets messy

If you don’t tend the vault — if you let the Inbox fill up, let orphan notes pile up, let the Open Loops list get stale — the agent reads a mess and gives you mess-shaped answers. The fix: do a fifteen-minute vault audit every week or two. Trim completed items, file inbox captures, merge duplicates. You’d do this for a physical office; do it for the vault too.

Sync across devices

If you keep the vault in OneDrive or Dropbox for device syncing (I do), you’ll occasionally hit sync conflicts — especially if you’re writing from both your PC and phone. The fix: check for conflict files after long editing sessions, and treat the desktop as the canonical source. My phone adds captures to the Inbox; my desktop does the heavy work.

The agent trusts the vault too much

If your CONTEXT.md says “Project X is active” and the reality is that X got killed last week, the agent will keep giving you advice about X. The fix: when you change direction, update the vault first. The agent is only as correct as the files it reads. Treat CONTEXT updates as the last step of any decision you make.

The hooks fail silently

A badly written hook can crash without any visible error, and you won’t notice until you realize your daily notes haven’t been created in a week. The fix: check once a month. Open the Daily folder. If there are gaps, something’s broken. I’ve had two hook failures this year and both were caught by noticing the daily folder had a hole in it.

Your turn: a minimal starting vault

Don’t try to rebuild my whole setup on day one. That’s how people bounce off this idea. Start with the smallest possible vault that still works.

1. Install Obsidian (free, about five minutes).
2. Create a vault in a folder somewhere sensible on your computer. Call it whatever.
3. Create one file: CONTEXT.md. Write ten lines about yourself. Your name, where you live, what you do, your active projects, your current big goal, who the important people in your orbit are. Ten lines. Twenty max.
4. Create one more file: Open Loops.md. List the five to ten things you’re actively trying to do. A mix of work and personal is fine. One per line.
5. Open Claude Code in a terminal window at that folder. Say “read CONTEXT.md and Open Loops.md, then tell me what you think I should prioritize this week.” Read the answer. Notice how much better it feels than a cold chat.
6. Every day for a week, update Open Loops.md at the end of your session. Just three lines: what you worked on, what you shipped, what got stuck. You don’t need the fancy hooks to get value — manual updates work fine at the start.

Once you feel the difference — usually by day three or four — you’ll want the hooks, the daily folder, the voice guide, the CLAUDE.md, the whole thing. At that point, come back to this post and build the full stack. But start small. The minimum viable second brain is two files and ten minutes.

Next workflow

Planning with your second brain

→