I Built an AI Personal Operating System for My Coaching Business With Claude Code

There's a specific kind of frustration that comes from explaining yourself to the same tool for the hundredth time.

I'm talking about this: I open a new Claude session. I want help drafting a coaching brief for my client. So I spend five minutes explaining who he is, what phase of training he's in, his injury history, his cadence issues, the fact that he's just back from a work trip and probably undertrained. Then I get a decent brief. Close the session. Next time, I start from zero again.

That's not an AI problem. That's a context problem. And for six months, I accepted it as the price of using AI tools.

Then I built Odin. Now my client's full profile, programme history, coaching protocol, and watch points load automatically before I write a single word.

Here's how I did it.

The Problem I Was Actually Trying to Solve

I run a performance and longevity coaching business. I manage training programmes, write client briefs, run outreach, create content, and train myself for a half marathon I'm targeting at 1:28. I'm also building a product called Asgard, a one-person business OS, and trying to keep a content pipeline moving across X, LinkedIn, and YouTube.

That's a lot of threads to hold.

The AI tools I was using were genuinely good. But every session felt like briefing a new hire. Paste in the context. Explain the rules. Re-establish voice preferences. Describe what done looks like. By the time I was actually working, I'd burned 20 minutes on setup.

The bigger problem: I'd spent hours building systems, frameworks, and rules across dozens of sessions. None of it transferred. It lived in chat history, and chat history doesn't follow you.

I needed something that treated AI like a system, not a conversation.

What I Actually Built

Odin is a Claude Code-based AI personal operating system. It lives as a folder on my machine, version-controlled in Git, with a structured rules and skills architecture that loads into every session automatically.

The core of it is a CLAUDE.md file. Claude Code reads this file at the start of every session. It's not a wall of prose. It's a compressed map: who I am, what I'm building, the active clients, the active hypotheses, and a set of pointers to modular files in a rules/ folder and skills/ folder.

The rules/ folder covers everything that should govern how the system behaves: voice guidelines for content, workflow protocols, revenue priorities, client data rules, token efficiency settings. Each file is a specific domain. I don't paste them into prompts. They load automatically.

The skills/ folder is where reusable workflows live. Garmin recovery analysis. My client coaching brief protocol. A wrap-up skill that extracts session insights and saves them to my Obsidian vault. Each skill is a self-contained instruction set that any capable model can follow.

When I want the system to pull my sleep data, assess my recovery, check my client's training compliance, scan for outstanding invoices, and deliver a single clean brief, I don't write a prompt for that. I run the morning brief workflow, and three parallel sub-agents run their domain tasks and feed into a synthesiser that writes one clean output.

That's the system. It sounds more complex than it is. It started as a single CLAUDE.md file with 200 words in it.

The Architecture, Specifically

If you want to build something like this, here's what the actual file structure looks like.

CLAUDE.md is the master context file. It stays compressed. No full essays in here. Pointers to files, summaries of current status, and the rules that need to be active on every single session. Mine covers: active clients, active projects, current revenue targets, and references to every major rule file.

rules/ covers the operating layer. My folder has: voice.md (how I write, what words I never use), workflow.md (morning brief, weekly review, post-session steps), clients.md (client programme and coaching rules), revenue.md (the daily revenue filter), token-efficiency.md (which model to use for which task), and a hypotheses/ subfolder where I track beliefs that are being tested with data.

skills/ covers repeatable workflows. garmin-recovery/ has the exact thresholds I use to interpret HRV, sleep score, and body battery. The coaching skill has the client's protocol, watch points, and brief format. wrap-up/ extracts session insights and saves them to Obsidian automatically.

MCP connections are what make the data layer work. I have Garmin connected (pulls sleep score, HRV, body battery every session), Strava, Obsidian as the knowledge vault, GitHub, Gmail, and Google Calendar. These aren't fancy setups. They're standard MCP servers that let Claude read and write to these systems.

Token routing is how I keep costs controlled. Haiku handles data extraction and file parsing. Sonnet handles drafting, reasoning, and most of my daily work. Opus runs once a week for synthesis and on high-stakes decisions only. The routing table lives in token-efficiency.md so the system follows it without me thinking about it.

The fan-out morning brief is the piece I'm most proud of. Three sub-agents run in parallel: one pulls Garmin data and assesses recovery, one checks the client's recent training and flags anything concerning, one scans the financial plan and surfaces one priority action. A synthesiser reads all three outputs and writes a single brief. I review it. Total time: three minutes.

What Actually Changed

Before Odin, my morning brief was 30 minutes of manual data pulling, tab switching, and writing. Now it's three minutes of reviewing a draft and either approving it or adjusting one line.

Client briefs went from 45 minutes of writing to reviewing a draft. The history, programme, watch points, and brief format are all pre-loaded in the skill file. I edit, approve, and send.

Zero context loss between sessions is the thing that sounds obvious but has the biggest daily impact. I never re-explain myself. I never re-establish voice rules. I never re-paste client profiles. The system knows what it knows because I wrote it down properly, once, and it loads every time.

The system also gets smarter over time. Every week, a /insights synthesis runs: it reads session notes from the week, extracts patterns, and saves them to Obsidian. Beliefs I've corrected become rejected hypotheses in the hypotheses/ folder. Rules I've validated become permanent. Over twelve weeks, the system has accumulated a working model of how I think, what I've tried, what's failed, and what's working.

That's the part that no single AI conversation can do. The compounding only happens if you build the architecture for it.

How to Start

You don't need to build what I built. You need to build the first version of it, which is much smaller.

Step one. Install Claude Code. It's a CLI tool. Get comfortable running it from your project folder.

Step two. Create a CLAUDE.md file in your project root. Write 150 words about what you're building, who you are, and what context Claude needs to know every session. Keep it compressed. This is not a biography. It's a briefing document.

Step three. Create a rules/ folder. Start with one file: voice.md. Write down how you write. What words you never use. What formats you use for posts or briefs. Even if it's five bullet points, write it down.

Step four. The next time you give a correction (you re-write a sentence, you say "don't do it like that"), ask yourself: should this be a rule? If yes, write it in a rules file. The system improves by capturing those corrections before they disappear.

Step five. Once you have three or four rules files, think about what repeatable tasks you do weekly. Draft a skill file for the most frequent one. Your client brief. Your content format. Your recovery review. A skill file is just a markdown file with clear instructions. Any capable model can follow it.

That's the foundation. The fan-out agents and MCP connections come later. Start with the context layer. That's the part that changes the daily experience.

Where to Go Next

If you want to build this for your own coaching or consulting business, the full guide is on this site.

The free CLAUDE.md template is the fastest way to start. It's a pre-built context file you fill in once, and every session starts with full context from that point on.

The system took me about three weeks to build properly and roughly four hours a week to maintain. The payoff has been every week since.