Your Obsidian Vault Is a Knowledge Graph. Here’s How to Make It Think.

I watched Boris Cherny say “coding is solved” and thought of an essay from 1945. That collision — between the creator of Claude Code and a wartime science director named Vannevar Bush — is what this article is about.

An Idea from 1945, Triggered by an Interview from 2026

A few weeks ago, I watched Boris Cherny’s interview at Sequoia’s AI Ascent 2026. Cherny is the creator of Claude Code. He hasn’t written a line of code himself this year. He ships dozens of pull requests a day from his phone, orchestrating thousands of AI agents that do the mechanical work overnight. His claim — “coding is solved” — got all the headlines.

But the line that stuck with me was quieter. He said the most valuable skill in the AI era isn’t writing code. It’s domain knowledge — understanding a problem deeply enough to direct the machine well. The best person to build accounting software, he argued, isn’t the fastest engineer. It’s the great accountant.

I’d heard that argument before. Not from a tech conference. From a 1945 essay in The Atlantic Monthly.

In July 1945, while the world was still at war, Vannevar Bush published “As We May Think.” Bush was the director of the U.S. Office of Scientific Research and Development — the man who coordinated nearly all wartime scientific research for the Allied powers. His essay wasn’t about weapons. It was about what comes after: how do scientists manage the explosion of knowledge that war had accelerated?

His answer was a device he called the Memex — a desk-sized machine in which an individual would store all their books, records, and communications, mechanized so it could be consulted with extraordinary speed and flexibility. An enlarged intimate supplement to memory.

But the Memex’s killer feature wasn’t storage. It was what Bush called associative indexing — the ability to link any item to any other item, creating chains of association he called trails. Bush’s insight was that hierarchical filing systems — alphabetical, numerical, categorical — don’t match how humans actually think. As he wrote:

“The human mind does not work that way. It operates by association. With one item in its grasp, it snaps instantly to the next that is suggested by the association of thoughts, in accordance with some intricate web of trails carried by the cells of the brain.”

Bush imagined that users would build trails through their material — linking a history article to an encyclopedia entry to a personal annotation to a table of physical constants — and that these trails would persist, could be named, and could be shared with colleagues for insertion into their own Memex.

He even imagined a new profession: trailblazers, people whose job was to find useful paths through the maze of the world’s knowledge and make them available to others.

Bush’s core conviction — and Cherny’s, eighty years later — is the same: the mechanization of routine work doesn’t diminish human expertise. It makes expertise the bottleneck. When the machine handles retrieval, traversal, and synthesis, what matters is the quality of the trails you’ve built and the judgment you bring to what the machine finds.

I’ve been reading Bush’s essay once a year for the past five years. Each time, it hits differently. Watching Cherny’s interview, it clicked in a way it hadn’t before. Because somewhere along the way, without fully realizing it, I built a Memex. It’s called an Obsidian vault. And the trailblazer? That turned out to be Claude Code.

Five Years of Building a Memex Without Knowing It

I opened my first Obsidian vault in 2021. It was a mess — a migration dump from Evernote, Notion, and a decade of text files scattered across three computers. Five years later, that vault holds over 4,000 notes spanning my consulting work, personal research, investment theses, and the day-to-day texture of life — meeting notes, book highlights, half-finished ideas, and the kind of thinking you only do when you know nobody’s watching.

Obsidian became load-bearing infrastructure for me. Not in the productivity-influencer sense. In the sense that when a client asks me to synthesize six months of project history, I open my vault instead of my email. When I’m evaluating a company, I pull up my investment framework note and the industry research I’ve accumulated over years. When I need to write something, the first draft already exists as fragments scattered across a hundred notes.

The parallels with Bush’s Memex are almost eerie once you see them. The Memex stores all records in one place — my vault stores all notes in one folder tree. The Memex lets you project two items side-by-side on viewing screens — Obsidian opens notes in split panes. The Memex lets you add marginal notes and annotations — Obsidian has frontmatter, callouts, and inline comments. The Memex’s associative links let any item instantly call up another — Obsidian’s [[wikilinks]] do exactly this, eighty years later, in plain text.

But here’s what I couldn’t do — the thing Bush imagined but I was still missing: I couldn’t ask the vault to follow a trail for me. I couldn’t say “what connects my distributed systems notes to my organizational design notes?” and get an actual answer. The trails were all there — linked, tagged, structured — but the only thing that could traverse them was me, manually, one note at a time.

