productivityaiobsidiandeveloper-experience

My Developer Second Brain: Obsidian and Claude Code Together

How I combine Obsidian for knowledge capture with Claude Code for automation. The note structure, AI integration, and workflows that actually stick.

·8 min read

I've tried a lot of note-taking systems over the years. Most didn't stick. The ones that failed had something in common: too much friction between capturing a thought and actually using it later.

My current setup combines Obsidian for knowledge management with Claude Code for automation. Obsidian handles the capture and organization. Claude handles the tedious parts - processing raw notes, generating summaries, connecting information across documents.

This post is about the specific system I use, not theory. If you're curious about using AI with a personal knowledge base, here's what actually works for me.

The Note Structure

I use a modified Zettelkasten approach with four main note types:

Atoms are small, focused notes about single concepts. A note about a specific API, a programming pattern, a tool I learned. Each atom captures one idea thoroughly. Tagged #atom, they auto-move to the atoms/ folder.

Molecules combine multiple atoms into larger concepts. A note about "Event-Driven Architecture" might link to atoms about message queues, event sourcing, and CQRS. These are reference documents I return to. Tagged #molecule.

Projects are active work with tasks, decisions, and context. Each client project or side project gets a note tracking what's happening, what's blocked, and what's next. Tagged #project.

Fleeting notes go in the inbox. Quick thoughts, links to check later, half-formed ideas. These get processed into atoms or deleted. The inbox is a holding area, not a destination.

The folder structure:

vault/
├── atoms/           # Single concepts
├── molecules/       # Combined knowledge
├── projects/        # Active work
├── inbox/           # Unprocessed notes
├── personal/
│   ├── daily/       # Daily notes
│   ├── weekly/      # Weekly summaries
│   └── sessions/    # AI coaching/review sessions
└── templates/       # Note templates

I use Obsidian's auto-note-mover plugin. When I tag a note, it moves to the right folder automatically. Less thinking about where things go.

Daily Notes as Developer Journal

Every day gets a note. I don't follow a rigid template - some days are detailed, some are sparse. The consistent parts:

  • Tasks for today (checkbox format)
  • Notes and thoughts as they come up
  • Decisions made and why
  • Links to relevant project notes

The daily note is stream-of-consciousness during the day. I dump thoughts, paste links, jot down ideas. It's messy and that's fine. The processing is where it becomes useful.

At the end of the day or start of the next, I spend a few minutes cleaning up. Move actionable items to the right project notes. Turn interesting thoughts into atom notes if they're worth keeping. Delete the noise.

Daily notes link forward to weekly notes, which link to monthly notes. Each level summarizes the one below. I rarely read old daily notes, but I often read weekly summaries to remember what I was working on.

The Claude Integration

This is where it gets interesting. I have a CLAUDE.md file in my Obsidian vault that teaches Claude how my system works.

# CLAUDE.md

## Repository Structure

This is an Obsidian vault using Zettelkasten with:

