Building the Claude Code + Obsidian Vault Stack

A walkthrough for operators who know browser Claude but have never opened a Terminal. From a fresh Mac to a fully-wired AI workspace in about a half-day of patient clicking — or, if you cheat, about 20 minutes.

I'm setting up my Claude Code workspace using the walkthrough at
projects/claude-setup-guide/walkthrough.html (you have file access — read
it if you need details). I've already installed Claude Code (you're
running). Walk me through Chapters 3 through 14 automatically, pausing
when you need input.

PHASE 1 — Vault setup (Chapters 3 + 7):
- Ask me where to put the vault and what to name it (default: ~/Documents/MyVault).
- Create the folder, then build the skeleton: CLAUDE.md, me.md, companies/,
  projects/, .agents/, .claude/skills/, _stack/, .gitignore (with the
  exclusions from Chapter 16).
- Ask me 4–6 questions to populate CLAUDE.md (name, role, companies,
  communication preferences, format I prefer answers in).
- Ask me 4–5 questions to populate me.md.
- Create a stub overview.md inside companies/<slug>/ for each company I list.

PHASE 2 — Status line (Chapter 5):
- Save the statusline-command.sh script to ~/.claude/statusline-command.sh.
- chmod +x it.
- Install jq via brew if missing.
- Add the statusLine block to ~/.claude/settings.json (preserve existing keys).

PHASE 3 — Memory symlink (Chapter 6):
- After I confirm I've launched Claude Code from inside the vault at least
  once (so the project memory folder exists), create the _memory symlink.
- Add a "## Setup notes" section to CLAUDE.md documenting the symlink so
  it survives a fresh clone.

PHASE 4 — Skill bundles + plugins (Chapters 9 + 10):
- Run /plugin marketplace add anthropics/skills, then install
  document-skills and example-skills.
- Run /plugin marketplace add coreyhaines31/marketingskills, then install
  marketing-skills@marketingskills.
- Run /plugin marketplace add obra/superpowers-marketplace, then install
  superpowers@superpowers-marketplace.
- Run /plugin marketplace add kepano/obsidian-skills, then install
  obsidian@obsidian-skills.
- Ask me if I want the Codex plugin; install only if yes.

PHASE 5 — MCP checklist (Chapters 11 + 12):
- Don't try to OAuth MCPs for me. Print a checklist of:
  • Free claude.ai connectors I should connect at claude.ai/settings/connectors
    (Slack, Notion, Gmail, Drive, Calendar, Klaviyo, Shopify, Canva, Sprouts) —
    one line each on what they unlock.
  • Paid (Pipeboard for Meta + TikTok ads) — show me what it costs and the
    `claude mcp add` commands I'll need after I sign up.
  • Local (Playwright, GA4) — show me the exact `claude mcp add` commands.

PHASE 6 — Stack manifest (Chapter 14):
- Create _stack/manifest.md (starter from the walkthrough) and
  _stack/snapshot.sh.
- chmod +x snapshot.sh.
- Run it once and save the output to _stack/snapshot-latest.md.

WRAP-UP:
- Print a "What you still need to do manually" checklist: open Obsidian and
  point it at the vault, install the Dataview community plugin, connect each
  claude.ai MCP in the browser, sign up for Pipeboard if I want it.

Confirm the plan, then start with Phase 1. Ask me anything you need.

0What you're building

The stack is one folder on disk, looked at by three apps that cooperate by reading and writing the same files. Once you see that, everything else slots in.

                              ┌──────────────────────────┐
                              │   ~/Documents/MyVault/   │
                              │   (one folder on disk)   │
                              └────────────┬─────────────┘
                                           │
              ┌────────────────────────────┼────────────────────────────┐
              │                            │                            │
       ┌──────▼──────┐             ┌───────▼───────┐            ┌───────▼───────┐
       │  Obsidian   │             │ Claude Code   │            │   VS Code     │
       │ (notes UI)  │             │  (CLI agent)  │            │ (dev surface) │
       └─────────────┘             └───────┬───────┘            └───────────────┘
                                           │
                          ┌────────────────┼────────────────┐
                          │                │                │
                     ┌────▼────┐      ┌────▼────┐      ┌────▼────┐
                     │ Skills  │      │  MCPs   │      │ Memory  │
                     │(recipes)│      │ (hands) │      │ (brain) │
                     └─────────┘      └────┬────┘      └─────────┘
                                           │
                            ┌──────────────┼──────────────┐
                            ▼              ▼              ▼
                         Slack ▪ Notion ▪ Gmail ▪ Drive
                         Klaviyo ▪ Shopify ▪ Canva
                         Meta Ads ▪ TikTok Ads ▪ GA4 ▪ …

