Claude Code + Obsidian: A Personal Intelligence System

~15 minutes to read. ~2 hours to set up and be running well.

What This Document Is

This explains the system I’ve been using that combines Obsidian (a note-taking app) with Claude Code (an AI that runs in your terminal and can read/write files). The result is something that feels qualitatively different from chatting with ChatGPT or Claude on the web.

The Core Insight

You control the context. The AI doesn’t guess it.

Instead of:

Dumping everything into one endless chat history
Hoping the model “remembers” the right things
Re-explaining yourself every time
Losing valuable outputs to chat archives you’ll never revisit

You:

Explicitly choose which notes/files the AI reads for each conversation
Save outputs back into your own file system
Reuse those outputs as context for future conversations

This creates a compounding loop. Each conversation produces refined thinking that becomes input for the next conversation.

And crucially: you decide when and what goes back into your canon. Not everything the AI produces is worth keeping. You curate what becomes part of your permanent knowledge base.

What Obsidian Is (For Non-Technical People)

Obsidian is just a nice way to view and edit a folder of text files on your computer.

Your notes are plain text files (Markdown format - like .txt but with simple formatting)
They live on your computer, not someone else’s server
You can open them with any text editor, forever
You own them completely - no subscription lock-in, no account suspension risk

Think of it as: Your external brain, stored as files you control.

Obsidian isn’t doing any AI magic. It’s just the interface - where you browse, link, and organise your thinking.

What Claude Code Is

Claude Code is Anthropic’s AI (Claude) running in your terminal (command line) instead of a web browser.

The key difference: It can read and write files on your computer. This is the superpower.

This means:

You can point it at specific folders/files as context
It can create, edit, or update your notes directly
No copy-pasting between browser and your notes
No losing outputs to chat history

Why This Combination Is Powerful

1. Precise Context Control

Web chat: “Here’s everything I’ve ever said to you, try to figure out what’s relevant”

Claude Code + Obsidian: “Read these 3 specific files. Ignore everything else.”

You choose the lens width for each conversation:

Narrow: “Only my health notes”
Medium: “My travel planning folder”
Broad: “My life philosophy documents + current projects”

2. Outputs Persist and Compound

Web chat: Insights get buried in chat history. You might search for them later. Probably won’t.

Claude Code + Obsidian: The AI writes directly to your notes. The output is the documentation. Next conversation can build on it.

3. The Frictionless Flywheel

This is the killer feature. The conversation flow:

“Read these files to understand my context”
AI synthesises, asks clarifying questions
Back-and-forth discussion refines the thinking
“Write the output to this location”
Output becomes input for future sessions

No manual copy-paste. No reformatting. No “where did I save that?”

And crucially: you can pause at any point, come back tomorrow, and pick up exactly where you left off. The state is saved in your files, not trapped in a chat window. This means multi-day projects flow naturally - you’re not racing to finish before the context disappears.

A Concrete Example

What I Started With

A messy document where I’d pasted:

ChatGPT’s memory of me (Settings > Personalization > Memory)
Claude’s memory of me (Settings > Capabilities — requires paid plan)
Lists of my project/conversation titles from both platforms

Recommendation: Do this yourself. Export your AI memories and conversation lists into a single document. It’s a surprisingly powerful starting point — you’ll see patterns, forgotten context, and things worth preserving.

Plus scattered notes about travel plans, life goals, technical setup, etc.

What We Produced

Over ~10 hours across two days:

1. Travel Planning

A comprehensive 4-month trip itinerary
Routing logic, conference schedules, friend visits, anxieties and mitigations
Multiple iterations refined through rapid back-and-forth
Draft emails ready to send to retreat centres
ASCII timeline visualisation

2. Personal Context System

A core CLAUDE.md file (~80 lines) containing essentials any AI session should know
7 modular context files covering: Technical Infrastructure, Photography, Health, Relationships, Spiritual Practice, Philosophy & Worldview, Key People
These can be selectively loaded depending on the conversation topic

Examples of Quick, High-Impact Additions

The system isn’t just for big planning sessions. Here’s a real example of adding rich context in seconds:

