The Ultimate Guide to Running Your Business on Obsidian + Claude Code

You can run a real business on a folder of plain-text files. Obsidian gives those files structure — links, properties, dashboards — and an agentic coding tool like Claude Code gives them an operator: an AI that reads your entire business context from disk and then does work that is actually grounded in it. This guide describes the exact setup Total Format runs on, the plugins it needs, the conventions that keep it safe, and copy-paste prompts you can fill in and deploy for your own firm.

This is not a productivity-app article. It is an operating model: your business knowledge lives in one structured vault; an AI agent with file access reads it, works in it, and builds from it; you review everything before it ships.

What is this setup, exactly?

Three parts, each doing one job.

Obsidian is the memory. A free note-taking app over a folder of Markdown files on your own machine. Every strategy, offer, price, decision, SOP, campaign and piece of positioning lives as a note with structured properties (type, status, review state) and links to related notes. Because it is plain text in a folder you own, nothing is locked in a vendor's database — and, critically, an AI agent can read and write it directly.

Claude Code is the operator. An agentic AI tool that runs on your machine with access to your files. Point it at the vault and it stops being a chatbot guessing about your business and becomes a worker that has read all of it — your voice rules, your prices, your decision log — before it types a word. The same pattern works with other orchestration tools (OpenAI's Codex CLI, or similar agents); the vault doesn't care who reads it. The reason this matters is the argument at the heart of our AI automation reality check: AI produces generic output when it has generic context. Fix the context and the output changes class. Or as we've put it elsewhere, AI doesn't know your business until you write it down.

You are the review layer. Every note carries a review property. The agent creates work as pending; nothing ships until you approve it. This is human-in-the-loop made structural rather than aspirational — the approval step is a field in the file, not a good intention.

What did it actually produce?

Concrete outputs from this setup at Total Format, so you can judge whether it is worth an evening of installation:

• A business brain of roughly 380 interlinked notes — strategy, offers, SOPs, decision log, brand rules, qualification frameworks — built in about two days from two long source documents.
• A 250-article, ~210,000-word interlinked content library, written in the firm's voice with real numbers, every article born review: pending, delivered over roughly three days.
• A 252-page static website generated directly from vault notes by a build script the agent wrote, deployed to ordinary shared hosting over SSH with one command.
• The connective tissue around it: a lead-capture pipeline, a CRM stage design, outbound sequences — each one drafted in the vault first, then implemented.

The pattern behind every item is the same: the vault holds the judgement, the agent does the labour, the review field holds the gate. Costs are modest — Obsidian is free for personal and small-business use, and agentic AI tools typically run on subscriptions from roughly £15 to £100+ a month depending on tier and usage.

What do you need to install?

The full stack:

Install the three community plugins from Obsidian's Settings → Community plugins. That is the entire dependency list — no database, no server, no per-seat platform fee.

How should the vault be structured?

Structure is what separates a business brain from a notes graveyard. The conventions that have mattered most in practice:

1. Numbered top-level folders by function — e.g. 01 - Strategy, 04 - Sales, 05 - Marketing, 08 - Operations, 12 - Decisions, 99 - Meta (templates, schema, how-to guides). The agent navigates by these the way a new hire navigates a shared drive — badly if it's chaos, instantly if it's labelled.
2. Every note declares what it is. Frontmatter properties: type (strategy, sop, decision, sequence, post…), status, review, created, updated — with controlled vocabularies, not free text. This is what lets a script (or an agent) treat notes as data.
3. A decision log. Every meaningful call gets a decision note: what was decided, options considered, rationale, a revisit date. Six months later, neither you nor the agent re-litigates it from memory.
4. Systems of record stay separate. The vault holds judgement — strategy, reasoning, rules. Live operational data (pipeline, files, campaign metrics) stays in the CRM and the tools that own it. Duplicating facts into notes creates two versions of the truth, and one of them is always wrong.
5. A conventions note the agent reads first. One README that states the rules: filename conventions, vocabularies, the review protocol, what the agent must never touch. This becomes, in effect, the agent's employment contract — and it is the same discipline as writing an SOP before you automate it, the promotion rule covered in from SOP to automation.

What makes it safe to let an AI write in your business brain?

The review protocol. The mechanism, step by step: when the agent creates or edits any note, then that note is set to review: pending. When you read it and it is right, then you mark it approved with a date. When it is wrong, then you set needs-changes and leave a dated feedback comment at the exact passage. When you next tell the agent to "run the feedback sweep", then it collects every open comment, proposes and applies the edits, marks the comments resolved, and resets the notes to pending for re-review. When a note is approved, then the agent may not silently edit it — any change resets it to pending.

Nothing ships — no page, no email sequence, no SOP — while its note awaits review. A Dataview dashboard lists everything pending, so the queue is visible rather than remembered.

Two boundary rules complete the safety story. First, credentials never live in the vault — no passwords, no API keys; the vault describes systems, it doesn't hold the keys to them (the same boundary logic as client data and AI tools). Second, the vault runs on your machine, not a shared cloud workspace — you control what any given tool can reach.

The prompts: copy, fill in the blanks, deploy

Three prompts run the whole model. The first builds the vault; the second is how you start each working session; the third is the review loop. Replace everything in {CURLY BRACES}.

Prompt 1 — build the vault. Write one honest brain-dump document first (what you sell, to whom, at what price, how delivery works, what you believe about your market — length beats polish), then give the agent this:

You are building an Obsidian vault that will run my business. Work only from the source document(s) I provide — do not invent facts; where information is missing, insert "TODO:" markers instead.

BUSINESS: {NAME} — {ONE SENTENCE ON WHAT IT DOES AND FOR WHOM}
SOURCE: {PATH TO YOUR BRAIN-DUMP DOCUMENT(S)}
VAULT LOCATION: {PATH, e.g. ~/Obsidian/MyBusiness}

Structure: numbered top-level folders by function — 01 Strategy, 02 Offers, 03 Sales, 04 Marketing, 05 Operations, 06 Clients, 07 Decisions, 99 Meta. Adjust names to fit the source material, but keep the numbered scheme.

Conventions (enforce all of these):
- Plain-ASCII filenames: hyphens, no special characters, no emoji.
- Every note has frontmatter: type, status, review, created, updated. Controlled vocabularies only — define them in a "YAML Schema" note in 99 Meta.
- Every note is born "review: pending". I approve notes by setting review to "approved" with a date, or "needs-changes" with a dated feedback comment at the relevant passage.
- Notes link to related notes with wikilinks. A note that stands alone is a note that gets lost.
- Decisions get their own notes in 07 Decisions: what was decided, options considered, rationale, revisit date.
- The vault holds judgement, not live data. Point to my systems of record ({CRM / FILE STORAGE / ANALYTICS TOOLS}) rather than duplicating their contents.
- Do not modify the .obsidian/ settings folder.
- No credentials, keys or passwords anywhere in the vault, ever.

Also create in 99 Meta: Templater templates for each note type; a "Vault README & Conventions" note stating all rules above; a Dataview dashboard note listing everything with review: pending; and a short how-to guide teaching me the review workflow.

Build the full structure, populate it from the source document, then give me a summary of what exists and where the TODO gaps are.

Prompt 2 — the daily operating loop. Start each working session with this pattern:

Before anything else, read 99 Meta/Vault README & Conventions in my vault at {VAULT PATH}, and check the review dashboard for anything I have marked needs-changes.

Then: {TODAY'S TASK — e.g. "draft a 4-email outbound sequence for {AUDIENCE}, following our voice rules and linking the relevant strategy notes", or "write an SOP for {PROCESS} based on the decision note {NOTE NAME}"}.

Create all new work as review: pending. If anything you need is missing from the vault, say so rather than inventing it.

Prompt 3 — the feedback sweep. After you have reviewed and left comments:

Run the feedback sweep on my vault at {VAULT PATH}: find every note marked needs-changes, read my dated feedback comments, propose and apply the edits, mark each comment resolved, and reset those notes to review: pending so I can re-check them. List every change you made.

That is the entire operating system. Everything else — content engines, site generators, campaign libraries — gets built inside this loop, as vault notes first.

What are the honest limits?

Four, and they are real. The review burden is yours — an agent that can produce 250 articles can produce 250 mediocre ones if nobody reads them; budget genuine review time or produce less. Garbage context, garbage output — the vault is only as good as the brain-dump and the upkeep; a stale price in a note becomes a stale price in a proposal. Agents make mistakes — confident, plausible ones; that is why the review field exists and why it is a gate, not a suggestion. Maintenance is forever — conventions drift, links rot, and the vault needs the same periodic tending as any system (automation debt applies to knowledge systems too).

None of these is a reason not to build it. They are the reason to build it with the review protocol from day one.

Where does this actually pay off?

The compounding effect is the point. Week one, the agent writes in your voice without being reminded. Month one, it drafts campaigns that quote your real prices and link your real decision log. The deeper return is structural: every piece of judgement that previously lived only in the founder's head now exists as a file an agent can act on — which is, mechanically, how a firm stops being bottlenecked by its founder. The knowledge stops walking around in one skull and starts sitting in a system that works while the skull sleeps.

Start with the brain-dump document this week. The vault is an evening's work. The habit of reviewing what your new operator produces — that is the actual discipline, and the only part no tool can install for you.

Next step: the Growth System Audit — £450, seven days, credited against any build — maps where your growth system leaks and what to build first, including whether a setup like this is the right lever for your firm.