One-sentence definitions, all of which we'll come back to:

• Vault — a folder of plain-text files. Obsidian's word; we'll use it too.
• Claude Code — Anthropic's command-line agent. You talk to it, it reads/writes files in the folder.
• VS Code — your code editor. It hosts a Terminal where Claude Code runs and a tree view of the same folder.
• Obsidian — your notes app. It opens the same folder, treats every .md file as a note.
• MCP (Model Context Protocol) — how Claude reaches outside the folder. Each MCP is a server that gives Claude one specific superpower (read your inbox, post a Slack message, query Shopify).
• Skill — a Markdown file that teaches Claude how to do a specific job (write a cold email, audit SEO, build a slide deck).
• Memory — a folder of small Markdown notes Claude has written about you. Persists between sessions.
• Plugin — a bundle of skills + commands + MCPs + hooks you can install with one command.

Mental model: your filesystem is the database. Three apps look at it. They cooperate by editing the same files.

1Prerequisites — one-time machine setup

Most of this you'll only ever do once per laptop. If a step looks scary, paste the command and read the next paragraph while it runs.

This guide assumes macOS. Windows users: install WSL first and run the Linux versions of these commands inside it.

1.1 Open Terminal

Press ⌘ + Space, type Terminal, hit return. You'll see a window with a blinking cursor. This is where you'll paste commands.

1.2 Install Homebrew (the macOS package manager)

Homebrew installs developer tools. Paste this, hit return, type your password when asked:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

After it finishes it will print 2–3 lines under "Next steps." Copy those lines and paste them too — they add Homebrew to your shell. (brew.sh for reference.)

1.3 Install Node.js, Git, GitHub CLI, Python

brew install node git gh pyenv pipx

What you just installed:

• node — runs JavaScript. Many Claude Code tools depend on it.
• git — version control. Probably already installed; harmless to re-run.
• gh — GitHub's command-line tool. Lets Claude open PRs and issues for you.
• pyenv — switches between Python versions. We'll use it in a moment.
• pipx — installs Python CLI tools without breaking your system Python.

1.4 Set a Python version with pyenv

pyenv install 3.10.4
pyenv global 3.10.4

This makes Python 3.10 the default. Some MCPs need a specific Python version; 3.10 is the safest choice today.

1.5 Install VS Code & Obsidian

• VS Code — download the .dmg, drag to Applications.
• Obsidian — same drill. Don't open or create a vault yet; we'll point it at the right folder in Chapter 3.

1.6 Add the code command

Open VS Code once. Press ⌘ + Shift + P, type "Shell Command", pick "Install 'code' command in PATH". This lets you type code . from the Terminal to open the current folder in VS Code.

2Install Claude Code itself

Claude Code is the CLI that talks to Anthropic's Claude models on your behalf. You'll need a paid Claude plan (Pro or higher) or an Anthropic API key. The walkthrough assumes a paid Claude plan because it's the simplest path.

npm install -g @anthropic-ai/claude-code

Then log in:

claude login

It opens your browser, you click Approve, and you're connected. Done.

3Create the vault folder & point all three tools at it

This is the key chapter. The single folder becomes the Obsidian vault, the Claude Code working directory, and the VS Code workspace — at the same time.

3.1 Make the folder

mkdir -p ~/Documents/MyVault
cd ~/Documents/MyVault

You can name it whatever you want — MyVault is just a placeholder. Mine is called Claude because that's how I think about it.

3.2 Open it in Obsidian

1. Open Obsidian.
2. Click Open folder as vault on the welcome screen.
3. Pick ~/Documents/MyVault.
4. Trust it when prompted ("Yes, I trust the author").

3.3 Turn on the Obsidian features you'll actually use