Bush knew this would be the hard part. He believed the real value would come from mechanized trail-following — machines that could traverse associations faster and more completely than any human. He was right. It just took eight decades.

That changed when I connected Claude Code to my vault.

Selection by Association, Not by Indexing

Bush’s deepest insight — the one that separates him from everyone who just wanted faster filing cabinets — was about the nature of retrieval itself. Hierarchical classification forces every item into one place. To find it, you trace down from category to subcategory, and if you guess the wrong path, you start over. Bush called this artificial. He wanted selection by association.

This is exactly why Obsidian works and why rigid folder systems don’t. A note about Bayesian reasoning doesn’t belong in “Mathematics,” “Investing,” or “Machine Learning” — it belongs in all three, connected by links rather than confined by location. Every [[wikilink]] I write is an associative index entry in Bush's sense: it causes one item to select another.

And this is why most Obsidian-AI integration guides get the story wrong. They start with the tool — install this plugin, configure this server. They miss the deeper point: Claude Code isn’t just accessing files. It’s traversing an associative network. The same one Bush described.

Claude Code wasn’t built for note-taking. It was built to navigate codebases — read files, understand structure, follow references, make targeted edits, and execute multi-step plans. But a codebase and an Obsidian vault are structurally identical: source files and notes, import statements and wikilinks, directory hierarchies and folder trees, config files and YAML frontmatter. Claude Code navigates them with similar fluency.

The simplest integration is the most underrated:

cd ~/my-vault
claude

No plugins, no servers. Claude Code reads every note, creates files, edits content, searches with regex. But “can access files” is table stakes. The five years I’d spent structuring my vault — building Bush’s associative trails in Markdown — that’s what makes the integration genuinely powerful.

Teaching Claude Your Trails: CLAUDE.md

Bush imagined that the Memex would know its owner’s interests, projects, and organizational habits. In practice, Claude Code has a mechanism for this: a file called CLAUDE.md at your vault root, read automatically at the start of every session. Think of it as the Memex's user profile — except the machine forgets it between sessions, so you need to keep it current.

I run /init the first time, which generates a starting point by scanning vault structure. Then I rewrite it heavily. Here's what five years of vault discipline taught me to include:

# Vault Context

This is my personal + professional knowledge vault. Five years 
of notes across consulting, investing, and distributed systems 
research, and personal development. Notes use Obsidian-flavored 
Markdown with [[wikilinks]], callouts, and YAML frontmatter.

## Structure
- Projects/ — active client and personal work
- Areas/ — ongoing domains (health, finance, ML research)
- Resources/ — reference material, book notes, papers
- Archive/ — completed work (still searchable, not active)
- _attachments/ — images and PDFs (NEVER modify)
- _templates/ — Obsidian templates (NEVER modify)
- _ai-drafts/ — staging area for AI-generated content

## Conventions
- Internal links: always [[wikilinks]], never bare URLs
- Tags: hierarchical #domain/topic format
- MOCs: prefixed "MOC — " (Maps of Content)
- Daily notes: Journal/YYYY/YYYY-MM/YYYY-MM-DD.md
- Source notes: must include `source:` in frontmatter

## Rules
- NEVER modify _attachments/, _templates/, or .obsidian/
- NEVER delete notes without my explicit confirmation
- Always include YAML frontmatter: date, tags, aliases
- When synthesizing, use ONLY content from my notes
- Output drafts to _ai-drafts/ — never directly into the vault

## Active Context (I update this before each session)
- Working on: Q2 client architecture review
- Open questions: containerization strategy for legacy systems
- Recent focus: Areas/distributed-systems/, Projects/client-acme/

Three practices that matter more than the template:

Keep the Active Context fresh. Stale context sends Claude down yesterday’s priorities. I update this before every session, and ask Claude to append a session log at the end. That creates continuity across sessions — a trail of trails, in Bush’s terms.

Reference, don’t inline. My interests, active projects, and professional context live in separate notes. CLAUDE.md references them. This keeps the root file focused — Bush’s Memex had code books for quick lookup, not everything crammed onto one screen.

Include negative instructions. “Never modify _templates/” prevents the most common accidents. I learned this the hard way when an early session helpfully “improved” one of my Templater scripts.

The Knowledge Graph Bush Couldn’t See