❯ summarise Caplan's book "The Case Against Education" in 1000 words
  and put it in /mnt/nas/Files/05 Resources/Personal philosophy

● I'll write a summary of Caplan's book and save it to your personal
  philosophy folder.

● Write(/mnt/nas/Files/05 Resources/Personal philosophy/The Case Against
  Education - Bryan Caplan - Summary.md)
  ⎿  Wrote 87 lines

● Done. Saved a ~1000 word summary. Covers the core thesis (80% signalling,
  20% human capital), the key evidence, and policy implications.

One sentence. Instant documentation. Now that summary is part of my knowledge base forever, ready to be referenced in future conversations.

Other quick wins:

Song lyrics + reflections → captured in philosophy notes
A blog post idea → drafted and saved
Technical setup decisions → documented for future reference

The point: it’s not just for big projects. The friction is so low that capturing anything becomes effortless.

The Process

Started messy: pasted memories, rough notes, half-formed ideas.

Claude Code would:

Read the relevant files
Synthesise and identify gaps
Ask clarifying questions
Draft outputs
I’d review, correct, add nuance
It would refine and write back to files

Each round made the outputs sharper. The refined outputs then served as context for the next topic.

Worked Example: Actual Back-and-Forth

Here’s a real excerpt showing how the brainstorm/workshop process works. We were building my personal context file:

Me: “Create a context file about my philosophy and worldview”

Claude Code: reads my existing notes, then writes a draft

Me: “The ‘Background’ section is great, but I can’t justify elevating it over the other aspects of my life philosophy we talked about”

Claude Code: “Fair point. The signaling framing got elevated but Internal Locus of Value, My Machine philosophy, Makers vs Takers, etc. are all in the modular file. Inconsistent. Two options: 1) Remove it entirely, 2) Brief mention + pointer…”

Me: “option 2”

Claude Code: revises to a one-line pointer

Me: “do a final proofread”

Claude Code: “Found one issue: Line 66 ‘Health & optimization’ uses US spelling, but the actual filename also uses US spelling. Options: 1) Leave as-is, 2) Rename the file to Australian spelling…”

Me: “2”

Claude Code: renames file, updates reference

This back-and-forth - dozens of rounds over the weekend - produced something much better than asking for a one-shot output ever would. The AI catches inconsistencies, asks for clarification, and the output gets refined iteratively.

The key insight: You don’t need to get your prompt perfect. Start rough, iterate, refine. The conversation IS the refinement process.

The Compounding Effect

By the end of the weekend, Claude Code had:

Deep context on my life situation, values, constraints
Access to well-structured reference documents
Understood my communication preferences (Australian English, no sycophancy, technical depth welcome)

New conversations now start from a much higher baseline. Instead of re-explaining who I am, I just point to CLAUDE.md and the relevant context files.

This is the flywheel: Each conversation makes future conversations more powerful.

Note for readers: I spent the first ~5 hours figuring out the workflow, experimenting, making mistakes. You have this guide. You should be up and running in 2 hours, not 5. The learning curve I climbed is now a path you can walk.

Why Web Chat Feels Clunky By Comparison

After using this system, going back to web chat feels like:

Shouting into a void and hoping it remembers
Manually copy-pasting everything
Losing track of valuable outputs
Re-establishing context every session
Trusting an opaque “memory” system you don’t control

You were probably trying to do this through web chat subconsciously - carefully phrasing context, wishing it would remember, saving good outputs somewhere. The interface just fights you.

Practical Setup

Step 1: Install Obsidian

What it is: A free app for viewing and editing Markdown files (plain text notes with simple formatting).

Download: Go to obsidian.md and download for your operating system.

Create a vault: When you first open Obsidian, it asks you to create or open a “vault”. A vault is just a folder on your computer. Pick a location you’ll remember - this is where all your notes will live.

Suggestion: Create a folder called Notes or PKM (Personal Knowledge Management) somewhere logical:

Mac: /Users/yourname/Documents/Notes/
Linux: /home/yourname/Documents/Notes/
Windows: C:\Users\yourname\Documents\Notes\

Start creating notes:

Click “New note” or press Cmd+N (Mac) / Ctrl+N (Linux/Windows)
Notes are saved as .md files (Markdown)
Don’t overthink organisation yet - just start capturing thoughts

Step 2: Install Claude Code

What you need:

A Claude Pro subscription ($20 USD/month) from claude.ai - this gives you access to Claude Code
Node.js installed on your computer (Claude Code runs on Node)

Installing Node.js

On Mac (Sequoia 15.x or earlier):

Option A - Direct download:

Go to nodejs.org
Download the LTS (Long Term Support) version for macOS
Run the installer, follow the prompts

Option B - Using Homebrew (if you have it):

brew install node

On Linux (Ubuntu/Debian-based):

sudo apt update
sudo apt install nodejs npm

On Windows 11:

Option A - Direct download:

Go to nodejs.org
Download the LTS version for Windows
Run the installer, accept defaults

Option B - Using winget (Windows Package Manager):

winget install OpenJS.NodeJS.LTS

Verify installation: Open Terminal (Mac/Linux) or PowerShell (Windows) and run:

node --version
npm --version

You should see version numbers (e.g., v20.x.x and 10.x.x).

Installing Claude Code

Once Node.js is installed, open your terminal and run:

npm install -g @anthropic-ai/claude-code

The -g means “global” - installs it so you can run claude from anywhere.

Verify it worked:

claude --version

First Run & Authentication

The first time you run Claude Code, it will ask you to authenticate:

Open Terminal (Mac/Linux) or PowerShell (Windows)
Run: claude
It will open a browser window to log in with your Claude account
Once authenticated, you’re ready to go

Step 3: Run Claude Code

The simple approach:

Open Terminal (Mac/Linux) or PowerShell (Windows)
Run: claude
When Claude starts, just drag your vault folder from Finder/Explorer into the terminal and press Enter — or paste the path

That’s it. Claude Code can now see and modify files in that folder.

Even simpler: Include your vault path in your CLAUDE.md file (see Step 4). Then Claude Code always knows where your notes live, and you can reference files by relative paths.

Pro tip: If you always work from your vault folder, you can cd into it first, then run claude. But dragging/pasting the path works fine and requires less typing.

Basic commands to try:

Tell it to read a file:

“Read my notes/ideas.md file”

Tell it to create something:

“Create a new file called brainstorm.md with a summary of what we just discussed”

Tell it to update something:

“Add a new section to my travel-plans.md file”

Plan Mode (recommended): Press Shift+Tab twice to enter Plan Mode. In this mode, Claude discusses its approach before making changes. This matches the “brainstorm, then execute” workflow - you refine the plan together, then let it implement.

Step 4: Build Your Context System

This is the most important part - and the part that pays compounding dividends.

The CLAUDE.md File (Auto-Loaded)

Create a file in your vault called CLAUDE.md. Claude Code automatically reads this file when you start a session in that folder - you don’t need to tell it to. This is your “always-on” context.

What to include (start simple, expand over time):

# My Context

## Who I Am
[Your name, age, profession/situation - 2-3 sentences]

