Knowledge Vault: A personal knowledge management system combining Claude Code + Obsidian. Replaces Evernote, Notion, Asana, and Otter.ai with local Markdown files, custom SKILLs, and persistent context. Share this with Claude Code to build your own.

knowledge-vault-readme.md

Knowledge Vault

A second brain that actually thinks.

What This Is

This is a personal knowledge management system that combines Obsidian (for notes) with Claude Code (for intelligence). Instead of just storing information, it actively processes, connects, and surfaces knowledge when you need it.

What it replaces:

• Evernote — But AI organizes your notes for you
• Notion — But everything is local Markdown you own
• Asana/Trello/Jira — But the todo system fits YOUR workflow
• Otter.ai / note-takers — Meeting summaries with /meeting-summary
• ChatGPT/Claude web — This becomes your main LLM interface

Why this matters now: With ads coming to ChatGPT and concerns about data usage, this gives you:

• Files you own — Everything stored in local Markdown files you control
• Custom behavior — Skills define exactly how YOU want tasks done, every time
• Persistent context — Your entire knowledge base available to Claude
• No vendor lock-in — Markdown works forever, switch LLMs anytime

Note: Claude Code still sends queries to Anthropic's API (not a local LLM). But your knowledge base stays local—you control what context gets sent, and your files aren't stored on someone else's platform.

The problems it solves:

1. Content overload — Bookmarks pile up, notes gather dust, nothing gets revisited
2. Knowledge trapped in heads — Team knowledge exists only in a few people's minds
3. To-do app fatigue — Tried every app, none fit your workflow
4. Context switching — Re-explaining projects to AI every session

The approach: Four integrated workflows powered by Claude Code + Obsidian.

---

How to Use This Document

This README is designed to be shared with Claude Code. Here's how to build your own Knowledge Vault:

Prerequisites

1. Install Claude Code from Anthropic (requires Claude Pro or Max subscription)
2. Install Obsidian from obsidian.md (free)

Build Your Own

1. Save this README to your computer (or copy the text)
2. Open your terminal and run Claude Code: claude
3. Share this document with Claude:

   claude "Read this README and help me set up a Knowledge Vault: [paste README or file path]"
   

4. Claude Code will walk you through creating the folder structure, CLAUDE.md files, and initial setup
5. Add skills one at a time based on what workflows matter to you

Start simple. You don't need everything at once. Pick one pillar (content digestion, project context, task management, or meetings) and build from there.

---

What It Unlocks

Pillar 1: Content Digestion

Before	After
Bookmark a link, forget it exists	Drop a link, get a rich summary automatically
Copy-paste quotes into notes manually	AI extracts key insights and organizes them

Pillar 2: Project Knowledge Dumps

Before	After
Re-explain context to AI every session	CLAUDE.md files provide persistent context
Knowledge trapped in your head	Document once, Claude builds on it forever
Start from scratch each time	Iterate on existing plans and architectures

Pillar 3: Task Management

Before	After
Try Trello, Asana, Jira—none fit	Build a todo system that matches your style
Completed tasks disappear	Arxiv creates searchable history of accomplishments
No visibility into progress	Dashboards surface what needs attention

Pillar 4: Meetings & Audio

Before	After
Pay for Otter.ai, Fireflies, etc.	/meeting-summary extracts action items free
Transcripts are walls of text	Structured output: decisions, owners, next steps
Audio recordings gather dust	Transcribe → summarize → actionable notes

The real unlock: Your knowledge compounds. Content, projects, and tasks all feed into the same system—searchable, connected, and always available as context for Claude.

---

Origin Story

This system emerged from a happy accident: VS Code kept crashing during long planning sessions with Claude. The workaround—saving plans to Markdown files first—revealed something powerful:

• Plans become reviewable before execution
• Markdown is human-readable and correctable
• External files persist across crashes
• Documents serve as context for future sessions

"I found actually planning and outputting the plan is really great and helpful way of building because then I can actually review the plan."

That realization led to Peter Yang's tutorial with Alex Finn on using Claude Code as a "life operating system." Alex had built slash commands and sub-agents to automate his workflows. Then discovering that Anthropic added SKILLs (reusable Markdown recipes) provided the perfect way to package these workflows. The combination evolved into this full knowledge management approach.

---

The Big Picture

Four workflows, one vault, one LLM interface:

┌──────────────────────────────────────────────────────────────────────────────┐
│                              KNOWLEDGE VAULT                                  │
│                      (Your main LLM interface)                               │
├───────────────────┬───────────────────┬───────────────────┬──────────────────┤
│  CONTENT DIGEST   │  PROJECT CONTEXT  │  TASK MANAGEMENT  │    MEETINGS      │
├───────────────────┼───────────────────┼───────────────────┼──────────────────┤
│ 00-inbox/         │ 02-projects/      │ 01-todos/         │ 06-meetings/     │
│      ↓            │      ↓            │      ↓            │      ↓           │
│ /digest           │ CLAUDE.md gives   │ inbox → active    │ /meeting-summary │
│      ↓            │ persistent context│      ↓            │      ↓           │
│ 03-resources/     │      ↓            │ arxiv (done)      │ summaries/       │
│                   │ Iterate & build   │                   │ (action items)   │
└───────────────────┴───────────────────┴───────────────────┴──────────────────┘
                                    ↓
                 All files stored locally in Markdown you own
                 Custom SKILLs define exactly how tasks get done
                 Switch LLM providers anytime—no vendor lock-in

Everything flows into one searchable, connected system.

---

Sync Strategy

This vault stays synchronized across devices using two methods:

Method	Purpose
Obsidian Sync	Real-time sync across Mac, iPhone, iPad
GitHub	Version history, backup, shareable structure
Dropbox	Filesystem-level sync (alternative to Obsidian Sync)

Note: This README is self-contained. Share it with Claude Code and ask it to help you build your own Knowledge Vault. No access to the original repository needed.

---

Getting Started

Minimal Setup (5 minutes)

1. Create the vault:

mkdir -p ~/Dropbox/knowledge-vault
cd ~/Dropbox/knowledge-vault
mkdir -p 00-inbox 01-todos 03-resources

2. Add a CLAUDE.md file:

cat > CLAUDE.md << 'EOF'
# Knowledge Vault

## Structure
- 00-inbox/ — Drop links here for processing
- 01-todos/ — Task tracking
- 03-resources/ — Processed knowledge notes

## When processing inbox items
1. Fetch content from URLs
2. Create structured note with frontmatter
3. Save to 03-resources/
4. Delete the inbox file
EOF

3. Try it:

# Add something to inbox
echo "https://example.com/interesting-article" > 00-inbox/article.md

# Ask Claude to process it
cd ~/Dropbox/knowledge-vault
claude "Process the file in 00-inbox/ into a resource note"

That's the core workflow. Everything below builds on this foundation.

---

Core Concepts

The Inbox

00-inbox/ is your capture point. Anything you want to process goes here:

<!-- 00-inbox/cool-video.md -->
https://youtube.com/watch?v=xyz

Interesting talk about AI agents. Want to extract key points.

The inbox should stay empty. Content flows through, not stays.

Resources

03-resources/ holds processed knowledge. Each note follows a template:

---
tags: [topic, status/to-evaluate]
created: 2025-12-29
source: https://example.com
---

# Title

## Summary
One paragraph capturing the key insight.

## Key Points
- Point 1
- Point 2

## Related
- [[Other Note]]

Todos

Simple three-file system:

File	Purpose
inbox.md	Quick capture, unsorted
active.md	Currently working on
arxiv.md	Completed items with dates

Archive format:

- [x] Task description ✅ 2025-12-29
  - Output: what was produced

This creates a searchable history of accomplishments.

Projects (Knowledge Dumps)

02-projects/ holds project-specific context that persists across Claude sessions:

02-projects/
├── my-app/
│   ├── CLAUDE.md          # Project context for Claude
│   ├── ARCHITECTURE.md    # System design docs
│   ├── PLAN.md            # Current implementation plan
│   └── resources/         # Project-specific references
└── another-project/
    └── ...

The CLAUDE.md file tells Claude everything it needs to know:

• What the project does
• Key files and their purposes
• Conventions and patterns used
• Current state and next steps

Why this matters:

• No more re-explaining context every session
• Plans persist and evolve over time
• Claude can review and iterate on its own previous work
• Team members can understand projects by reading the docs

Example workflow:

cd ~/Dropbox/knowledge-vault/02-projects/my-app
claude "Review PLAN.md and implement the next step"
# Claude reads existing context, continues where you left off

---

Adding Intelligence: Skills

Skills are an Anthropic feature: reusable Markdown recipes that define how you want a task done. Write the instructions once, invoke them with /skill-name forever. The workflow recipe itself persists, not just the output.

Example Skills

Command	What it does
/digest	Process inbox items into rich notes
/deep-research topic	Multi-query web research
/meeting-summary file.txt	Extract action items from transcripts
/code-review ./src	Generate architecture documentation

Using Skills

# In your vault directory
claude "/digest"

# With arguments
claude "/deep-research 'best practices for RAG systems'"

Creating a Skill

