Claudesidian: Unix Pipes for Your Second Brain

TL;DR

Claudesidian lets you treat your Obsidian vault like a Unix filesystem for your brain: small, composable Claude Code commands that grep/sed/awk your notes into shape — with persistent, inspectable AI memory that lives in plain Markdown.

---

Why devs should care

If you live in a terminal and your notes live in Obsidian, this is the crossover episode.

Most “AI note” tools try to trap you in a proprietary app, a weird database, or an opaque embedding index. Claudesidian flips that script:

• Your vault is the memory
• Your Markdown is the database
• Claude Code is basically a programmable shell over it

Instead of one giant "do everything" AI agent, you get Unix-style tools: small, focused commands you can chain, remix, and trust because you can see what they do in your files.

If grep | sed | awk changed how you think about text, Claudesidian will blow your mind about AI + notes.

---

The core idea: AI as a shell, vault as memory

The Claudesidian pattern is simple but powerful:

1. Keep everything in plain Markdown inside your Obsidian vault
2. Use Claude Code to run tiny, composable commands against that vault
3. Treat those commands like Unix tools: they do one thing well
4. Build higher-level workflows by chaining them

No custom DB, no secret indexes — just files you can open, diff, grep, and version control.

Think of it like this:

• Obsidian = your filesystem + editor
• Claude Code = your AI-powered shell
• Claudesidian commands = scripts that transform and refactor your notes

---

Setup: point Claude at your vault

At a high level, you:

• Have an Obsidian vault (a folder of Markdown files)
• Run Claude Code in that folder so it can operate on your notes
• Add your own small command files in a .claude/commands directory

Once that’s wired up, you can say things like:

“Run refactor-note on 2025-01-07 design doc and summarize decisions at the top.”

…and Claude will execute your custom command logic against real files in your vault.

---

Example 1: summarize-note — grep for meaning

Let’s start with a tiny command that gives you an always-up-to-date summary section at the top of any note.

Create .claude/commands/summarize-note.md in your vault:

# summarize-note
 
You are a note refactoring command for my Obsidian vault.
 
Goal:
- Read the target Markdown file
- Generate a concise "Summary" section in bullet form
- Insert or update a `## Summary` block at the top of the note
 
Rules:
- Keep it under 8 bullets
- Preserve all existing content below the summary
- Never delete sections; only reorganize if obviously helpful
 
Steps:
1. Open the specified note file.
2. Analyze the content and pull out key decisions, concepts, and todos.
3. Create a `## Summary` section.
4. If a `## Summary` already exists, replace just that section.
5. Save the updated note.

In Claude Code you can now do something like:

# Inside your vault directory
claude
 
# In the Claude session
/run summarize-note file="notes/system-design/cache-strategy.md"

You’ve essentially created an AI equivalent of head | grep important-stuff, but for ideas.

---

Example 2: extract-concepts — awk for knowledge

Now let’s build a command that scans a note and extracts reusable concepts into a separate “library” note.

Create .claude/commands/extract-concepts.md:

# extract-concepts
 
Purpose:
- Scan a source note for recurring concepts, patterns, or definitions
- Append them to a central `Concepts.md` file in the vault
 
Behavior:
- Each concept should have:
  - A short title
  - 2–4 sentence explanation
  - A "See also" list of related notes (by relative path)
- Do not duplicate concepts that already exist; merge or improve instead.
 
Steps:
1. Read the source note provided as `file`.
2. Identify 3–10 key concepts.
3. Open or create `notes/Concepts.md`.
4. For each concept, either:
   - Add a new `### Concept Name` section, or
   - Update an existing one with better wording.
5. Save `Concepts.md`.

Usage in Claude Code:

/run extract-concepts file="notes/blog/ai-shell-architecture.md"

Now your vault slowly grows a high-quality, AI-maintained concepts library — in a single Markdown file you can open, link, and search.

---

Example 3: link-notes — automatic grep + backlinks

Last one: auto-link related notes like a smart grep that writes the backlinks for you.

# link-notes
 
Objective:
- For a given note, find other notes in the vault that are clearly related
- Insert wiki-style links between them using Obsidian's `[[Note Title]]` syntax
 
Constraints:
- Do not create more than 15 new links in one run
- Prefer linking to existing, high-signal notes (longer, more structured)
- Never change code blocks, YAML frontmatter, or fenced sections
 
Steps:
1. Read the target note specified as `file`.
2. Search the vault for notes with overlapping topics.
3. Propose a set of new links.
4. Insert links inline where they naturally fit.
5. At the bottom of the note, add a `## Related` section with bullet links.
6. Save the updated note.

Usage:

/run link-notes file="notes/research/vector-databases.md"

You just built a mini, transparent AI backlink engine — no opaque embedding graph required.

---

Why this matters

A few reasons this approach is sneaky-powerful:

- Chain them (summarize-note → extract-concepts → link-notes) - Swap one out without breaking everything - Share them like dotfiles

• Plain text forever: Your “AI memory” is just Markdown. No lock-in, no mystery DB.
• Version control friendly: Every AI change is a diff you can inspect and revert.
• Composable: Small commands > giant monolithic agents. You can:
• Auditable AI: The behavior lives in .claude/commands/*.md. You can read the “source” and tweak how your AI behaves.

It’s very much the Unix philosophy, but applied to your second brain.

---

Practical use cases

Here are a few ways devs can put Claudesidian-style commands to work:

- Command to "clean up today’s note": move todos to a central task file, extract decisions, update summary.

• Daily note hygiene

- Command to normalize headings, pull out API contracts, and create a separate Open Questions section.

• Refactoring design docs

- Command that scans new notes tagged #learned-today and appends key takeaways to a Learning Log.md.

• Learning logs

- Command that compiles all notes under projects/foo/ into a single status dashboard with links and summaries.

• Project dashboards

- Command that pulls insights from past code reviews into a Guidelines note, grouped by language or repo.

• Code review knowledge

Each is just another little Markdown “program” living in .claude/commands/.

---

Try it yourself

1. Point Claude Code at your Obsidian vault.
2. Create a .claude/commands/ folder.
3. Drop in one tiny command (start with summarize-note).
4. Run it on a messy note you care about.
5. Iterate like you would on a shell script.

If Unix gave you superpowers over files, Claudesidian gives you superpowers over knowledge. And the best part: it all lives in plain Markdown, under your control.