Run your company on a vault an AI can actually operate.

01 · The mental model

Two tools, one job: a brain the AI can hold in its hands

The whole system is two pieces that most people use separately, wired together on purpose.

Because both tools point at the exact same folder of Markdown, they share one source of truth. You edit a note by hand in Obsidian; the AI reads it a second later. The AI writes a note; it shows up in Obsidian instantly. There is no "upload," no "sync my documents," no copy-paste. The folder is the product.

Everything below is in service of that principle: structure so files are findable, conventions so they're consistent, instruction layers so the AI knows the house rules, and tooling so it can turn notes into finished documents.

02 · Setup

Install everything (and why each piece matters)

Do these in order. The instructions below are for macOS, which is the smoothest path; Windows works too via WSL. None of this requires you to be a programmer, but you will spend twenty minutes in the Terminal. That is the price of admission.

1. Obsidian

Download from obsidian.md. On first launch, choose Create new vault and pick (or make) a folder. That folder is your vault. Obsidian is just a nice window onto it, the real thing is the folder.

2. Homebrew (the package manager)

Homebrew is how macOS installs command-line tools. Almost everything else depends on it. Paste this into Terminal:

# Installs Homebrew, the macOS package manager
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

3. Node.js (the runtime Claude Code needs)

brew install node

This gives you node and npm. Claude Code runs on Node, and so do the document-building libraries later.

4. Claude Code (the agent)

Install it globally with npm, then run it from inside your vault folder:

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

# then, whenever you want to work:
cd "/path/to/your/Vault"
claude

The first time, it walks you through signing in. From then on, typing claude while your Terminal is "inside" the vault folder drops you into a conversation where the AI can see every note.

03 · Setup

The tool kit: what turns notes into finished documents

The AI can write Markdown all day. But when you want a real, branded PDF, Word doc, spreadsheet, or slide deck, it needs command-line tools to build those files. Install this set once and the agent can produce polished deliverables on demand. These are the specific, load-bearing ones.

The full install script for all of this is in the starter kit at the end.

04 · Setup

Folder architecture: number your folders

A vault with 40 folders in alphabetical order is chaos. The fix is dead simple: prefix folders with numbers so they sort by workflow, not by name. This is the single highest-leverage structural decision you'll make.

00-Inbox/            # unsorted captures land here first
04-Transcripts/      # raw verbatim meeting/call transcripts
05-Dashboards/       # live rollups and views
10-Division-A/       # your first business unit
11-Division-B/
13-Shared-Services/  # finance, HR, IT, brand
15-People/           # profiles by role
50-Long-Term/        # permanent reference material
60-Short-Term/       # active working context
70-Templates/        # reusable note + document templates
80-Archive/          # completed / inactive
90-System/           # config, rules, taxonomy, brand guides

The pattern: low numbers for daily flow (inbox, transcripts), a middle band for your actual business areas, and high numbers (50/60/70/80/90) for reference, templates, and system config. The 90-System folder is special, it holds the files that govern how the AI behaves. Keep it clean; it's the control room.

Inside each folder, one note per thing: one file per person, per property, per project, per decision. Small, single-purpose notes link together far better than giant catch-all documents.

05 · Setup

Keep your vault clean: separate the workshop from the library

This is the rule people most often get wrong, and it matters. Your vault should contain Markdown only, text, notes, knowledge. It should never fill up with PDFs, Word files, spreadsheets, images, and half-built drafts. Those are output, not knowledge.

Tell the agent this explicitly in your rules: "Structured/final documents (PDF, DOCX, XLSX, PPTX) save to the output folder. Never save binary files into the vault, Markdown only." Two benefits fall out of this:

• Obsidian stays fast and searchable. It's a text engine; a vault stuffed with binaries gets slow and noisy.
• Sync stays sane. If your vault lives in a cloud-synced folder shared with colleagues, you want to sync lightweight text, not 40MB decks.

06 · How it thinks

The instruction layers: how the AI knows your house rules

Here is the part that makes this feel like magic. The agent doesn't guess how your company works, it reads layered instruction files that you write once and it obeys every session. Think of it as an onboarding manual the AI re-reads automatically. There are four layers, from broadest to most specific.

They compose. For a task, the AI starts from the constitution (Layer 1), applies whatever it has learned about you (Layer 2), follows the relevant procedure (Layer 3), and adopts the right expert voice (Layer 4). You are effectively programming the agent in plain English, no code, just well-organized instructions.

The next three sections cover the two layers you'll touch most: CLAUDE.md and memory, plus how to write good rules.

07 · How it thinks

CLAUDE.md: the file that governs everything

A file named exactly CLAUDE.md, placed at the root of your vault, is loaded automatically at the start of every session. It is the single most important file in the system. Whatever you put here, the AI treats as standing orders. Mine covers, in order:

• Context: what this vault is, who it's for, what the company does.
• The prime directive: "the vault is the system of record, persist durable knowledge here, not just in chat."
• A routing table: "tagging rules go here, brand rules go there, a decision about a project goes in that project's note." So new knowledge lands in the right home automatically.
• Read-first pointers: "before any real analysis, read these context modules." This front-loads the AI with your operating reality.
• Conventions: the taxonomy and metadata rules (next section), naming, linking.
• Hard rules: the "always / never" list, tone, formatting, what to confirm before doing, where to save output.
• Installed tools: the "don't reinstall these" table from earlier.

Treat this file as living. Every time you catch yourself correcting the AI the same way twice, that correction belongs in CLAUDE.md (or a memory file). The goal is that you never have to say the same thing three times.

08 · How it thinks

Memory files: the AI's persistent notebook

Where CLAUDE.md is the constitution you author deliberately, memory is what the AI records on its own as it learns you. Each memory is a tiny file holding one fact, with a couple of lines of structured header so it can be found later:

# one memory = one file
name:        no-em-dashes
description: Never use em dashes in drafted content
type:        feedback

Use commas, periods, colons, or parentheses instead.
Why: the user finds em dashes a tell of AI writing.

A running index file (call it MEMORY.md) lists every memory in one line each, and that index loads at the start of each session. So the AI walks in already knowing the durable facts about how you work, without you re-explaining.

The two-tier discipline that makes it reliable

Session memory is private to one machine and one person. It does not sync to your team. So the rule I enforce is: private memory is fine as scratch, but it can never be the only copy of anything that matters. Durable, shareable knowledge goes into a real note in the vault (which everyone sees); the AI's private memory is just a fast-recall cache on top.

09 · How it thinks

Writing rules that make the agent trustworthy

An AI with permission to write files and produce documents needs guardrails, or it will be confidently wrong at scale. Good rules are specific, testable, and explain the "why." Here are the categories worth writing, with real examples generalized from my own set.

Behavioral rules: how it works

• Lead with the problem and the decision needed, not throat-clearing.
• Default to the 80/20 answer; flag complexity that doesn't earn its keep.
• Flag budget variances over a set threshold with a proposed cause and action.
• No fluff in investor- or board-facing documents.

Voice rules: how it sounds

• Formal, direct, plain English.
• A house style-quirk list (mine bans em dashes; use whatever tics you care about).
• Never include auto-populated boilerplate like email signature blocks.

Safety rules: what it must not do without asking

• Confirm before irreversible writes. Never bundle "here's the problem" with "and I already fixed it in the live system." Present the evidence, wait for an explicit yes, then act.
• New system permissions ship off by default, the AI never grants access or enrolls people on its own.
• Sending anything outward (email, post, message) requires a clear go-ahead first.

10 · Conventions

Taxonomy & metadata: the closed-list discipline

Every note starts with a small block of structured metadata called frontmatter, a few fields between two --- lines at the very top. This is what makes a pile of notes queryable, filterable, and consistent. Obsidian reads it; the AI reads it; dashboards are built from it.

---
type:     meeting-notes     # what kind of note
entity:   division-a        # which part of the business
status:   active            # lifecycle state
created:  2026-07-23       # YYYY-MM-DD
updated:  2026-07-23
tags:     [budget, q3]     # topic tags
---

The discipline that makes this work is closed lists. For the important fields, type, entity, status, you define a fixed menu of allowed values in one master file, and nothing else is permitted. If nobody can invent Meeting Notes, meeting_notes, and mtg-notes as three versions of the same thing, your data stays clean forever.

Keep one canonical file (mine lives at 90-System/Tag-Taxonomy.md) that is the single source of truth for every allowed value and every approved topic tag. Point your CLAUDE.md at it: "read the Tag-Taxonomy before any tagging decision; use only approved values; when editing old notes, quietly bring them into compliance." Now the AI enforces your data standards better than any human ever would.

11 · Conventions

Wiki links: turning notes into a network

Type [[Note Name]] anywhere and Obsidian creates a live link to that note. This is the second superpower after Markdown. Notes stop being a filing cabinet and become a web, every connection navigable, and every note automatically knowing what links to it (backlinks).

• Link liberally. A link to a note that doesn't exist yet is fine, it's a placeholder marking something worth writing later. The graph grows as you work.
• The AI reads the web, not just the page. When it opens a note and sees [[Q3 Budget]] and [[Division-A Roster]], it knows to pull those in for full context. Good linking makes the agent dramatically smarter.

The same idea applies to transcripts and their summaries: keep the raw transcript in one place, the polished summary in its home folder, and wiki-link the two together so you can always get from the clean version back to the source of truth.

12 · Conventions

Agentic workflows: what "an agent that acts" actually looks like

"Agentic" just means the AI can take multi-step actions on its own, not only answer questions. Inside a well-built vault, that translates to concrete daily leverage:

The enabling move is skills: named, reusable procedures you define once. A skill bundles the steps, the format, and the rules for one repeatable job so you invoke it by name instead of re-explaining. "Draft in my voice," "produce the monthly brief," "format this as a proposal", each becomes a one-word command. For big, isolated jobs the agent can also spin up sub-agents that work in their own context and report back, so a huge transcript never clogs the main conversation.

13 · Voice & output

Brand voice: teach the AI to write like you

Generic AI writing is easy to spot and worthless for anything that carries your name. The fix is to build a voice guide, a note the AI reads before drafting anything on your behalf, grounded in evidence, not vibes. Here is the exact method I used to build mine.

1. Gather a corpus. Pull together a meaningful sample of things you've actually written: sent emails across registers (internal directives, coaching notes, tough external escalations, warm personal outreach), memos, messages. The wider the range, the better.
2. Have the AI analyze it. Ask it to extract the patterns: sentence length, how you open and close, formality by audience, recurring phrases, punctuation habits, what you never do. It's reverse-engineering your style from real examples.
3. Codify it into a guide. Turn that analysis into a written voice note, rules and do/don't examples, broken out by register, since you write to your team differently than to a lender.
4. Wire it in as a skill. Make "draft in my voice" a named skill that always consults the guide. Now every email, reply, and note it drafts sounds like you, not like a chatbot.

Scope it deliberately: a voice guide is for emails and short written notes, not for formatted deliverables like decks and proposals, which follow their own production rules (next).

14 · Voice & output

Logos, branding, and document production

To make the AI produce documents that look like they came from your company, not a default template, you give it the raw ingredients and written production guides, then let the tooling from section 03 assemble the files.

Brand assets

Keep a dedicated assets folder (in your output workspace, not the text vault, since these are images) holding your logos, colors, and fonts. Provide multiple logo variants, the practical rule I learned the hard way: never a dark-text logo on a dark background. Give the AI a light-background logo and a dark-background logo and a rule for which to use where, and it stops making that mistake.

Production guides

Write a short guide per document type, a proposal guide, a general document guide, a slide guide, that specifies margins, fonts, footer layout, cover-page treatment, where the logo goes. Point CLAUDE.md at them: "read the relevant production guide before producing any branded document." The AI then builds Word, PDF, and PowerPoint files that match your standards every time, using docx, WeasyPrint, and pptxgenjs under the hood.

And the standing rule from earlier applies: these finished files save to your output folder, never into the Markdown vault.

15 · Voice & output

Formatting rules worth writing down

Small, consistent formatting rules compound. Put the ones you care about in CLAUDE.md so you never police them by hand. A sampler of the kind of rules that earn their place:

• Output locations: Markdown stays in the vault; binaries go to the output folder. (The one non-negotiable.)
• Naming: a consistent file-naming convention, dates as YYYY-MM-DD, kebab-case, no spaces where it matters.
• Punctuation quirks: whatever tells you're allergic to. Mine forbids em dashes; the AI uses commas, colons, and parentheses instead.
• Boilerplate: don't add signature blocks or auto-populated fields the downstream system fills in.
• Numbers with one source: for any headline metric, unit counts, headcount, AUM, name the single canonical note it must be read from, and forbid quoting it from memory. This kills the slow drift of a wrong number propagating across documents.

16 · Go

Starter kit & setup checklist

The whole tool install in one block. Paste it into Terminal after you've installed Homebrew and Node. Grab a coffee; it runs itself.

# --- command-line document tools ---
brew install poppler pandoc python@3.12 pango

# --- PDF engine (real headers/footers/page numbers) ---
pip3.12 install weasyprint

# --- native document builders (Word / Excel / PowerPoint) ---
npm install -g docx exceljs pptxgenjs

# --- the agent itself (if not already installed) ---
npm install -g @anthropic-ai/claude-code

Download the starter files

Five ready-to-edit Markdown files that seed a new vault. Start with START-HERE.md: drop all five into an empty folder, open Claude Code there, and tell it to read that file and set everything up. Nothing here is proprietary; the {{curly-brace}} placeholders are yours to fill in.

The order of operations

• Install Obsidian; create a vault folder you own.
• Install Homebrew, then Node, then Claude Code.
• Run the tool-kit block above once.
• Number your folders by workflow (00 → 90).
• Create an output folder outside the vault for all finished PDFs/docs.
• Write a CLAUDE.md at the vault root: context, the "vault is system of record" rule, a routing table, conventions, hard rules, and the installed-tools table.
• Create 90-System/Tag-Taxonomy.md with your closed lists for type / entity / status.
• Adopt the two link habits: link liberally, and link by role not by name.
• Build a voice guide from a real corpus of your own writing; wire it in as a skill.
• Write your brand production guides and drop logo variants in an assets folder.
• Then start working, and every time you correct the AI twice, write the correction into a rule or a memory.