Skills live in ~/.claude/skills/skill-name/SKILL.md:

# My Skill

Brief description.

## Invocation
/my-skill argument

## Behavior
What Claude should do when this is invoked...

---

Expanding the Structure

Once the basics work, add more organization:

knowledge-vault/
├── 00-inbox/              # Capture
├── 01-todos/              # Tasks
│   ├── inbox.md
│   ├── active.md
│   ├── someday.md         # Future/maybe items
│   └── arxiv.md           # Completed archive
├── 02-projects/           # Project-specific context
├── 03-resources/          # Processed notes
├── 04-claude-code/        # Claude configurations
│   └── skills/            # Skill definitions
├── 05-prompts/            # Prompt library
│   ├── system-prompts/
│   └── patterns/
├── 06-meetings/           # Meeting recordings & summaries
├── _templates/            # Obsidian templates
└── _assets/               # Images, attachments

Each directory can have its own CLAUDE.md with context-specific instructions.

---

Obsidian Integration

Why Obsidian?

• Local-first (your data, your machine)
• Markdown files (portable, future-proof)
• Plugin ecosystem (Dataview, Templater, etc.)
• Graph view for connections
• Works offline

Essential Plugin: Dataview

Dataview turns your vault into a queryable database. Install it from Community Plugins.

Example: Show resources to review

TABLE file.mtime AS "Modified"
FROM "03-resources"
WHERE contains(tags, "status/to-evaluate")
SORT file.mtime DESC

Example: Recent todos

TASK FROM "01-todos"
WHERE !completed
LIMIT 10

Tags Strategy

Status tags (lifecycle):

• #status/to-evaluate — Haven't reviewed yet
• #status/evaluated — Reviewed
• #status/adopted — Actively using

Content tags (type):

• #article, #video, #tweet, #repo, #paper

---

Advanced: Automation

For hands-free processing, set up a watcher that monitors your inbox.

How It Works

┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
│  00-inbox/      │────▶│  digest-watcher  │────▶│  03-resources/  │
│  (new files)    │     │  (polls every 5m)│     │  (processed)    │
└─────────────────┘     └──────────────────┘     └─────────────────┘

The Scripts

digest-inbox — Processes a single file:

#!/bin/bash
FILE="$1"
CONTENT=$(cat "$FILE")

claude "Process this into a resource note:
$CONTENT

Save to 03-resources/ then delete $FILE" -p --permission-mode acceptEdits

digest-watcher — Polls inbox continuously:

#!/bin/bash
while true; do
  for file in 00-inbox/*.md; do
    [[ -f "$file" ]] || continue
    [[ "$(basename "$file")" == "CLAUDE.md" ]] && continue
    digest-inbox "$file"
  done
  sleep 300  # Check every 5 minutes
done

Crontab Setup

# Start on boot
@reboot ~/.local/bin/digest-watcher

# Ensure running
*/5 * * * * pgrep -f digest-watcher > /dev/null || ~/.local/bin/digest-watcher

Note: Skills don't work with claude -p (non-interactive mode). The automation scripts inline the full prompt instead.

---

Full Skills Reference

This vault includes 8 pre-built skills:

Skill	Command	Use Case
digest	/digest	Transform inbox links into structured notes
ultrathink	/ultrathink	Deep thinking for complex problems
code-review	/code-review ./path	Generate architecture docs from code
content-review	/content-review ./path	Synthesize insights from documents
deep-research	/deep-research topic	Multi-query web research with synthesis
meeting-summary	/meeting-summary file	Extract decisions and action items
flights	/flights LAX to Tokyo	Multi-strategy flight search
stock-sentiment	/stock-sentiment NVDA	Generate Grok AI sentiment prompts

Syncing Skills

Skills are stored in 04-claude-code/skills/ and copied to Claude's directory:

rsync -av --delete 04-claude-code/skills/ ~/.claude/skills/
# Restart Claude Code to pick up changes

---

Gap Analysis

What's Working

Component	Status
Core capture → process → store workflow	Functional
8 custom skills	Synced and working
Obsidian + Dataview dashboards	Configured
Todo workflow with archive	Complete
Automation scripts	Running

Known Gaps

Capture Friction

Gap	Impact	Potential Solution
No browser extension	Must manually copy links	Build Chrome/Firefox extension
No mobile capture	Can't capture on phone easily	iOS Shortcut → Dropbox
No Raycast/Alfred integration	Extra steps to add content	Create quick-add scripts

Missing Integrations

Integration	What it would enable
Twitter/X MCP server	Direct tweet extraction
Readwise	Auto-import highlights
YouTube transcript API	Auto-extract video content
Semantic search	AI-powered retrieval across vault