Settings (gear in the bottom-left) → Core plugins. Make sure these are on: File explorer, Search, Quick switcher, Graph view, Backlinks, Outgoing links, Tags, Page preview, Daily notes, Templates, Properties, Bookmarks, Bases, Sync (Sync is paid; skip if you don't want to pay $4/mo).

Then Community plugins → turn off "Restricted mode" → Browse → search for Dataview → Install → Enable. Dataview lets your memory index render as a live table later.

3.4 Open the same folder in VS Code

code ~/Documents/MyVault

VS Code opens with the folder in the Explorer panel on the left.

3.5 Open Claude Code in that folder

From the Terminal, with you already in the folder from step 3.1:

claude

Claude Code starts. The status line should show your folder name. Quit with /exit or Ctrl+D for now.

4Install the Claude Code VS Code extension

Running Claude Code in a separate Terminal tab works fine. Embedding it inside VS Code is nicer — you see the code Claude is changing in the editor while you chat with it in a side panel.

1. In VS Code, click the Extensions icon in the left rail (or ⌘ + Shift + X).
2. Search for Claude Code.
3. Install the one published by Anthropic.
4. Reload VS Code when prompted.
5. Click the Claude icon in the rail. Sign in (uses the same browser flow as claude login).
6. The extension auto-detects the workspace you have open. You're done.

5The status line that doesn't suck

Out of the box, Claude Code's status line is minimal. Here's a one-file replacement that shows three things at a glance: working directory, model, and how much context you've used.

5.1 Save the script

Save the following as ~/.claude/statusline-command.sh:

#!/usr/bin/env bash
# ~/.claude/statusline-command.sh
# Displays: working directory | model | context usage

input=$(cat)

cwd=$(echo "$input" | jq -r '.workspace.current_dir // .cwd // ""')
dir=$(basename "$cwd")
model=$(echo "$input" | jq -r '.model.display_name // .model.id // "unknown"')

used_pct=$(echo "$input" | jq -r '.context_window.used_percentage // empty')
total=$(echo "$input" | jq -r '.context_window.context_window_size // 200000')
input_tokens=$(echo "$input" | jq -r '.context_window.total_input_tokens // 0')

if [ -n "$used_pct" ]; then
  used_int=$(printf '%.0f' "$used_pct")
  if [ "$total" -ge 1000000 ]; then
    total_fmt="$(echo "$total" | awk '{printf "%.0fM", $1/1000000}')"
  else
    total_fmt="$(echo "$total" | awk '{printf "%.0fK", $1/1000}')"
  fi
  tokens_k=$(echo "$input_tokens" | awk '{printf "%.0fK", $1/1000}')
  ctx="${tokens_k}/${total_fmt} (${used_int}%)"
else
  ctx="--"
fi

printf "%s  |  %s  |  ctx: %s\n" "$dir" "$model" "$ctx"

Then make it executable:

chmod +x ~/.claude/statusline-command.sh

Install jq if you don't have it:

brew install jq

5.2 Wire it in ~/.claude/settings.json

Open ~/.claude/settings.json in VS Code:

code ~/.claude/settings.json

Make sure it contains (creating the file if needed):

{
  "statusLine": {
    "type": "command",
    "command": "bash ~/.claude/statusline-command.sh"
  }
}

Set up my Claude Code status line from Chapter 5 of the walkthrough at
projects/claude-setup-guide/walkthrough.html. Save the script to
~/.claude/statusline-command.sh, chmod +x it, install jq via brew if it
isn't already, and add the statusLine block to ~/.claude/settings.json
without overwriting any existing keys. Print the final settings.json so I
can sanity-check it.

6Memory — making Claude remember between sessions

By default, Claude Code forgets you between sessions. The auto-memory system fixes that: Claude writes small Markdown notes about you and reads them back next time.

6.1 Where memory lives

Claude Code stores per-workspace memory at:

~/.claude/projects/<encoded-path>/memory/

The encoded path is your vault's absolute path with slashes replaced by dashes. For ~/Documents/MyVault it becomes -Users-yourname-Documents-MyVault. Inside that folder is one Markdown file per memory plus a master MEMORY.md index.

6.2 The symlink trick

Memory living deep inside ~/.claude is invisible to Obsidian. Fix: symlink the memory folder into your vault as _memory. Both apps now see the same files.

cd ~/Documents/MyVault
ln -s ~/.claude/projects/-Users-$(whoami)-Documents-MyVault/memory _memory

(Adjust the -Users-... path to match yours exactly. ls ~/.claude/projects/ will show you the right one.)

6.3 Render the index in Obsidian

Open _memory/MEMORY.md in Obsidian. At the bottom of the file Claude maintains a Dataview block like this:

```dataview
TABLE type, description
FROM "_memory"
WHERE type
```

Switch the note to Reading view (top-right toggle). The block renders as a live table of every memory, grouped by type.

6.4 How to add memories

You don't. You just tell Claude things, and it writes them. Examples that work in practice:

• "Remember that I prefer terse responses with no trailing summaries."
• "I'm CEO of Acme. We sell B2B widgets. Don't suggest consumer marketing tactics."
• "My wife's name is Ashley. Our anniversary is June 12."

Claude writes one file per memory under _memory/ and updates MEMORY.md automatically.

Set up the memory symlink described in Chapter 6 of the walkthrough at
projects/claude-setup-guide/walkthrough.html. Look up the encoded vault
path automatically (the folder under ~/.claude/projects/ whose name
matches this vault's absolute path with slashes replaced by dashes).
Create the symlink at ./_memory pointing to that folder, then verify by
listing _memory/. If the project folder doesn't exist yet, tell me to
restart Claude Code from inside the vault and try again. Also add a
"## Setup notes" section to my CLAUDE.md documenting the symlink command
so it survives a fresh clone.

7The vault layout

Claude Code is unopinionated about how you organize the vault, but a few special files are auto-loaded if they exist. Here's the layout I use; copy what's useful, skip what isn't.

~/Documents/MyVault/
├── CLAUDE.md                  # Project instructions — auto-loaded every session
├── me.md                      # Operator profile — referenced by CLAUDE.md
├── _memory → ~/.claude/.../   # Symlinked memory dir (Chapter 6)
├── _dashboard.md              # Optional — your morning dashboard
├── companies/                 # One folder per business
│   ├── <slug>/
│   │   ├── overview.md        # Role, status, current priorities
│   │   ├── brand.md           # Voice, tone, do/don't
│   │   ├── stack.md           # Tools used by this company
│   │   ├── campaigns/         # Active campaigns
│   │   └── operations/        # Custom scripts/SOPs
├── projects/                  # Personal projects (parallel to companies)
│   └── <slug>/
├── .agents/                   # Per-company evergreen positioning
│   └── <slug>/
│       └── product-marketing-context.md
├── .claude/
│   ├── settings.local.json    # Workspace permissions
│   └── skills/                # Project-level skills (vault-specific)
├── _stack/                    # Inventory & audit (Chapter 14)
│   ├── manifest.md
│   ├── snapshot.sh
│   └── snapshot-latest.md
└── .gitignore

The most important file: CLAUDE.md

Anything in CLAUDE.md at the vault root is automatically loaded into every Claude Code session. Treat it as your standing orders. Skeleton:

# Claude Context — Your Name

## Who I Am
1–2 paragraphs: your role, what you do, how you make decisions.

## How to Work With Me
- Be direct. Recommendations, not menus.
- Match format to task — bullets for lists, prose for strategy.
- Flag tradeoffs but skip the basics.
- (whatever else matters to you)

## What I Need Help With
Bullet list of recurring task types.

## My Companies
| Company | Role | Status | Folder |
|---|---|---|---|
| Acme   | CEO  | Active | [companies/acme/](companies/acme/) |
| …      | …    | …      | …                                  |

## My Personal Profile
→ [me.md](me.md)

Build my vault skeleton from Chapter 7 of the walkthrough at
projects/claude-setup-guide/walkthrough.html. Create CLAUDE.md, me.md,
companies/, projects/, .agents/, .claude/skills/, _stack/, and .gitignore
(with the Chapter 16 exclusions).

Then interview me to populate the files:
1. For CLAUDE.md — ask me 4-6 questions covering my name, role, what kinds
   of work I want help with, format preferences (bullets vs prose), and a
   list of my companies/projects with one line on each.
2. For me.md — ask me 4-5 questions: background, technical comfort, working
   style, current priorities.
3. For each company I named — create companies/<slug>/overview.md and
   companies/<slug>/CLAUDE.md with 5-line stubs.

Read back each file before saving. Don't overwrite anything that already
exists; if a file is there, show me the diff and ask before merging.

8Skills 101

A skill is a single Markdown file that teaches Claude how to do one specific job. Frontmatter at the top tells Claude when to use it; the body is the actual instructions.

---
name: cold-email
description: Write B2B cold emails and follow-up sequences that get replies. Use when the user wants outbound emails, prospecting, SDR emails…
---

You are an experienced SDR. When writing cold emails:
1. Open with a specific observation, not a flattery.
2. Keep it under 90 words.
3. CTA = one easy yes.
…

Two places skills can live:

• User skills at ~/.claude/skills/ — available in every workspace.
• Project skills at <vault>/.claude/skills/ — only available in this vault.

Claude reads the description of every available skill at session start and picks the right one based on what you ask. You don't have to invoke them by name (though you can, by typing /skill-name).

9Install skill bundles

You could write skills from scratch. You shouldn't have to — the community has published dozens of good bundles you can install in one command. Here are the four I recommend, in order.

9.1 Anthropic's official skills

Document creation (docx, pdf, pptx, xlsx) plus example skills (canvas-design, mcp-builder, slack-gif-creator, web-artifacts-builder, etc).

Inside Claude Code:

/plugin marketplace add anthropics/skills

/plugin install document-skills@anthropic-agent-skills
/plugin install example-skills@anthropic-agent-skills

Source: github.com/anthropics/skills

9.2 Marketing Skills (Corey Haines)

~30 skills covering SEO, CRO, copywriting, paid ads, lifecycle email, analytics — the closest thing to a packaged AI CMO.

/plugin marketplace add coreyhaines31/marketingskills
/plugin install marketing-skills@marketingskills

Source: github.com/coreyhaines31/marketingskills

9.3 Superpowers (Jesse Vincent)

A complete software-development methodology delivered as skills + agents + hooks. TDD, brainstorming, plan-writing, code review, subagent-driven dev. If you do any coding via Claude, install this.

/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

Source: github.com/obra/superpowers-marketplace

9.4 Obsidian Skills (Steph Ango / kepano)

Teaches Claude how to write proper Obsidian-flavored Markdown (wikilinks, callouts, properties), edit .canvas and .base files, and use the Obsidian CLI. Crucial if you want Claude's notes to feel native to Obsidian.

/plugin marketplace add kepano/obsidian-skills
/plugin install obsidian@obsidian-skills

Source: github.com/kepano/obsidian-skills

Install the four recommended skill bundles from Chapter 9 of the
walkthrough at projects/claude-setup-guide/walkthrough.html. Do them one
at a time, in this order, pausing after each to print what was added:

1. /plugin marketplace add anthropics/skills, then /plugin install
   document-skills@anthropic-agent-skills and example-skills@anthropic-agent-skills
2. /plugin marketplace add coreyhaines31/marketingskills, then
   /plugin install marketing-skills@marketingskills
3. /plugin marketplace add obra/superpowers-marketplace, then
   /plugin install superpowers@superpowers-marketplace
4. /plugin marketplace add kepano/obsidian-skills, then /plugin install
   obsidian@obsidian-skills

After each, list the skills it added (one per line, name + 1-line
description). At the end, confirm ~/.claude/plugins/installed_plugins.json
has all four registered.

10Plugins

You already installed plugins in the previous chapter — that's all a "plugin" really is, just a bundle that can contain skills, slash commands, agents, hooks, and MCP configs in one install.

Two more plugins worth installing:

10.1 Codex (OpenAI)

Lets Claude hand a coding task to GPT-5 / Codex CLI for a second opinion or a rescue. Useful when Claude is stuck.

/plugin marketplace add openai/codex-plugin-cc
/plugin install codex@openai-codex

You'll also need the Codex CLI on your machine — install per github.com/openai/codex.

10.2 The official Anthropic plugin marketplace

A curated directory of vetted plugins. Adding it makes them all discoverable via /plugin.

/plugin marketplace add anthropics/claude-plugins-official

Then browse with /plugin and install any that interest you.

11MCPs 101

An MCP (Model Context Protocol server) gives Claude one specific superpower: read your inbox, post to Slack, query a database. Each MCP defines a set of tools Claude can call.

Three flavors, easiest first:

1. claude.ai-hosted connectors — you connect them once in your browser at claude.ai → Settings → Connectors. They auto-appear in Claude Code under the prefix claude.ai <Name>. No local install. This is how you'll add 90% of MCPs.
2. Remote HTTP MCPs — you paste a URL into Claude Code; it auths in browser. Pipeboard Meta-ads is one of these.
3. Local stdio MCPs — Claude Code spawns a process on your machine. Used when the MCP needs filesystem access (Playwright) or local credentials (GA4 with a service-account JSON).

Useful commands:

• /mcp inside Claude Code — list everything wired up and their auth state.
• claude mcp list from a shell — same thing.
• claude mcp add <name> <command-or-url> — register a new local or HTTP MCP.

12Recommended MCP set

Do these in order. The free/hosted ones first; the paid and local ones only if you need them.

12.1 Free claude.ai connectors

Go to claude.ai → Settings → Connectors and connect (you'll be redirected to each provider's OAuth):

• Slack — read channels, post messages, react.
• Notion — read pages, create/update databases.
• Gmail — search threads, read, draft.
• Google Drive — read/create files, search.
• Google Calendar — list events, create, suggest times.
• Klaviyo — campaigns, flows, segments, templates.
• Shopify — products, orders, customers, GraphQL queries.
• Canva — designs, brand templates, comments.
• Sprouts Data Intelligence — contact/account enrichment.

12.2 Pipeboard — Meta & TikTok Ads (paid)

Neither Meta nor TikTok publishes its own AI-friendly MCP. Pipeboard is the practical workaround. Sign up, connect your Meta Business Manager and TikTok Ads accounts, copy the MCP URLs they give you, then in Claude Code:

claude mcp add meta-ads "https://mcp.pipeboard.co/meta-ads-mcp" --transport http
claude mcp add tiktok-ads "https://tiktok-ads.mcp.pipeboard.co" --transport http

(Pipeboard is ~$25–50/month last I checked; verify pricing on their site.)

12.3 Google Analytics 4 (free, local)

For GA4 you need a service-account JSON file with read access to your GA4 property.

1. In Google Cloud Console, create a service account, download its JSON key.
2. In GA4, grant that service account's email "Viewer" on the property.
3. Install the MCP:

claude mcp add google-analytics "pipx run analytics-mcp" \
  --env GOOGLE_APPLICATION_CREDENTIALS=/full/path/to/key.json

12.4 Playwright (free, local — browser automation)

Lets Claude open a real Chrome browser, click around, take screenshots. Critical if you want it to verify visual changes or scrape paywalled UIs.

claude mcp add playwright "npx -y @playwright/mcp@latest --user-data-dir ~/.cache/playwright-meta-profile"

The --user-data-dir flag is the trick: the browser profile persists across sessions, so you only have to log into Meta / TikTok / Google once.

13A daily flow — how it all comes together

Here's a worked example so the three-app cooperation makes sense:

It's Monday morning. You open Obsidian and glance at _dashboard.md, which Claude refreshed yesterday — Meta spend, TikTok results, Klaviyo open rates, pending decisions.

You open VS Code, open the Claude panel, and say:

"Refresh the dashboard. Pull yesterday's Meta + TikTok + Klaviyo numbers, flag anything outside its target, and add a 'pending actions' section."

Claude Code does the work in the background:

1. Reads _dashboard.md to learn what's there and what the targets are.
2. Calls the Meta-ads MCP (yesterday's spend + conversions).
3. Calls the TikTok-ads MCP.
4. Calls the Klaviyo MCP (yesterday's flow + campaign performance).
5. Composes the new dashboard and writes it to _dashboard.md.

Obsidian's file watcher notices the change and re-renders the note. You haven't switched apps; you watched the dashboard update in front of you while Claude worked.

The pattern repeats for everything: open Obsidian to read; talk to Claude to write; let VS Code show you the diff if something looks off.

14Stack manifest + weekly audit (power-user)

Once you have a dozen MCPs, several plugins, and a pile of custom scripts, you'll want a way to remember what's installed and detect drift. Two files do it:

14.1 _stack/manifest.md — what should be installed

A Markdown file you maintain by hand. Headings: Claude Code, Integrations — interface verdicts (CLI vs MCP per integration), MCP Servers, Plugins, Skills, Custom Tooling, Change log. Update it any time you intentionally install or remove something.

14.2 _stack/snapshot.sh — what is installed

A shell script that prints the current reality:

#!/usr/bin/env bash
set -u
echo "# Stack Snapshot — $(date '+%Y-%m-%d %H:%M %Z')"
echo
echo "## MCP Servers"; claude mcp list
echo "## Claude Code CLI"; claude --version
echo "## Installed Plugins"; cat ~/.claude/plugins/installed_plugins.json
echo "## User Skills"; ls ~/.claude/skills/ | sort
echo "## Project Skills"; ls "$(dirname "$0")/../.claude/skills/" | sort
echo "## Key CLIs"
for cli in node npm python3 pyenv pipx gh git playwright codex; do
  command -v "$cli" >/dev/null 2>&1 && printf -- "- %s: %s\n" "$cli" "$("$cli" --version 2>&1 | head -1)"
done
echo "## Homebrew outdated"; brew outdated | head -30
echo "## npm global outdated"; npm outdated -g --depth=0

Run it weekly, diff the output against manifest.md, action anything that drifted.

Set up the stack manifest and audit system from Chapter 14 of the
walkthrough at projects/claude-setup-guide/walkthrough.html.

1. Create _stack/manifest.md as a starter (a template I can fill in) with
   the sections: Claude Code, Integrations (interface verdicts), MCP
   Servers, Plugins, Skills, Custom Tooling, Change log.
2. Create _stack/snapshot.sh from the walkthrough's verbatim script.
3. chmod +x _stack/snapshot.sh.
4. Run it once and pipe the output to _stack/snapshot-latest.md.
5. Print a short summary of what's in the snapshot so I can sanity-check.

Also add this to my .gitignore if it isn't there yet:
_stack/snapshot-latest.md

15Custom CLI tooling (power-user)

Sometimes an MCP doesn't exist for the API you need, or the MCP is too rigid (no bulk ops, no parallel calls). Write a small CLI instead.

Template, in Python:

#!/usr/bin/env python3
"""my-tool — short description.

Usage:
  my-tool whoami
  my-tool list-something
  my-tool do-thing --id 123 --dry-run
"""
import os, sys, json, argparse, requests
from dotenv import load_dotenv

load_dotenv()

API_TOKEN = os.environ["MY_API_TOKEN"]
BASE = "https://api.example.com/v1"

def whoami():
    r = requests.get(f"{BASE}/me", headers={"Authorization": f"Bearer {API_TOKEN}"})
    print(json.dumps(r.json(), indent=2))

# … more subcommands …

def main():
    p = argparse.ArgumentParser()
    sub = p.add_subparsers(dest="cmd", required=True)
    sub.add_parser("whoami")
    # …
    args = p.parse_args()
    {"whoami": whoami}[args.cmd]()

if __name__ == "__main__":
    main()

Save it under companies/<company>/operations/my-tool.py. Claude Code can call it directly via the Bash tool: "Run my-tool whoami and tell me what you see."

Two rules that make CLI tools work well with Claude:

• Output JSON by default — Claude parses it instantly. Pretty-print only if a human is reading.
• Include a --dry-run flag on anything that writes. Claude will use it before doing the real thing if you ask.

16Keeping it healthy

What to back up

• ~/Documents/MyVault/ — the whole vault. Either git-version it, or rely on Obsidian Sync.
• ~/.claude/ — your global Claude Code config, memory, plugins. Time Machine covers this; or rsync it monthly.

How to update

claude --version          # check Claude Code
npm update -g @anthropic-ai/claude-code
/plugin update            # inside Claude Code, updates all installed plugins
brew upgrade              # macOS tools
npm install -g npm@latest
pipx upgrade-all          # Python CLIs (including analytics-mcp)

.gitignore for the vault

If you put the vault under git (worth doing), drop this in at minimum:

# Secrets
**/.env
**/.env.*
!**/.env.example

# Claude Code transient state
.playwright-mcp/
.last-cleanup
_stack/snapshot-latest.md

# Standard junk
.DS_Store
node_modules/
__pycache__/
.venv/

# Obsidian transient
.obsidian/workspace.json
.obsidian/cache/

Obsidian Sync (optional, $4/mo)

Settings → Sync. Pick the vault, pick which folders to include (exclude .playwright-mcp/, node_modules/, the cloned skill repos). You now have the same vault on every Mac, iPhone, iPad you log into. Worth it if you context-switch across devices.

17Glossary & all links

Glossary

Every download in this guide