Bush described trails as linear sequences: item A links to item B, which links to item C. He knew items could belong to multiple trails, but his mechanical design limited him to chains. What he couldn’t envision was what happens when you have 4,000 items with thousands of cross-links: you get a graph.

Every Obsidian vault contains an implicit graph. Notes are nodes. Wikilinks create edges. Individual wikilinks are directed (note A links to note B), but Obsidian’s backlinks feature creates a bidirectional navigation layer, so you can traverse connections in either direction. Tags act as labels grouping nodes into subgraphs. Frontmatter properties become node attributes that graph-aware tools can query and filter.

Obsidian’s Graph View shows this structure beautifully. But it’s passive — a visualization, not a reasoning engine. It can’t tell you which notes are hubs, can’t identify clusters that should be connected but aren’t, can’t find the conceptual bridges between domains. This is exactly where Claude Code — especially through MCP servers with graph capabilities — fills the gap that Bush’s original design couldn’t address.

Graph Metrics That Actually Matter

Once you connect Claude Code via an MCP server with graph operations, you unlock the kind of analysis Bush’s trail blazers would have done — but across thousands of items in seconds:

Centrality ranking identifies your true hub notes. I discovered that my note on “Feedback Loops” had 38 incoming links across four domains, while my official MOC for Systems Thinking had 7. That mismatch was a sign I needed to restructure. Here’s what it looks like in practice:

> get_centrality_ranking(limit=5)

1. Feedback Loops — 38 connections (Areas/systems-thinking, 
   Projects/client-acme, Resources/books)
2. MOC — Distributed Systems — 34 connections
3. Bayesian Reasoning — 29 connections (bridges 3 clusters)
4. Second-Order Effects — 26 connections
5. Margin of Safety — 24 connections (Areas/investing, 
   Projects/portfolio)

Orphan detection finds notes with zero connections — ideas captured but never linked into a trail. I had 340 orphans in 4,000 notes. Bush would have called these dead-end index cards: information stored but effectively lost.

Cluster analysis reveals which topics form natural groupings and which are disconnected. My investing notes and systems thinking notes were two separate islands despite obvious overlap — an integration opportunity I’d missed for years.

Bridge note identification finds the rare notes connecting otherwise isolated clusters. These are often your most original insights — the places where you’ve drawn connections between fields that other people keep separate. Bush would have recognized these as the most valuable trails: the ones that cross disciplinary boundaries.

The Tools: Building a Modern Memex

I tested every major integration path. Here’s what I’d recommend, ranked by complexity.

Tier 1: Direct Filesystem (Start Here)

Just run claude from your vault root. Add CLAUDE.md. Install the official kepano/obsidian-skills — five skill files from Obsidian CEO Steph Ango that teach Claude the full Obsidian format: wikilinks, callouts, Bases, Canvas, and the CLI. Without them, Claude treats [[wikilinks]] as broken Markdown.

npx skills add git@github.com:kepano/obsidian-skills.git

This handles 80% of what I need. I used just this for the first two months.

Tier 2: MCP Server (Structured Search)

When my vault crossed 2,000 notes, I needed structured search. MCPVault is my recommendation: zero Obsidian plugin dependencies, 14 methods, BM25-ranked search, 40–60% smaller token usage.

~/.claude.json:

{
  "mcpServers": {
    "obsidian": {
      "command": "npx",
      "args": ["@bitbonsai/mcpvault@latest", "/path/to/your/vault"]
    }
  }
}

For deeper integration, obsidian-claude-code-mcp runs inside Obsidian with WebSocket auto-discovery. For semantic search, obsidian-mcp-tools integrates with Smart Connections to find conceptually related notes — Bush’s selection by association, mechanized at last.

Tier 3: Graph Analysis (Large Vaults)

TurboVault — a Rust engine with 47 tools, sub-500ms search on 100k notes, SQL queries against frontmatter, and the graph analysis I described above. obsidian-mcp-plugin exposes your vault as a connected knowledge graph with multi-hop traversal and concept discovery.

Tier 4: Embedded Plugins

Claudian and Cortex embed Claude in Obsidian’s sidebar with persistent sessions. Seamless UX, but dependent on plugin maintenance.

The Trail Blazer at Work: Workflows That Earn Their Keep

Bush imagined his Memex user following trails through material, leaving annotations, branching into side trails, and building a personal research path. Here’s what that looks like in 2026.

