Obsidian

1 - Run Claude Code inside my Obsidian

I run Claude Code inside my Obsidian vault through a terminal extension. This lets me treat the AI as a collaborator that can read, write, and traverse my notes.

The structure

My vault follows a light hierarchy:

• 01 Inbox for quick capture
• 02 Journal for reflections and plans
• 03 Garden for permanent, evergreen notes
• 04 Projects for active work, each in its own folder
• 05 Areas for ongoing life contexts

The Garden is where ideas mature. Notes there are atomic (one idea each), opinionated (stating positions rather than describing topics), and linked to each other. They accumulate slowly.

Projects live in separate folders. I can open a terminal in any project folder and give Claude Code the specific context it needs. The AI sees only what’s relevant.

Maps of Content

I maintain a handful of Maps of Content (MOCs) that act as entry points into clusters of ideas. These are pages that link to related notes on a theme: creative work, tools for thought, software philosophy, focus, durability, self-experimentation.

MOCs help me and the AI navigate. When I ask Claude to explore a topic, I can point it to the relevant MOC instead of hoping it finds the right notes through search alone.

How Claude Code fits in

The point is not to have AI write for me. It’s to think alongside something that can hold more context than I can in my head at once.

The terminal interface matters. I’m not pasting notes into a chat window. Claude can use tools: reading files, searching across the vault, writing drafts directly where they belong. It operates inside my system rather than alongside it.

Common patterns:

• Filling gaps: I have scattered thoughts across journal entries and inbox notes. I ask Claude what’s missing, what I haven’t addressed, where the argument is weak.

• Surfacing connections: It finds relationships between notes I hadn’t linked. Sometimes it surfaces tensions or contradictions I’d missed.

• Deepening thinking: I describe a half-formed idea. Claude asks questions, challenges assumptions, helps me see angles I hadn’t considered. The goal is sharper thinking, not finished prose.

• Drafting from my material: When I do ask it to write, it’s working from my notes, my fragments, my voice. The output is a starting point I’ll rewrite.

The AI becomes useful when it has real context and when I stay in the loop. A vault full of linked notes provides the context. Staying critical of the output keeps the thinking mine.

Daily practice

I write daily notes when something needs processing. These go in the Journal, not the Garden. They’re messy, personal, often questions more than answers.

Periodically I review the Journal and promote ideas worth keeping into proper evergreen notes. Claude can help with this: “What themes keep appearing in my recent journal entries?”

What this isn’t

The system is simple. There’s no elaborate tagging taxonomy, no complex automation, no perfect template. I’ve tried those approaches. They create maintenance burden that eventually collapses.

The current setup works because it’s light enough to actually use. Five folders. A few MOCs. Notes that link to each other. An AI that can read and write in place.

For those exploring this

The ideas behind evergreen notes come largely from Andy Matuschak (@andy_matuschak), who has published extensively on the topic at notes.andymatuschak.org. His work on making notes atomic, concept-oriented, and densely linked shaped how I think about the Garden. His notes are themselves an example of the method.

For the underlying methodology, I recommend How to Take Smart Notes by Sönke Ahrens. It explains the Zettelkasten approach that influenced much of modern networked note-taking. The core insight: writing is thinking, and a good note system makes thinking accumulate.

The right setup depends on what you’re trying to do. Mine is optimized for accumulating clear thinking over time and having an AI collaborator that can work with that accumulated context. Yours might need something different.

Start light and add structure only when you feel its absence.

2 - ultrathink

as someone who’s been using it heavily for 9 months, here are my top tips to maximize its potential: getting started & configuration customize your status line - use /statusline to show your current model, git branch, and token usage. keeps you aware of what’s going on learn essential slash commands - /usage (rate limits), /chrome (browser), /mcp (tools), /stats (activity), /clear (fresh start). these are your power moves use claude. md for project context - create a claude. md file in your project root with commands, style guides, and setup instructions. claude pulls it in automatically create custom slash commands - turn your repetitive workflows into custom commands by adding markdown files to .claude/commands. automate the boring stuff configure allowed tools - use /permissions or edit .claude/settings.json to let claude use certain tools without asking every time. saves you a ton of back-and-forth install the gh cli - if you’re on github, grab the gh command-line tool. makes it way easier for claude to create issues and prs use terminal aliases - create alias c=‘claude’ so you’re not typing the full command constantly. small thing, big quality of life improvement prompting & interaction use voice input - talking is faster than typing. grab a local transcription tool and just talk to claude. it understands even with typos break down large problems - don’t throw a massive problem at claude. split it into smaller pieces and solve them one by one. works way better use the “think” keyword - when you want claude to really dig deep, use “think,” “think hard,” “think harder,” or “ultrathink” to give it more thinking time provide detailed specs - for bigger tasks, write a proper spec in markdown. more detail upfront means better results. worth the effort use @ to reference files - point claude to specific files with @ instead of just describing them. clearer and you get tab auto-completion interrupt and add context anytime - if claude’s going the wrong way or you think of something important, just type it. claude will pick it up and adjust on the fly workflow & best practices minimize context - start a fresh conversation for each new task. long chats with irrelevant stuff actually make claude perform worse plan before coding - hit shift+tab twice for planning mode. let claude map out the solution before writing code. saves so much time use git for version control - commit often. if claude messes up, just git restore and try again with a better prompt. no stress let claude handle git operations - ask claude to write commits and commit messages. it’s surprisingly good at it and you’ll get better messages always verify output - check what claude gives you. have it write tests, review changes, or create a draft pr. don’t ship blind use handoff documents for long tasks - for multi-session work, ask claude to write a handoff doc summarizing what it did, what worked, and what’s next. makes pickups way easier try test-driven development - have claude write failing tests first, then code to make them pass. powerful workflow that leads to better code advanced techniques use subagents for complex problems - for tricky research or investigation, tell claude to use subagents to verify details. keeps your main chat clean create feedback loops - for stubborn bugs, set up a loop where claude builds, runs, checks output, and tries again on its own. let it grind use tmux for interactive clis - when working with interactive command-line stuff, use tmux so claude can send commands and capture output clone and half-clone conversations - use clone to copy a conversation or half-clone to keep only the recent half. quick way to manage context juggle multiple sessions - run multiple claude instances in different tabs. focus on a few tasks at a time and switch between them. solid multitasking approach