Content Gaps

Area	Current State	Opportunity
Prompt patterns	1 pattern (Chain of Thought)	Add few-shot, tree-of-thought, reflection
Hook examples	Empty directory	Document pre/post hook patterns
Cross-linking	Notes are siloed	Build connection discovery

Workflow Gaps

Gap	Description
Review cycle	No systematic process for reviewing old content
Spaced repetition	Nothing resurfaces old knowledge
Weekly digest	No summary of what was processed

---

Building Your Own

You don't need this exact structure. Pick the pillars that matter to you:

If you mainly want content digestion:

• Start with 00-inbox/ + 03-resources/
• Add the /digest skill
• Set up automation when ready

If you mainly want project context:

• Start with 02-projects/ + CLAUDE.md files
• Document one project thoroughly
• Let Claude iterate on existing docs

If you mainly want task management:

• Start with 01-todos/ (inbox, active, arxiv)
• Use the dated archive format
• Add Dataview dashboards for visibility

Core principles:

1. Everything is Markdown — Portable, future-proof, AI-readable
2. CLAUDE.md for context — Instruction files give AI persistent memory
3. Skills for repetition — Codify workflows you do often
4. Obsidian for rendering — See content beautifully, sync everywhere

Add complexity only when needed.

---

Tips

Keep It Simple

• Process inbox regularly (don't let it pile up)
• Archive completed todos immediately
• One tag system, used consistently

Claude Code Specifics

• Skills only expand interactively (not with -p flag)
• Restart Claude Code after modifying skills
• Put project context in CLAUDE.md files

Obsidian Specifics

• Blank line required before tables
• Use wiki links: [[folder/file|Display Name]]
• Frontmatter (YAML) at top of every file

---

Summary

This system turns passive content consumption into active knowledge building through four pillars:

Content Digestion

• Capture — Drop links in inbox
• Process — Claude transforms into structured notes
• Review — Dashboards surface what needs attention

Project Knowledge

• Document — Dump knowledge into project CLAUDE.md files
• Iterate — Claude builds on existing context each session
• Evolve — Plans and architectures grow over time

Task Management

• Capture — Quick todos to inbox.md
• Work — Move to active.md when doing
• Archive — Completed items go to arxiv.md with dates

Meetings & Audio

• Record — Drop audio files in meetings/
• Transcribe — Use whisper or similar
• Summarize — /meeting-summary extracts decisions, action items, owners

Why This Becomes Your Main LLM Interface

Unlike web-based ChatGPT or Claude.ai:

• Files stay local — Your knowledge base lives on your machine, not a platform
• Custom skills — Define exactly how YOU want every task done
• Persistent context — Your entire knowledge base available every session
• No vendor lock-in — Markdown files work forever, switch LLMs anytime

(Note: Queries still go to Claude's API—this isn't a local LLM. But you control the files and what context gets sent.)

The goal isn't perfect organization—it's reducing friction:

• Between finding something interesting and being able to use it later
• Between having an idea and having Claude help you build it
• Between completing work and having a record of what you accomplished
• Between recording a meeting and having actionable next steps

Start small. Let the system grow with your needs.

---

Inspirations & Acknowledgements

This system wouldn't exist without these creators:

Peter Yang (@petergyang)

Product Lead at Roblox who runs Behind the Craft, a newsletter helping 140K+ tech professionals with practical AI tutorials. His philosophy—"no theory or fluff"—shaped this system's focus on workflows that actually work.

The video that started it all:

Full Tutorial: Build an AI Life Co-Pilot with Claude Code in 25 Minutes | Alex Finn

Original tweet: Peter Yang on X (Dec 23, 2024)

Alex Finn (@AlexFinnX)

Founder who built the "Claude Life" operating system using slash commands and sub-agents to automate his newsletter research, daily briefings, and brain dump analysis. His "$200/month employee" philosophy and the realization that Claude Code is just an AI agent (not just for coding) opened up possibilities far beyond typical use cases.

"Claude Code is actually just an AI agent. But it's one they market as a code builder."

Anthropic SKILLs

Anthropic's SKILLs feature (reusable Markdown recipes invoked with /skill-name) provided the mechanism to package workflows into persistent, repeatable commands. The workflow recipe itself persists, not just the output.

Resources

Resource	Link
Behind the Craft Newsletter	creatoreconomy.so
Claude Code Tutorial (YouTube)	youtube.com/watch?v=D0nDWQdN3F4
Tutorial Writeup	creatoreconomy.so/p/full-tutorial-build-an-ai-life-copilot-with-claude-code-alex-finn