Automated Backlinking

Read my journal entry for today and add [[wikilinks]] to all 
people, places, and books mentioned. Search the vault for 
existing notes. If none exists, create a stub in 
Resources/People/ or Resources/Places/ with frontmatter.

This is Bush’s trail-building, automated. What used to take 10–15 minutes of manual linking happens while I wait. After three months, my journal entries transformed from dead-end notes into richly connected nodes. Each linked entry gives Claude better context for the next — a compounding effect Bush would have recognized instantly.

Cross-Domain Synthesis (The Trail Across Domains)

This is the workflow that would have made Bush’s pulse quicken — it’s his bow-and-arrow example, realized:

Read my notes in Areas/distributed-systems/ and 
Areas/organizational-design/. Identify concepts that appear 
in both domains or share structural similarities. Write a 
synthesis note at _ai-drafts/cross-domain-synthesis.md. 
Use ONLY content from my notes. Include [[wikilinks]] to 
all source notes.

In his essay, Bush describes a researcher studying why the Turkish bow outperformed the English longbow. The researcher follows a trail from history to an encyclopedia to textbooks on elasticity to tables of physical constants — branching across domains, building a trail that connects military history to materials science. My cross-domain synthesis does the same thing: Claude found that my notes on consensus protocols and decision-making in flat organizations were describing the same coordination problem from different angles. That synthesis became a conference talk. The activation energy of reading 40 notes across two folders and holding them in working memory was too high for me alone. It wasn’t too high for a trail blazer.

Vault Health Audit

Find all orphan notes, notes missing frontmatter, and broken 
wikilinks. Output a report at _ai-drafts/vault-health-report.md.

I run this monthly. Before I started: 9% orphan rate, wildly inconsistent frontmatter. Six months later: orphans below 2%, frontmatter compliance above 95%. Bush worried about trails that fade — in his mechanical system, infrequently followed trails would become harder to find. In a digital vault, the equivalent is orphan notes: captured but never linked, effectively invisible.

Gap Analysis

Examine Areas/investing/ and list topics a practitioner would 
expect but aren't covered by any existing note.

Claude identified that my investing notes had extensive coverage of valuation and moats but almost nothing on position sizing or risk management. That gap was invisible to me for three years. This is the trail blazer’s diagnostic function: not just following existing paths, but identifying where paths should exist but don’t.

Quick CLI Piping

claude -p "Summarize Resources/RFID/ in 200 words" \
  > Resources/RFID-summary.md

The -p (or --print) flag runs Claude non-interactively. I use it for batch operations — a shell script that generates summaries for every folder in Resources/.

Why Obsidian + Claude, Not Notion AI or Logseq + GPT

Bush’s Memex was explicitly personal and local — a desk in your office, your records, your trails. This is the philosophical alignment that makes Obsidian the right foundation:

Local files, not cloud lock-in. My vault is a folder of Markdown files on my filesystem. I own them. I can grep them, git them, or switch tools tomorrow. Bush's Memex didn't phone home to a corporation. Neither does my vault. When I give Claude Code access, it reads the same files I edit in Obsidian — no sync layer, no API translation, no data leaving my machine.

Agentic, not autocomplete. Most AI integrations are autocomplete on steroids. Claude Code is an agent — Bush’s trailblazer. It reads 40 notes, decides which are relevant, creates new files, adds wikilinks, and reports what it did. The difference between “AI-assisted writing” and “AI-assisted knowledge management” is the difference between a faster typewriter and a research partner.

Composable, not monolithic. I can swap MCP servers, change CLAUDE.md, add skills, pipe output through shell scripts. The architecture is layers of plain text and open protocols. Bush designed the Memex as a personal machine you could customize. This philosophy survives.

Your knowledge is the moat, not your tooling. This is the point Cherny made at AI Ascent that maps most directly onto my experience. When Claude Code traverses my vault, the quality of its output depends entirely on the quality of my notes — the links I built, the frontmatter I maintained, the structure I imposed over five years. A fresh vault with 50 scattered notes produces shallow results. A dense, well-linked vault produces synthesis I couldn’t have done manually. The AI amplifies whatever domain knowledge you’ve encoded. Bush understood this about the Memex: the machine is only as good as the trails its owner has laid down.

Claude Code requires a Max subscription or API usage with costs. For my patterns — a few sessions per week, each touching 20–50 notes — the cost is a rounding error next to the consulting hours it saves.