## Current Life Stage
[What's happening now? Major projects, transitions, goals?]

## How I Think
[What's your mental orientation? Are you analytical? Creative?
What concepts/frameworks do you use to think about problems?]

## Communication Preferences
[How do you want Claude to talk to you?]
- Australian/British/American English?
- Technical depth or keep it simple?
- Challenge my thinking or be agreeable?

## What I'm Working On
[Current projects, questions, areas of focus]

## Key Files
[Pointers to other notes for deeper context on specific topics]
- Travel planning: /path/to/travel-notes.md
- Health: /path/to/health-notes.md
- etc.

Expand Into Modular Context Files

As your notes grow, create separate files for different life domains:

Context - Work.md
Context - Health.md
Context - Relationships.md
Context - Projects.md

Then you can selectively load additional context:

“Also read my Context - Health.md, then let’s discuss my sleep issues”

Keep a “Works in Progress” File

This is your days-to-weeks scale mental “RAM” - a single file tracking what’s actively in flight:

# Works in Progress

## Active Threads

### Project Name
Brief description of what this is.
→ /path/to/relevant/file.md

### Another Project
Brief description.
→ /path/to/file.md

When you sit down to work, check this file first. When starting a Claude Code session:

“Read my Works in Progress file, then let’s continue with [project name]”

This solves the “where was I?” problem completely.

The guide rope principle: Every active thread needs a path back to its location. Without this, things sink into the abyss of your folder structure - technically findable, but mentally lost. The Works in Progress file is a guide rope: a tether from your attention to the actual files. If something matters right now, it gets an entry with a path. If you can’t let go of it mentally, that’s a sign it needs a guide rope.

The Key Habit: Brainstorm, Workshop, Discuss

This is crucial and easy to underestimate.

Don’t just ask Claude Code to produce outputs. Use it as a thinking partner:

“Let’s brainstorm…” - generate possibilities without commitment
“Let’s workshop this…” - refine a rough idea through back-and-forth
“Can you ask me clarifying questions about…” - let it probe your thinking
“What am I missing here?” - get it to challenge assumptions
“Let’s discuss the trade-offs of…” - think through decisions together

The productive/creative/reflective back-and-forth is where the value comes from. Claude Code asking you questions and you refining your answers is often more valuable than Claude Code just producing output.

Example prompt to start a session:

“Read my travel-plans.md. I want to brainstorm the best routing for my trip. Ask me clarifying questions about my constraints and priorities, then let’s workshop some options.”

Save Outputs Back to Your Vault

After a productive conversation:

“Write a summary of what we discussed to a new file called [topic]-notes.md”

Or update an existing file:

“Update my travel-plans.md with the itinerary we just designed”

These outputs then become context for future sessions. The flywheel spins.

Folder Structure: IPARA

A suggested way to organise your vault, adapted from Tiago Forte’s PARA method. IPARA stands for:

Folder	Purpose	Examples
00 Now	Active working memory, what’s in flight right now	Works in Progress, scratchpad
01 Inbox	Capture point for new stuff. Process later.	Quick notes, screenshots, downloads
02 Projects	Active work with a goal and endpoint	“Plan trip to Japan”, “Write blog post”
03 Areas	Ongoing responsibilities, no end date	Health, Finances, Career, Relationships
04 Resources	Topics of interest, reference material	Recipes, Book notes, Technical guides
05 Archive	Completed/inactive items from above	Finished projects, old interests
06 System	Meta/config, context files, vault docs	CLAUDE.md context files, templates

The key principles:

Organise by actionability, not by topic. Projects are most actionable; Archives are least.
Projects have endpoints. If it never ends, it’s an Area, not a Project.
Move things opportunistically. Don’t schedule “reorganisation time” - just move notes when you notice they belong elsewhere.
Keep it shallow. Five categories wide, max four levels deep. Complexity kills systems.

The magic: your project list is constantly turning over. Completed projects move to Archive, creating a cadence of regular victories. Areas stay stable. Resources grow organically.

Who This Is For

Good fit:

You value owning your data
You have multiple domains of life you think about seriously
You want AI to be a long-term thinking partner, not just a chat toy
You’re willing to spend an hour or two getting set up for long-term payoff

Less good fit:

You just want quick answers to quick questions
You prefer everything to “just work” without any configuration

Key Concepts Summarised

Concept	What It Means
Context control	You choose exactly what the AI knows for each conversation
Local-first	Your notes are files on your computer, not someone else’s server
Compounding loop	Outputs become inputs for future sessions
Frictionless read/write	AI reads and writes files directly, no copy-paste
Modular context	Different files for different domains, load what’s relevant
Brainstorm/workshop	Use back-and-forth discussion, not just one-shot prompts
CLAUDE.md auto-load	Core context file is read automatically at session start
Works in Progress	A “mental RAM” file tracking what’s actively in flight
Guide rope	Every active thread needs a path to its location, or it sinks into the abyss
IPARA structure	Inbox → Projects → Areas → Resources → Archive
Pause and resume	State lives in files, not chat - pick up tomorrow where you left off
Iterative refinement	Start rough, refine through conversation - you don’t need perfect prompts
Quick captures	Low friction means even small insights get documented