- atoms/ - Small focused notes (tagged #atom)
- molecules/ - Combined concepts (tagged #molecule)
- projects/ - Active work (tagged #project)
- inbox/ - Unprocessed notes (tagged #fleeting)
- personal/daily/ - Daily notes in YYYY-MM-DD format

## Note Organization

- Tag notes appropriately for auto-move
- Link related concepts with [[Note Title]] syntax
- Daily notes capture raw thoughts for later processing

When I work with Claude in my vault, it understands the structure. I can say "create an atom note about WebSockets" and it knows what that means - where it should go, how it should be formatted, what tags to use.

Global Skills for Automation

Beyond project-specific CLAUDE.md files, I have global skills that work across all my projects. These live in ~/.opencode/skills/ and get loaded when I invoke them.

Coach skill (/coach). This turns Claude into an accountability partner. It reads my daily note and goals, asks hard questions, identifies patterns I'm avoiding, and creates a session log. The output goes in personal/sessions/ with commitments and follow-ups.

A coach session looks like:

# Coach Session - 2026-01-21

## Context

Working on portfolio site. Avoiding the content writing.

## Goals Check

| Goal           | Target | Current  | Today         |
| -------------- | ------ | -------- | ------------- |
| Ship portfolio | Jan 31 | 80% done | Wrote 2 posts |

## Pattern Identified

Avoiding writing by doing more code. The code is done. Write the content.

## Commitments

1. [ ] Finish 3 blog posts by Friday
2. [ ] No new features until content done

The session gets linked from my daily note. Next time I run /coach, Claude reads the previous session and checks if I followed through.

Budget skill (/budget). I track finances through my vault. This skill reads bank statement PDFs, categorizes spending, compares against targets, and updates my financial notes. What used to take an hour of spreadsheet work takes 10 minutes.

The workflow:

  1. Download statements, drop in personal/finances/ folder
  2. Run /budget with the date range
  3. Claude parses the PDFs, categorizes transactions, calculates totals
  4. Output goes in daily note with variance analysis

Daily cleanup skill (/cleanup). Processes yesterday's daily note - extracts key events, updates weekly summary, bubbles up unfinished tasks, structures scattered thoughts into proper sections. Raw capture becomes organized notes.

Session Documentation in Code Repos

The same documentation pattern works in code repositories. Every project I work on has:

project/
├── CLAUDE.md                    # Project-specific AI instructions
├── docs/
│   ├── WORKSTREAMS_OVERVIEW.md  # Status dashboard
│   ├── workstreams/
│   │   └── feature-name.md      # Feature plans
│   └── sessions/
│       └── 2026-01-21-work.md   # Session logs

Workstream docs are plans - goal, tasks, decisions, open questions. Session docs are logs - what got done, commits made, what's next.

When I start working, Claude reads the overview and recent sessions. It knows the context without me explaining. When I finish, I update the session doc. Five minutes of documentation saves twenty minutes of context-setting tomorrow.

I wrote more about this in my Claude Code workflow post - the session documentation section covers the specifics.

What Makes This Work

Capture is frictionless, processing is automated. I dump thoughts into daily notes without worrying about organization. Claude helps clean it up later. If capture required structure, I'd skip it when busy.

Everything links together. Daily notes link to projects. Projects link to atoms. Atoms link to each other. The connections compound over time. Six months of linked notes becomes a genuine knowledge base.

AI handles the tedious parts. Summarizing a week of daily notes is boring. Categorizing fifty bank transactions is boring. Checking if I followed through on commitments is boring. Claude does these reliably, freeing me to focus on the interesting work.

The system is documented. CLAUDE.md files mean the AI knows how things work. I don't re-explain conventions every session. The documentation is the configuration.

Honest Assessment

This setup has maintenance overhead. Templates need updating. Skills need refinement. The CLAUDE.md files need to stay accurate as projects evolve.

Sometimes Claude misunderstands the structure and puts things in wrong places. Sometimes the automated summaries miss important nuance. I review everything before trusting it.

The setup time was significant - maybe 10-15 hours to get everything configured and working smoothly. Whether that's worth it depends on how much you use notes. For me, daily use over months has more than paid back the investment.

What I can't do anymore: use a notes app that doesn't support markdown, linking, and some form of automation. The baseline has shifted.

Getting Started

If you want to try something similar, start small:

Week 1: Install Obsidian, create a simple folder structure (inbox, notes, daily), start capturing daily notes. Don't worry about Zettelkasten yet.

Week 2: Add a CLAUDE.md to your vault explaining the structure. Try using Claude Code to help process or organize notes.

Week 3: Create one automation - maybe a daily summary template or a simple skill. See if it saves time.

Week 4: Evaluate. Is this helping? What's friction? Adjust or abandon based on real usage.

Don't copy my system exactly. It evolved over years to fit how I think. Yours should fit how you think. The core ideas - frictionless capture, linked notes, AI for tedious work - adapt to many different structures.

For the technical details on Claude Code specifically, see how I use Claude Code to ship better code faster. That post covers skills, project configuration, and the development workflow in more depth.

If you're interested in managing complexity in code the way Zettelkasten manages complexity in notes, component-driven development applies similar principles to UI development.