Safety: Keeping the Human in the Loop

Bush’s vision was fundamentally humanist. The Memex would augment thinking, not replace it. The human mind would remain in control of goals, values, and meaning-making. This principle should guide your use of Claude Code with your vault.

Use git. Every change Claude makes becomes a reviewable diff. Every mistake becomes reversible. This is your single most important safety net.

cd ~/vault && git init
echo ".obsidian/workspace.json" >> .gitignore
echo "_attachments/" >> .gitignore

Review staged files before your first commit — don’t accidentally track sensitive data.

Route AI outputs through _ai-drafts/. Claude's work is a draft until you've reviewed it. Your vault should contain your thinking. This is Bush's principle in practice: the machine builds trails, but the human decides which trails to keep.

Constrain synthesis prompts. “Use ONLY content from my notes” prevents Claude from mixing your knowledge with its training data. Without this, you get an authoritative-sounding synthesis containing claims you never made.

Scope requests to specific folders. “Summarize Resources/quantum-computing/” is safe. “Summarize my entire vault” produces shallow results and burns tokens.

The Compound Effect: Trails That Build on Trails

Bush imagined that the Memex’s value would compound: each trail makes the next one easier to build. Each association creates context for future associations. He was describing a positive feedback loop before the term was coined.

That’s exactly what happens in practice. After three months of automated backlinking, my daily notes transformed from dead ends into connected nodes. After six months of health audits, my orphan rate dropped from 9% to under 2%. After running gap analysis on each domain, I started writing notes that fill structural holes rather than pile onto already-dense clusters.

The graph gets denser, more connected, and more navigable — for both me and the AI. Better-linked notes give Claude better context, which produces better suggestions, which creates better links. Bush’s associative trails, once built, make the trail blazer more effective.

This is the trajectory that the Zettelkasten method promised but few achieve manually. The organizational work — backlinking, tagging, formatting, consistency — is exactly what AI excels at. You bring the thinking. Claude brings the bookkeeping.

Getting Started This Week

If you’ve read this far and haven’t started, here’s the 30-minute setup:

1. Install Claude Code — npm install -g @anthropic-ai/claude-code
2. Initialize — cd ~/vault && claude then /init
3. Rewrite CLAUDE.md — use the template above, tailored to your structure and conventions
4. Install obsidian-skills — npx skills add git@github.com:kepano/obsidian-skills.git
5. Run your first audit — “Find all orphan notes and notes missing YAML frontmatter. Output a report to _ai-drafts/vault-audit.md.”

Week 1 challenge: Automate backlinking on 7 daily notes. Run your first vault health audit. Ask Claude to find connections between your two most separate knowledge domains. By Friday, you’ll know whether this transforms your workflow or is just another shiny tool.

I’m betting on the former. Five years of building my vault made it valuable. Connecting it to a trailblazer made that value accessible in ways I hadn’t imagined.

Unfinished Business

Bush closed his essay with a warning and a hope. Information technology, he wrote, represents both a great opportunity and a great risk. The mechanization of memory could elevate human wisdom — or it could become trivial efficiency. The question, he argued, is whether we build tools that make us more thoughtful or tools that simply make us faster.

Eighty years later, that question is more alive than ever. When I ask Claude Code to synthesize across my vault, I’m using the machine Bush imagined — a mechanized supplement to memory that follows associative trails. But the value doesn’t come from the machine. It comes from five years of trials I built by hand: the links, the tags, the front matter, the structure of my thinking encoded in plain text.

Bush’s Memex was never really about the mechanism. It was about augmenting human capability while preserving human agency. Cherny said something similar at AI Ascent, almost offhandedly: the future belongs to people with deep domain knowledge and the judgment to direct machines well. Bush would have agreed — he just would have called them trailblazers.

The vault holds my thinking. The agent follows my trails. And the human decides what it all means.

The Memex is no longer hypothetical. It just looks different from what Bush expected — not a desk with microfilm, but a folder of Markdown files and an agent that can think with them.

Open-source tools referenced: kepano/obsidian-skills (official agent skills), MCPVault (zero-dependency MCP server), TurboVault (Rust graph analysis), obsidian-claude-code-mcp (WebSocket integration), obsidian-mcp-tools (semantic search), Claudian (sidebar plugin). Features current as of May 2026.