Hazel Apuhin-Baxter

Private workspace

Enter the access code Hazel shared with you.

For invited participants only.
AI Operating System by Virtual Assistants Philippines
Module 01 of 04
Private workspace

AI Operating System
by Virtual Assistants Philippines

The complete guide to building your AI Operating System.

Module 01

🧱Foundations

The mental model that makes everything else make sense.

🎯 What this module gives you

By the end of this module, you'll understand:

  • What an AI Operating System is and why you need one
  • The tools you'll use (VS Code + Claude Code, Supabase, GitHub)
  • The vocabulary you'll need (Commands, Skills, MCP, tokens)
  • How the 3 layers (Context, Data, Function) fit together
  • How your AI OS learns (CLAUDE.md, Auto Memory, the Decision Engine)

This is all conceptual. You start building in Module 2.

01

What You'll Build

This guide walks through building your own AI Operating System: a persistent, integrated system that knows your business, connects to your data, and works for you every day.

What You Will Have

Your AI Operating System: a system that understands your business, connects to your data, generates a Daily Intelligence Brief every morning, is accessible from your phone, and learns how you make decisions. Yours to keep and extend. Everything you build lives on your own machine and in your own accounts.

💡 The order of the modules matters. Every module builds on the last. Resist the temptation to skip ahead. You'll understand why by the end of this module.
02

What is an AI Operating System

Most people using AI for business right now are losing ground. Not because the tools are bad. The tools are incredible. They're losing because of how they use them.

The Fragmentation Trap

A typical setup: a ChatGPT tab, a Claude tab next to it, some N8n automations dotted around. Nothing talks to anything else. Every conversation starts from zero. This fails for three reasons: No persistent context. Every conversation teaches the AI something. Close the tab, it's gone. You spend the first 5 minutes of every session re-explaining your business, your priorities, your style. No real data. The AI answers with general knowledge and whatever you paste in. It doesn't see your actual numbers, clients, or calls. Answers sound plausible. They're not specific. Nothing learns from your decisions. You make the same judgment calls over and over, and nothing watches, records, or compounds that intelligence. Year two looks like year one with a better prompt.

⚠️ The trap is speed without depth. AI tools are so easy to pick up that nobody bothers with the infrastructure that makes them powerful. A year in, they've got 40 prompts, 3 GPTs, 5 Zapier flows, and nothing that compounds. The tools got better. Their system didn't.

Definition: An AI Operating System is a persistent, integrated system built on a capable AI that knows your business, has access to your data, runs on a schedule, and learns how you decide.

A Way To Think About It…

Every serious company has an HR system, a CRM, a comms stack. These are operating systems for specific functions. What no company has had until now is an operating system for thinking. For decisions, intelligence, synthesis, pattern-matching across everything. That's what an AI OS is. A single integrated layer that sits across your business and turns scattered information into clear answers, one-off tasks into automated functions, and individual decisions into compounding intelligence.

What an AI OS Gives You That a Chatbot Does Not

CapabilityChatbotAI OS
PersistenceForgets everything when you close the tabRemembers your business, preferences, past decisions
ContextOnly what you paste into the promptYour full business: companies, team, strategy, metrics, tools
Data accessGeneral knowledge onlyLive data from your CRM, Slack, calendar, financials, calls
AutomationYou trigger it, it answersRuns on a schedule, wakes up to deliver your Daily Brief
LearningResets every conversationLearns your decision patterns and gets sharper over time

Why Now

For the first time, these tools are usable without an engineering team. The gap between "I want this" and "I have this" has never been smaller.

💡 In the AI era, the gap between those at the forefront of what is possible and those a few steps behind grows faster than any gap before it. This guide puts you at the forefront. You don't just learn to use AI. You learn to build a system that does the using for you, and keeps getting smarter while you sleep.
03

The Tools Required

Your AI OS is built in a real developer workspace. This guide uses four tools. All are free to start. All are industry-standard. You'll have a working command of each by Module 4.

The Stack

ToolWhat It IsUsed When
VS Code + Claude CodeA free code editor (VS Code, by Microsoft) with the Claude Code extension installed. This is your workspace and your AI in one place.Module 2 onwards. Every time you build.
SupabaseA hosted database service with vector search (pgvector) built in. Free tier.Module 3: your data layer.
GitHubVersion control and code hosting. Free.Module 2 (setup) and Module 3 (required for scheduled workflows).

What About Claude Web and the Claude Desktop App?

You've probably used Claude web or the Claude Desktop app to chat with Claude before. They're fine for quick conversations, but they don't give you a workspace, a filesystem, or the ability to run code against your real stack. Once you move to VS Code + Claude Code, you won't need them for building. Claude Code is Claude, with your whole project loaded and your data layer, version control, and deployment pipeline attached.

Supporting Pieces

Claude mobile app. Optional. Pairs to your VS Code session via Remote Control so you can query your AI OS from your phone. Module 4.

💡 You don't have to install anything yet. Module 2 walks through VS Code + Claude Code. Module 3 walks through Supabase and GitHub. This step is the map, not the install.
04

Core AI Concepts

These are the terms you'll see across the modules ahead. This section defines each one. It doesn't teach you how to use them. That comes later. "What is this?" only.

Large Language Models (LLMs)

An LLM is the AI that reads and writes text. You've used one if you've used ChatGPT or Claude. It can read, write, analyse, code, and reason. On its own it's smart but generic. The rest of this guide is about turning it into YOUR system.

The 3 Models of Claude

Not every task needs the most powerful model. Claude has three models, each with a different balance of speed and capability.

ModelSpeedBest For
OpusSlowest, most capableStrategic analysis, complex reasoning, your Daily Brief
SonnetBalancedQuality tasks, content, communication
HaikuFastest, lightestSimple classification, routing, quick lookups

Your AI OS picks the right model automatically. You don't choose manually.

Tokens and Context Windows

Think of Claude's context window as a desk. Everything the AI thinks about during a conversation must fit on that desk: your instructions, the files it reads, your messages, its responses, and the conversation history. Claude's desk holds about 1 million tokens (roughly 750,000 words, or over 1,500 pages). Large, but not infinite. When the desk fills up, the AI starts losing track. Earlier parts of the conversation get pushed off the edge. The AI forgets things you agreed on, repeats approaches you already rejected, and quality drops. This is why: Long sessions produce worse output than short ones. After extended work, start a fresh session. Claude Code also has a /compact command that compresses the conversation without starting over. Context files are the most efficient use of the context window. Your 6 context files (Module 2) load automatically at the start of every session. One set of files, every time, instead of repeating yourself.

💡 Recommendation: get Claude MAX. Claude Pro ($20/month) works, but you'll hit usage limits quickly once you're building with Claude Code every day. Claude MAX ($100/month or $200/month) gives you far more headroom and is the right choice for heavy building. You can start on Pro and upgrade when you hit the cap, but if you know you're going to build heavily, go MAX from day one. You'll save time and frustration.

Rough token numbers for reference:

  • 1 token ≈ 0.75 words
  • 1,000 words ≈ 1,300 tokens
  • A typical context file ≈ 500 to 2,000 tokens
  • A long meeting transcript ≈ 10,000 to 30,000 tokens

Claude's full context window ≈ 1 million tokens

Every message, every file Claude reads, and every response uses tokens. When the total exceeds the window, the oldest content is compressed or dropped.

  • CLAUDE.md

A file at the root of your AI OS project. Claude reads it at the start of every session. Think of it as the AI's job description and operating manual in one file. It tells Claude who you are, how your business works, the rules it should follow, and what commands are available. Your Blueprint comes with a CLAUDE.md pre-written. You extend it in Module 2.

Commands (Slash Commands)

One-word shortcuts you type into Claude Code to trigger a reusable prompt. Examples: /prime (loads your context at session start), /decide (logs a business decision), /create-plan (designs an implementation plan before you build). Commands exist so you don't retype the same prompt every time. Your Blueprint comes with a dozen. In Module 4 you'll see how they work, and later you can create your own.

  • Skills

Custom commands you create yourself, stored in .claude/commands/ in your project. Every slash command in your Blueprint is a Skill. When you want a new repeatable workflow (say /weekly-review), you build it as a Skill. Covered in Module 4. You can build your first Skill once you're comfortable with the basics.

MCP (Model Context Protocol)

The standard for connecting external services to Claude. Think of it as the USB cable between your AI OS and your business tools: Slack, Notion, Airtable, your CRM, your calendar. You configure MCP with a .mcp.json file in your project, with tokens stored in .env.local. Module 3 walks through it step by step.

API (Application Programming Interface)

An API is how two pieces of software talk to each other. A set of instructions that lets one app ask another app to do something. When your AI OS sends a message to Anthropic and gets a response back, that's an API call. When a scheduled workflow wakes up on schedule and generates your Daily Brief, that's an API call too. You won't write API code directly in this guide. But you'll see the term a lot: "API key", "API call", "API endpoint". Now you know what it means.

Scheduled Workflows (GitHub Actions)

This guide uses GitHub Actions as the canonical way to run your AI OS on a schedule. You write a small YAML file, store secrets like your Anthropic and Supabase keys in GitHub, and the workflow runs on GitHub's runners on a cron. Your computer can be off. Workflows can also trigger manually or on push events, and the script they run can chain outputs to Slack, email, or Notion in the same run. This replaces the older "Routines" pattern (Anthropic's cloud scheduled tasks). Routines couldn't reach Supabase or run TypeScript sync scripts reliably, so they failed for the patterns this Blueprint teaches. GitHub Actions does both natively. Set up in Module 3 and Module 4.

  • Subagents

A Subagent is a focused AI agent that Claude can spin up to handle one part of a bigger task. When you're working on a large project and Claude needs to research something, review code, or tackle a sub-task that would clutter the main conversation, it can spin up a Subagent to handle it separately. Each Subagent has its own context window, does its job, and reports back. You don't have to trigger them manually. Claude decides when a Subagent would help and spins one up.

05

AI OS Architecture

This is the most important section in Module 1. Everything you build in this guide follows this architecture.

The 3 Layers

Your AI Operating System is built on 3 layers. Each one depends on the one below it.

AI OS Architecture Diagram

LAYER 1: CONTEXT

This is everything the system needs to know before it can be useful: who you are, what you do, your team, your strategy, your metrics, your tools. What it is: 6 files in your project that teach the AI everything about your business. What it unlocks: An AI that gives advice specific to YOUR situation, not generic best practices.

You build this in: Module 2

LAYER 2: DATA

Context tells the AI what your business SHOULD look like. Data tells it what's ACTUALLY happening. It's the difference between a strategy document and a live dashboard. What it is: Live connections to your business tools: CRM, Slack, calendar, financials, call recordings. What it unlocks: The AI can answer questions like "How did last week's sales calls go?" or "Which clients haven't heard from us in 2 weeks?" using real data, not guesses.

You build this in: Module 3

LAYER 3: FUNCTION

This is where your AI OS acts. Everything it's learned in Context and Data now gets used to produce something. What it is: The layer that actually DOES things: generates your Daily Brief, drafts communications, automates tasks, makes recommendations. What it unlocks: An AI OS that works for you automatically. Before you check your email in the morning, your brief is already waiting.

You build this in: Module 4

⚠️ You can't skip layers.

Most people jump straight to Function. They want the Daily Brief, the automation, the mobile access. But:

  • A Daily Brief without Data is just a template
  • Data without Context is just numbers without meaning
  • Context without the AI OS foundation is just files sitting in a folder

This guide builds from the bottom up. That's why it works.

How Your AI OS Learns About You

Three complementary layers of learning sit across the architecture. They work together, not in competition.

LayerWhat It IsHow It Works
CLAUDE.mdThe AI's "who you are", stable rules and identity.Automatically (pre-configured in your Blueprint, then extended as your business evolves).
Auto MemoryThe AI's "how you've been", patterns and preferences picked up from your work.Automatically (Claude adds to it as you go. Loaded every session).
Decision EngineThe AI's "what you've decided", a record of your decisions and their outcomes.Automatically from your work, plus from logged decisions (Module 4).

The Decision Engine

The Decision Engine is the part of your AI OS that learns how you decide. Every decision you make (whether you log it directly, or your AI OS picks it up from a meeting, a conversation, or your daily work) becomes part of a growing library of how you think. Over time it spots your patterns. When you face a similar decision again, it surfaces what you've done before and what worked. Eventually it earns the ability to handle routine decisions on your behalf, within guardrails you set. Module 4 teaches you how to build and use it.

The Autonomy Ladder

Your AI OS doesn't start fully autonomous. It earns autonomy by proving it can be trusted. Four phases:

  1. Inform. AI collects data and surfaces it for you.
  2. Recommend. AI suggests actions with reasoning.
  3. Confirm. AI drafts and queues. You approve.
  4. Autonomous. AI executes routine decisions within guardrails you've set.

Module 4 teaches this in depth.

06

Your Path Ahead

The 4 Modules

ModuleWhat You BuildWhat It Unlocks
1. FoundationsThe mental model (you're here)Understanding of what you're building and why
2. ContextYour AI OS workspace and context filesAn AI that knows your business inside out
3. DataConnected data sourcesLive data flowing into your AI OS
4. FunctionDaily Brief, mobile access, Decision EngineYour AI OS working for you every day

What Happens in Module 2

Module 2 is where you stop reading and start building. You'll:

  1. Install VS Code and the Claude Code extension
  2. Download the AI OS Blueprint and open it
  3. Run /prime for the first time to load your (still empty) context
  4. Start populating your 6 context files with the story of your business

Think About Your AI OS

🧠 Before you move on, reflect on these:

  • What tools does your business use every day? (These will become your Data layer)
  • What questions do you wish you had instant answers to? (These will become your Functions)
  • What decisions do you make repeatedly? (These will train your Decision Engine)
  • What feels fragmented in your current setup? What would you consolidate if you had an AI OS? (This is what you're about to fix)

You don't need to write anything down yet. Just start forming the picture. In Module 2, you start building it.

✅ Module 1 complete. You know what an AI OS is, why you need one, the tools and vocabulary you'll use, and the 3-layer architecture that ties everything else together.

Next: Module 2 (Context). You'll set up your workspace, download the AI OS Blueprint, and start teaching your AI everything about your business. This is where you go from understanding to building.
Module 02

🧠Context

Hands on keyboard. Everything built later depends on what gets built here.

🎯 What this module gives you

By the end of this module, you'll have:

  • A working VS Code + Claude Code workspace
  • The AI OS Blueprint downloaded, opened, and auto-approved
  • Git initialised and /prime running
  • Your 6 context files populated with the story of your business
  • Claude answering your questions with context, not cold starts

This module is hands-on. Block 2 hours for your first session.

⛔ Already built something? If you have a Claude Code project, OpenClaw or Cursor workflow etc, run the Migration Guide: Already Have an AI OS? first. It'll audit what you have and map gaps to the right modules before you rebuild from scratch here.
01

Set Up Your Workspace

Module 1 was the mental model. This is where the tools come off the shelf. You'll install VS Code, sign in to Claude, download the AI OS Blueprint, initialise Git, and run your first /prime. 30 to 60 minutes, end to end. Everything in Modules 2 through 4 builds on this setup. Get it right once and you don't touch it again.

Step 1: Install VS Code and Claude Code

VS Code is the app everything runs inside. It's free, made by Microsoft, and used by most professional developers. The Claude Code extension is what gives it the AI brain. That combination is your workspace for everything that follows. Install VS Code:

  1. Go to code.visualstudio.com
  2. Click the big Download button (it auto-detects Mac or Windows)
  3. Install it like any other app
  4. Open it once to make sure it works

Install the Claude Code extension:

  1. Open VS Code
  2. Click the Extensions icon in the left sidebar (looks like 4 squares)
  3. Search for "Claude Code" by Anthropic
  4. Click Install
  5. You'll see a Claude icon appear in your left sidebar

Step 2: Sign Up for Claude

You need a Claude account with a Pro or Max subscription to use Claude Code.

  1. Go to claude.ai and create an account if you don't have one
  2. Subscribe to Claude Pro ($20/month) or Claude Max ($100/month or $200/month)

Pro gives you solid usage. Max gives you far more. If you're going to be building heavily, Max is worth it. You may have used Claude web or the Claude Desktop app before. They're fine for quick chats. For everything in this guide, you'll work in VS Code + Claude Code.

Step 3: Connect Claude Code to Your Account

  1. Open Claude Code (the Claude icon in VS Code's left sidebar)
  2. Click Sign In. This opens your browser.
  3. Log in with your Claude account
  4. Approve the connection
  5. You should see a chat interface ready to go

Step 4: Download the AI OS Blueprint

Your AI OS Blueprint is personalised to you - built from your intake form responses. It is for your use only and cannot be shared or resold.

📦 We sent your Blueprint zip file via email or Slack. Check your inbox or DMs. If you haven't received it yet, reach out to us and we'll send it over.
  1. Unzip it. You'll get a folder called ai-os-blueprint
  2. Move this folder somewhere sensible on your computer. Your Desktop or a dedicated projects folder works fine.
  3. Rename it to something meaningful if you want - like my-ai-os or [your-company]-os. The name doesn't matter technically, but it's your system.

Step 5: Open the Blueprint in VS Code

  1. Open VS Code
  2. Go to File > Open Folder
  3. Navigate to your ai-os-blueprint folder and select it
  4. You should see the full file tree in the left sidebar
📁 You should see:
  • CLAUDE.md (the brain)
  • context/ folder (6 files)
  • reference/ folder (architecture, autonomy ladder, decision engine, and data/integrations patterns)
  • scripts/ folder
  • data/, plans/, outputs/ folders
  • .claude/ folder (commands and skills)

If you see all of this, you're in the right place.

Step 6: Turn On Auto-Approve Permissions

By default, Claude asks for permission before every file read, every file write, every command. That's fine if you're cautious, but it creates a lot of friction when you're building. Auto-approve lets Claude read and write files in your project without stopping to check.

  1. Click the Claude icon in the left sidebar to open Claude Code
  2. In the Claude Code panel, paste the following:
💬 Prompt: Please enable auto-approve for all tools in this project so you can read and write files without asking each time.

Claude will walk you through enabling the right settings.

⚠️ Claude will be able to read and write files in your project without asking each time. This is safe. It can only access files inside your project folder. It's not touching anything else on your computer.

Optional: Dangerously Bypass Permissions (advanced)

This is a deeper version of auto-approve that removes every remaining confirmation, including commands, terminal operations, and file moves. The upside is zero friction while building. The downside is you're fully trusting Claude to do what you told it to do inside your project.

You assume all the risk. Claude can't touch anything outside your project folder, but inside it, it acts freely. If you've told Claude to build something, it builds without checking in.

This is the preferred workflow once you're comfortable. If you'd rather stay on standard auto-approve, skip this and come back later.

To enable it, paste this into the Claude Code panel:

💬 Prompt: Enable the dangerously skip permissions mode for this project. I've read the risks, I understand Claude can read, write, and run anything inside the project folder without confirmation, and I want zero-friction building from here.

Claude will walk you through the setup and confirm before it's live.

Step 7: Initialise Git

What Git is: Git is a version-control system. Every change you save to your project gets tracked. If something breaks, you can roll back to any previous version in seconds. GitHub is a separate thing - a website where you can push your Git project to the cloud as a backup or to share it. Right now, we're just initialising Git locally on your machine.

Why you're doing it: Claude Code is about to write and edit a lot of files as you build. Git gives you an undo button that reaches back forever. If a session goes sideways, you can recover. Module 3 also uses Git when we set up your scheduled workflows on GitHub Actions, so having it in place now means no rework later.

In the Claude Code panel, paste:

💬 Prompt: Initialise git for this project and make an initial commit with all files.

If Claude says "already initialised", that's fine. It just means the Blueprint already had Git set up.

Step 8: Run /prime

What /prime is: Every time you open a new Claude Code session, the AI starts with zero memory of your project. It doesn't know who you are, what you're building, or what you've discussed before. /prime is a command we baked into your Blueprint that loads all your context files and reference docs before the conversation starts, so the AI already knows who you are and what you're building by the time you type your first real message.

Why you're doing it now: To confirm the Blueprint works end to end and see what /prime reports. Virtual Assistants Philippines already prebuilt your context files from your intake form, so the AI should already know who you are and what your business does.

In the Claude Code panel, paste:

💬 Prompt: /prime

Claude reads your entire project and tells you where you stand. Because Virtual Assistants Philippines prebuilt your context from your intake form, /prime should already recognise your business. You'll run /prime at the start of almost every session from here on.

Quick Reference: Commands

CommandWhat It DoesWhen to Use
/primeLoads all context and reports system statusStart of every session
/decideLog a business decision to train the systemAny significant decision
/create-planDesign an implementation plan before buildingBefore adding anything significant
/implementExecute a plan step by stepAfter approving a plan

Troubleshooting

When something doesn't work, expand the matching problem below.

Claude Code isn't showing up in VS Code

Make sure you installed the Claude Code extension (by Anthropic) from the Extensions marketplace. Restart VS Code after installing.

Claude says "not signed in" or won't connect

Click the Claude icon > Sign In. Make sure you have an active Claude Pro or Max subscription. Try signing out and back in if it's stuck.

You can't see the file tree or project files

Make sure you opened the folder (File > Open Folder), not an individual file. You should see CLAUDE.md at the root level.

/prime isn't working

Make sure you're typing the command in the Claude Code panel, not the regular VS Code terminal. Click the Claude icon in the sidebar first.

Claude's asking for permission on every action

Turn on auto-approve in Claude Code settings (see the Turn On Auto-Approve step above). This lets Claude read and write files without asking each time.

You made a mistake and want to undo

Git tracks everything. Tell Claude "undo the last change to [file]" and it'll handle it. Or in the VS Code terminal, type git diff to see what changed, or git checkout -- filename to undo changes to a specific file.

02

Work with Claude

You're going to hit moments where Claude doesn't do what you want. Not because the tool is broken, but because you haven't told it what it needs to hear. This section is a reference library of the 10 most common stuck moments when working with Claude Code, and the exact prompt that unsticks each one. Any time you see a grey 💬 callout below, the text inside is a prompt you can paste straight into the Claude Code panel.

💡 Come back to this whenever you hit a wall in any module. These are the stuck moments that trip up everyone.
You're going back and forth and it's not getting it right

What it feels like: You've sent 5+ messages trying to get something right and each version is still wrong.

Why it happens: Each back-and-forth eats your context window. Claude loses track of what you actually want as the conversation grows.

💬 Prompt: Stop. Don't send me another version. Use [Playwright / the preview / the terminal] to check this yourself. Keep iterating until it matches [specific criteria]. Only come back to me when it's done.
Claude asks you to run a terminal command or do something manually

What it feels like: Claude says "now run this command in your terminal" or "paste this into your config file."

Why it happens: Claude sometimes defaults to instructing rather than doing, especially with new users.

💬 Prompt: Do that yourself. You have terminal access. Execute it and tell me the result.
Claude changed files you didn't ask it to change

What it feels like: You asked it to fix one thing and it "improved" three other files you never mentioned.

Why it happens: Claude tries to be helpful by fixing things it notices along the way.

💬 Prompt: Only change [specific file or function]. Don't modify, refactor, or improve anything else. If you notice other issues, tell me about them but don't fix them.
Claude keeps trying the same failing approach

What it feels like: You've seen the same error three times and Claude keeps trying variations of the same broken fix.

Why it happens: Without being told to stop, Claude persists with its current approach rather than stepping back.

💬 Prompt: Stop trying to fix this. Tell me: what do you think the root cause is, what have you tried so far, and what information are you missing? Don't attempt another fix until we agree on the approach.
Output is generic or doesn't match what you wanted

What it feels like: The output is technically correct but feels like it could be for anyone. It doesn't reflect your business, your style, or your situation.

Why it happens: Vague instructions give Claude nothing specific to work with. "Make this better" isn't actionable.

💬 Prompt: This is too generic. Here's an example of what good looks like: [paste example]. Match the style, specificity, and level of detail.
Claude invented something that doesn't exist

What it feels like: The code looks perfect but when you run it, methods or endpoints are undefined or return errors.

Why it happens: Claude generates code based on patterns, not verified documentation. It can invent API methods, library functions, and endpoints that look plausible but don't exist.

💬 Prompt: Before writing any code, verify that every API method, endpoint, and library function you plan to use actually exists. Read the source files or documentation first. Don't guess.
Quality is dropping after a long session

What it feels like: Claude was sharp earlier but now it's making basic mistakes, forgetting things you already agreed on, or repeating solutions you already rejected.

Why it happens: The context window fills up over time. Past 80% capacity, Claude starts losing track of earlier parts of the conversation.

💬 Prompt: Summarise where we are, what we've built, and what's left to do. Write it to a file so we can start a fresh session and pick up cleanly.

Alternatively, use the /compact command to compress the conversation without starting over.

You're about to make a big change and want to be safe

What it feels like: You're about to change something significant and don't want to lose what's currently working.

Why it happens: Without version control, big changes can be difficult to undo if something goes wrong.

💬 Prompt: Before you make any changes, commit everything we have right now. Then create a plan for what you're about to do. Show me the plan before you start.
You want Claude to check its own work

What it feels like: You're tired of reviewing every output manually and want Claude to catch its own mistakes.

Why it happens: Without a verification step, Claude moves on after generating code without testing it.

💬 Prompt: After you make this change, test it yourself. Run the code, verify the output, and confirm it works before showing me the result. If something's wrong, fix it first.
You don't know what to ask or what to do next

What it feels like: You're staring at the screen and not sure where to go from here.

Why it happens: Perfectly normal, especially when building something new.

💬 Prompt: Based on everything we've done so far, what should the next step be? Give me your recommendation and explain why.
03

Write Like the Founder

Context is only as useful as it is specific. The difference between "we run an agency" and the rich version below is the difference between an AI that gives generic advice and one that thinks like you. This section is how to get to the specific version, fast.

🔑 This is non-delegable. You can't hand context building to a VA or developer. The AI OS needs to think like you. Your context, your instincts, your decision-making logic. If someone else fills this in, you end up with a system that thinks like them.

Use Voice, Not Typing

The richest context comes from speaking, not typing. When people type context entries, they write thin bullet points. When people speak, they tell stories, give examples, and explain nuance. That's exactly what your AI needs.

Recommended tools:

  • Super Whisper (Mac): runs locally, transcribes your voice in real time
  • Whisper Flow (Mac/Windows): similar, lightweight voice-to-text

Open one of these, talk through what you want to add to a context file, and paste the transcription into Claude Code. Tell Claude to structure it for the context file.

Or Feed In Files You Already Have

You don't have to start from scratch. If you've got SOPs, internal documentation, strategy decks, onboarding guides, or past business plans, they're probably already full of the context your AI needs. Pull from them.

Drag a file into Claude Code, or paste the contents into the panel, and tell Claude to extract the relevant context and structure it into the right file.

💬 Prompt: I'm pasting in our [type of document]. Read through it and pull out everything relevant to context/[file-name].md. Structure it in the format Claude uses for context files and show me the draft before writing. I'll review it before it gets saved.

After Claude drafts the context from the file, read through it yourself. Files are a starting point. The context file is still your voice and your judgment. Remove anything stale, add anything missing, and push back if Claude misread the source.

Thin vs Rich Context

Thin (produces generic output):

We run a marketing agency. We have 5 team members. We focus on paid ads.

Rich (produces tailored output):

We run a B2B SaaS marketing agency doing about 35k a month. Our core offer is paid media management, but we're strongest on LinkedIn and Google Ads specifically. We've got 5 people. I handle strategy and new business, Sarah runs client delivery, and we've got 3 media buyers. We tried content marketing as a service last year but dropped it because the margins were terrible. Our best clients are Series A SaaS companies with 10k to 20k monthly ad spend.

The second version gives the AI enough to make useful recommendations. The first gives it nothing to work with.

Common Mistakes

  • Too short: One-sentence entries produce generic AI. Go deeper.
  • Outdated: Context files are the source of truth. If something changes in your business, update the file. Stale context produces stale advice.
  • Delegated: Getting a team member to fill in "the boring bits" defeats the purpose. The AI needs to understand how YOU think about these things.
04

Quality Check

Your context is populated. Before you move on to Module 3, stress-test whether the AI actually understands you. Populated is not the same as useful.

Run /prime and Read the Summary

Paste into the Claude Code panel:

💬 Prompt: /prime

/prime loads all your context files into the session. Claude will summarise what it picked up: who you are, what your business does, your strategy, your team, your metrics, your tools.

Read that summary back. Does it sound like your business, or like a generic version of it? If the summary is thin or could apply to any agency owner, your context is still thin. Open your context files directly in VS Code and deepen the entries - more specifics, more examples, more of your actual numbers and decisions.

Stress-Test With Real Questions

The real test isn't whether Claude can recite your context. It's whether Claude can apply it. Ask the AI a handful of real questions and see if the answers feel tailored or generic.

Try these prompts, or variations of them that reflect real decisions you're weighing right now:

💬 Prompt: Based on my current strategy and where the business is right now, what's the single most important thing I should be focused on this month?
💬 Prompt: Knowing my team and how we work, who should I delegate [a specific task you've been sitting on] to, and how should I hand it over?
💬 Prompt: Look at my biggest metric from current-data.md. Given our strategy and the tools in our stack, what are three specific things I could test this week to move that number?
💬 Prompt: I'm considering [a real decision you're weighing]. Based on my decision filters and what you know about my business, what would you recommend and why?

Repeat with whatever matters to you right now. The answers should sound like something a business partner who knows you would say. If they sound like a general management textbook, your context is still thin.

When You're Done

  • /prime summary sounds like your actual business, not a generic version
  • At least three stress-test questions produced answers that felt tailored to your situation
  • You feel confident that if you asked Claude about a decision you're genuinely weighing, the answer would be informed by your context, not boilerplate

You don't need perfection. You need enough depth that Claude's answers are useful. You can always come back and strengthen your context later.

Think About Your Context

🧠 Take 5 minutes to reflect before you move on:
  • What's the single most important thing about your business Claude should know before answering any question?
  • Which of your 6 context files felt richest? Which felt thinnest?
  • If you read your context files back aloud, do they sound like you, or like a LinkedIn post?
  • What's one context entry you'd want to add that isn't in the 6 files yet?
✅ Module 2 complete. Your AI OS now understands your business. Every session from here starts with context loaded.

Next: Module 3 (Data). You'll connect your business tools to your AI OS so it can answer questions with real numbers, not guesses.

←  01  ·  Foundations
Module 03

🔗Data

Connect everything so the AI knows what's actually happening, not just what you told it.

By the end of these 5 sections, you'll have:
  • Your business data sources classified (what gets synced, what stays live)
  • A searchable memory bank for everything that accumulates over time (calls, messages, transactions)
  • Live connections to your ever-changing services (SOPs, today's calendar, current pipeline)
  • One nightly GitHub Actions workflow keeping everything up to date, running in the cloud so your computer doesn't need to be on
  • A verified data layer Module 4's Daily Brief can build on

Module 2 taught the AI what your business SHOULD look like. Module 3 teaches it what's ACTUALLY happening.

01

Data Sources

Module 2 taught your AI OS what your business should look like. Module 3 teaches it what's actually happening.

Without a Data layer, Claude can only answer from what you told it in Module 2. Which is still better than a chatbot with nothing. But it's not live.

This section is the map. What counts as data, where it sits in your AI OS, and how it gets connected. §2 onwards is where you start building.

What Counts as Data

Data here means the things your business generates and uses every day. Not public datasets. Not industry benchmarks. Not market research. The raw material your AI OS turns into intelligence.

  • Conversations: client calls, sales calls, team meetings, Slack threads, email, WhatsApp, voice notes
  • Records: CRM entries, pipeline stages, deal notes, client history
  • Transactions: Stripe charges, Xero invoices, P&L exports, bank data
  • Reference material: SOPs, internal wikis, knowledge bases, process docs, contract templates
  • Signals: calendar events, task systems, project updates, booking systems

Five categories. Different shapes, different places, different update rhythms. Module 3 connects them all so your AI OS can read across them in one breath.

🧱 Where Data Sits in Your AI OS. Module 1 laid out three layers. Context (who you are, how you think). Data (what's actually happening). Function (what gets done about it). Module 2 built Context. Without Data on top, Context is a static document. With it, Context becomes a live dashboard.

Data Behaves in Two Shapes

Not all your business data behaves the same way. Some of it is written once and never changed. The rest gets revised in place.

  • Append-only: written once, left alone. A past call doesn't change. A sent message doesn't change. A completed transaction doesn't change. A CRM note, once logged, stays what it was. This kind of data accumulates, and the value comes from having every one of them available to search across months or years.
  • Ever-changing: revised whenever the business changes. An SOP updated every quarter. A pipeline record moving from Discovery to Proposal. A calendar event rescheduled. A knowledge-base article rewritten. For this kind of data, the current version is almost always what you want. An old version is misleading or wrong.
  • Use the wrong method for each, and one of two things goes wrong. Either you lose history (when you treat append-only as live-only and never store it). Or you act on stale information (when you sync ever-changing data and answer with last week's version).

Two Connection Methods

Because data behaves in two shapes, your AI OS connects it in two ways.

MethodHow It WorksBest For
SyncClaude writes a script that pulls data from the service on a schedule and stores it in your database. Each run adds new records on top of what's already there.Append-only data you'll want to search across months or years. Calls, messages, emails, transactions, CRM events.
LiveClaude queries the service directly the moment you ask, via MCP or a small API wrapper. Nothing gets stored.Ever-changing data where the current version is what matters. SOPs, knowledge bases, today's calendar, current pipeline.

Some services need both. Slack holds months of team history (Sync) and also the current channel state (Live). Gmail holds years of correspondence (Sync) and also today's inbox (Live). Claude picks based on what you're asking.

MCP and API: Quick Refresh

You met both of these in Module 1. Here's the refresher in Module 3's context.

  • MCP (Model Context Protocol): a standardised way for Claude Code to talk to an external service live, in-session. When you ask Claude "what's in my Notion page about onboarding?", and Notion is configured as an MCP, Claude queries Notion right then, reads the current page, and answers. Nothing is stored.
  • API (Application Programming Interface): the public door every service has for programs to read or write. When Claude builds a sync script, that script uses the service's API to pull data out and save it into your database. The script runs on a schedule; each run adds new records.
  • The key difference: MCP is live and stores nothing. Sync is scheduled and builds up your database over time.

What If a Service Has No API?

Some data sources don't have a useful API. WhatsApp chat exports. Spreadsheets. Historical CSV archives from a tool you've since left.

For these, Claude reads files you drop into your project folder and ingests them into your database. One-off imports, then done. The command handles the ingestion the same way as any other source once the file is in place.

💡 Check what's available before you connect. The MCP ecosystem ships new servers weekly. Rather than trusting a static list, ask Claude to check the MCP Registry when you pick a service. The /connect-data command does this for you automatically. Worth knowing the list isn't frozen.

The System Classifies This for You

You don't sort every service by hand. /connect-data reads your integrations.md file, cross-checks the MCP Registry, and proposes a method for each service. You see the table. You approve or adjust. The command handles the rest.

First, though, your database needs somewhere to live. §2 sets that up. Then §3 runs /connect-data and connects your services.

02

Set Up Your Database

Your Data layer needs somewhere to live. A searchable memory bank where every synced call, message, and transaction ends up, ready for Claude to pull from whenever you ask a question.

That somewhere is Supabase. It's a free database service that runs in the cloud. You sign up, get a project, and you've got a place to store everything. Nothing to install on your computer, nothing to maintain.

Supabase comes with a small add-on called pgvector. It lets the database search by meaning, not just by exact words. That's what makes "find calls where clients expressed doubt" work, even when nobody used the word "doubt" in the call.

One database. One place for everything you sync. You set it up once here, and every section after this builds on top of it. Paste this into Claude Code:

💬 Prompt: /connect-data set up supabase

What the command does:

  • Walks you through creating a free Supabase project (takes about 2 minutes)
  • Collects your project credentials and saves them locally
  • Wires your database into Claude Code so Claude can query it directly in every session
  • Turns on the add-ons that make semantic search work
  • Creates the search() function - what Claude calls whenever you ask a content question. For now it's an empty shell, because no data's flowing yet. It fills out as you connect services in §3.
  • Runs a small self-test to confirm everything works. You approve each step.

When it's done, your Data layer foundation is live. No business data yet: that starts in §3.

Under the Hood: What /connect-data set up supabase Builds

You don't need to hand-tune any of this. Knowing what's there builds confidence.

  • Per-source tables: each service you connect gets its own table, shaped to its real data. Call transcripts get a summary, attendees, action items. Stripe charges get amounts, customers, dates. No generic mould forced on every source.
  • Semantic search for your content: text tables (transcripts, messages, emails) each get a "meaning index". Two pieces of text with similar meaning get similar indexes, so "find calls where clients expressed hesitation" lands the right calls even when nobody used the word "hesitation". Anthropic's embedding partner Voyage generates these indexes.
  • Keyword search alongside it: the same text tables also get a simple word-level index. That's what catches invoice numbers, client names, specific dates. Semantic and keyword search run together whenever Claude needs to find something.
  • The search() function: one function Claude calls whenever you ask a content question. It runs semantic and keyword together across every text table, then ranks the best matches through a dedicated scoring model. You never see any of this.
  • Structured data stays simple: financials, KPIs, ad performance. Claude queries those with regular database aggregation (totals, averages, trends). No semantic search: numbers don't need it.
  • Live connections for ever-changing data: SOPs, today's calendar, current pipeline. Never stored. Claude queries the service directly at question time.
  • Summary mode and Deep mode for long-form text: call transcripts get a choice when you connect them. Summary mode (default) stores a summary per call. Deep mode (opt-in) splits each call into searchable passages. More on this in §3.
  • Freshness and no duplicates, baked in: every synced record tracks when it was written so Claude can flag stale data. Running a sync twice never creates duplicates: edits at the source update the record instead.

Where Supabase Sits in Your AI OS Memory

Supabase isn't where everything lives. Your AI OS has a few kinds of memory, each in a different place.

  • Claude Code's own memory: identity, rules, recent patterns. That's CLAUDE.md, Auto Memory, and the conversation you're in right now. Loaded automatically every session. You don't manage it.
  • Supabase: the cold, searchable historical stuff. Call transcripts, Slack messages, Stripe charges. Everything that accumulates and needs searching across months or years.
  • Live connections: current state from the source. Today's calendar, the current SOP, this morning's pipeline. Queried on demand, never stored.

Three places, one system. Claude picks the right one for whatever you're asking.

When You Outgrow This (spoiler: not any time soon)

The default setup comfortably handles agency-sized data. For scale: 10,000 hours of coaching calls would still sit well below the ceiling.

If you ever need more capacity, there's a drop-in upgrade called pgvectorscale. Same database, same connection, one extra add-on. Proven at 5× the scale without performance loss.

Don't install it now. The default is correct. This is here so you know the ceiling isn't close and the upgrade path is simple.

03

Connect Your Services

Your database is ready. Now each service on your integrations.md list gets connected.

/connect-data reads that file, classifies every service (Sync if the data accumulates, Live if the current version is what matters, both if the service holds both kinds), and walks you through them in priority order. You approve each connection. The command handles the rest.

Paste this into Claude Code:

💬 Prompt: /connect-data connect my services

What happens per service:

  1. Classify. The command reads your integrations file and cross-checks the MCP Registry to pick the right connection method.
  2. Pick the shape. How data gets stored depends on what kind of data it is:
    • Short text (messages, CRM notes): one row per item
    • Long text in Summary mode (transcripts, default): one row per item with an AI-generated summary
    • Long text in Deep mode (transcripts, opt-in): every transcript split into searchable passages
    • Numbers (Stripe, Xero, ads): plain structured data
  3. Ask for your token. Claude asks for the service's API token; you paste it in.
  4. Build. The command writes the sync script (or wires the live connection). For services with pre-built templates, this is instant. For anything else, Claude designs it on the fly.
  5. Show you the cost. Before pulling history, Claude estimates what it'll cost. You choose: pull everything, last 90 days only, or skip history entirely.
  6. Test. A small batch gets pulled and confirmed. You see real data from your service.
  7. Mark it done. The command updates your integrations file so next time it picks up where you left off.

You approve each service in priority order. A few minutes per service, less for known ones.

For long-form services (call transcripts, long emails) the command asks one extra question: Summary mode (default, cheap, finds which items touched a topic) or Deep mode (opt-in, costs about $0.01 per item extra, finds exact moments inside items).

Start with Summary mode everywhere and switch specific services to Deep mode later if you need it.

Connect one service at a time:

💬 Prompt: /connect-data connect slack

Upgrade a service to Deep mode later:

💬 Prompt: /connect-data connect otter --deep

Upgrading re-processes that service's history with the deeper approach. Cost is shown before it runs.

⚠️ Live connections live inside your Claude Code session. If Claude Code isn't running, Live tools aren't available. If your session disconnects (you close the laptop, your Wi-Fi drops, the extension reloads), the connection reconnects when you come back. That's fine for interactive queries. But don't build anything that needs to run unattended on top of Live alone. Your Daily Brief workflow in Module 4 shouldn't depend on your VS Code session being open. For anything that needs to work when you're not there, use Sync.
⚠️ Never sync ever-changing reference data. SOPs, policy docs, knowledge bases, live pipeline state. If you sync an SOP today and it's updated tomorrow, your stored version is wrong until the next sync runs. A stale SOP is worse than no SOP. /connect-data won't do this by default. But if you ever override it manually, this is the trap to avoid.

Under the Hood: The Five Storage Shapes

Claude picks the right shape based on the service's data pattern plus a live MCP Registry check. Two surfaces (Sync and Live), five shapes in total.

  • Short text (Slack, Discord, CRM notes, Gmail): one row per item. Each message or note is small enough to store and search directly.
  • Long text, Summary mode (transcripts, default): one row per item with an AI-generated summary. Search finds which calls touched a topic. Cheap, fast, works for most retrieval.
  • Long text, Deep mode (transcripts, opt-in): each transcript split into passages, each with a short AI context line describing the parent. Search finds specific moments within calls, not just which calls to listen to. Opt-in per service because it costs more.
  • Structured numbers (Stripe, Xero, QuickBooks, ad performance): plain structured records. Claude queries these with regular database aggregation. No semantic search needed because totals, averages, and trends don't want it.
  • Live (Notion, Google Drive, Google Calendar, current CRM records): not stored. Claude queries the service directly whenever current state is what you want. Uses MCP where available, or a small API wrapper if no MCP exists.

Services that hold both patterns (Slack, Gmail, Airtable, HubSpot) get wired for both: Sync for history, Live for current state. Claude picks based on whether your question is "across time" or "right now".

Where Your Credentials Live (the .env file)

Every service you connect hands you an API token when you set it up. Think of it as a password that lives in code, not in your head. Claude uses that token to log into the service on your behalf whenever the sync runs.

Tokens live in a file called .env in your project folder. "Env" is short for "environment variables" - developer-speak for "settings and secrets the code reads at runtime". For you, it's a simple text file with your tokens, one per line.

  • What you do: when Claude asks for a token, paste it into the chat. Done.
  • What Claude does: saves it to .env with a sensible name (SLACK_TOKEN, STRIPE_KEY, HUBSPOT_KEY, and so on) and wires the sync scripts to read from there. You never edit .env by hand.
  • .env is gitignored by default. If you ever push your project to GitHub, the file stays on your machine and nobody else sees your tokens. Don't commit it.
  • If you need to rotate a token (one expired, or you accidentally shared it): regenerate it in the service's dashboard, tell Claude "update my Slack token", paste the new one when asked, and Claude overwrites the old one in .env. The next sync uses the new token automatically.

Where Common Services Typically Land

A quick lookup for where the most common agency tools usually end up. The system classifies each service automatically; this is a map for curious readers, not a decision tree.

Call Recordings and Transcripts
ServiceWhat It Gives YouConnection
Google MeetMeeting transcripts (via Google Drive)Sync
ZoomMeeting recordings and transcriptsSync
Otter.aiMeeting transcriptsSync
FirefliesMeeting transcripts and AI notesSync
Loom*Video transcriptsSync

*Loom uses the fallback template path rather than a pre-built one.

Team Communication
ServiceWhat It Gives YouConnection
SlackTeam messages, client channels, channel activitySync + Live
GmailEmail threads, client communicationSync + Live
Discord*Community messages, support threadsSync
WhatsAppClient communication (chat export)Manual upload

*Discord uses the fallback template path.

SOPs and Knowledge
ServiceWhat It Gives YouConnection
Google DriveSOPs, documents, shared filesLive
NotionKnowledge bases, wikis, project docsLive
ClickUp / Asana*Task data, project docs, activity historySync + Live

*ClickUp and Asana use the fallback template path.

CRM and Sales
ServiceWhat It Gives YouConnection
AirtablePipeline, client records, sales trackingSync + Live
HubSpotDeals, contacts, pipeline, activity logSync + Live
GoHighLevelCRM, pipeline, automationsSync + Live
Pipedrive / Close*Deals, contacts, pipelineSync + Live

*Pipedrive and Close use the fallback template path.

Financials
ServiceWhat It Gives YouConnection
StripeRevenue, subscriptions, invoices, chargesSync
XeroP&L, invoicing, cash flow (UK/AU primarily)Sync
QuickBooksP&L, invoicing, cash flow (US primarily)Sync
SpreadsheetsCustom financial reports, one-off dataManual upload
Marketing
ServiceWhat It Gives YouConnection
Meta AdsAd spend, performance, ROASSync
Google Ads*Ad spend, performance, conversionsSync
GA4 / Google Analytics*Website traffic, conversion dataSync
YouTube AnalyticsChannel performance, video metricsSync

*Google Ads and GA4 use the fallback template path.

What About Services I Don't See Here?

17 services have pre-built templates (the list in the opener). For anything else, Claude designs the setup on the fly when you connect it.

The command reads the service's API docs, proposes a structure that fits its data, and shows you the plan before writing any code. You approve, Claude builds.

Common services that use this path: Pipedrive, Close, ClickUp, Monday.com, Intercom, Zendesk, Linear, Loom, Calendly. Niche tools almost always work this way.

04

Automate Your Syncs

A system that needs you every week won’t get used. Automation is what turns your AI OS into infrastructure.

Your Live connections are already live. Every time you ask Claude a question about your SOPs or Google Calendar, the service gets queried right then. Nothing to automate there.

Your sync scripts, though, need to run on a schedule. This section sets that up. Paste this into Claude Code:

💬 Prompt: /connect-data schedule syncs

The command creates one nightly GitHub Actions workflow at .github/workflows/data-sync.yml that runs all your sync scripts in order, by default at 02:00 UTC. One schedule. One log. One thing to check if something goes wrong.

GitHub Actions is GitHub's built-in cron platform (see the GitHub Actions docs). Workflows run on GitHub's runners, not your machine. Your computer doesn't need to be on. The free tier covers a daily 5-minute sync many times over.

The command walks you through three things:

  1. Committing the workflow file to your repo
  2. Adding your SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY, and per-service API tokens as GitHub secrets (Settings - Secrets and variables - Actions)
  3. Triggering a manual run from the Actions tab to confirm it works before waiting for the cron

Syncs only pull what's new. Each script remembers when it last ran. The next run only fetches records added or updated since then. A day's worth of Slack messages costs pennies to process, not the full history every time.

If you ever want finer scheduling (say, Slack every six hours and everything else nightly), you can split specific scripts into their own workflow files later. Start with the default.

🧱 This is what separates a one-time export from a living system. Your Daily Brief in Module 4 is only useful if it has yesterday's data, not last month's. Automate the syncs now so your functions always have fresh information.
05

Test Your System

Before Module 4 relies on your data layer, confirm it works. One query per source. Then one query across all of them. Then a freshness check. If all three land, you're ready.

Single-Source Test

Paste this into Claude Code, replacing [SERVICE NAME] with one of your connected services:

💬 Prompt: Query my [SERVICE NAME] data and give me a summary of what you can see. What data is available? If Claude comes back with real data from your service (your actual clients, your actual messages, your actual meetings) the connection works.

What This Unlocks

Now that you have a few services connected, your AI OS can answer questions it couldn't before. Real examples of what you can ask in week one:

  • "Find all calls where clients mentioned onboarding friction."
  • "What was revenue last month vs the month before?"
  • "Which clients haven't heard from us in two weeks?"
  • "What's the most common reason deals go cold at Discovery?"
  • "Summarise this week's team activity."
  • "Draft a follow-up email to Client X using the tone of my last three messages to them."

Each of these was impossible before the Data layer was built. After Module 3, they all work.

Cross-Source Test

Once you have multiple sources connected, test that Claude can cross-reference them:

💬 Prompt: Using all my connected data sources, give me a summary of what happened in my business this week. What meetings took place, what deals moved, and what messages need attention? This is the real test. If Claude can pull from multiple sources and synthesise a coherent answer, your data layer is working.

Freshness Check

Claude's meant to mention when your data is stale. Confirm it does:

💬 Prompt: When was my data last synced? Are any of my services more than a day out of date? Claude reports freshness per service. For anything that hasn't updated recently, it'll say so and offer to trigger a sync manually.

Troubleshooting

When a test fails or something doesn't behave, expand the matching problem below.

Sync failed overnight

Check the sync log in outputs/sync-log/. Most common causes: an API token expired (regenerate it in the service's dashboard), the service's API was down (re-run tonight, usually self-heals), or a rate limit hit. Ask Claude: "Read the latest sync log and tell me what failed and how to fix it."

A service I connected isn't showing up in Claude's tools

Live connections bind when Claude Code starts. After connecting a new one, close and reopen Claude Code. Run /mcp to confirm the service is listed. If it's still missing, the token might not have the right permissions. Check against the service's required scopes.

Claude can't find something I know is in my data

Three likely causes. First, the service might not be synced yet. Run /connect-data status to check. Second, your wording might catch keyword where semantic doesn't (or the reverse). Try phrasing it differently. Third, some rows might be missing meaning indexes if a sync interrupted mid-run. Ask Claude: "Check for any unindexed rows in [service] and fix them."

Claude answered using the wrong service

It searches across everything by default. To scope to one service: "Answer only from [service]." Claude will narrow the search.

Backfill cost was higher than I expected

Backfill estimates are based on record count times average length. Some services have longer records than assumed. For future backfills, "last 90 days" is a safer default than "everything."

Think About What You've Built

🧠 Before moving on, reflect on these:
  • Which connected data source is most likely to change your decision-making first? Why?
  • What data didn't you connect in this pass that you'd want on your next pass? What's blocking it?
  • If you asked your AI OS right now "what should I prioritise this week?", would the answer feel specific to your business, or still generic? What would you need to add to close the gap?
  • Which scheduled workflow, once running, would save you the most time every week?

Think it through. In Module 4 you'll turn this data into your first automated output.

✅ Module 3 complete. Your AI OS now has a real Data layer: a searchable memory bank for everything that accumulates over time, live connections to your ever-changing services, and one consolidated nightly GitHub Actions workflow keeping it all fresh.

Next: Module 4 (Function). You'll build the Daily Brief, your first automated output that reads your Context and Data every morning, synthesises business intelligence across all your connected sources, and delivers it to you before you open your laptop.

←  02  ·  Context
Module 04

⚡Function

The AI starts working for you. The first outputs that prove the system is alive.

By the end of this module, you'll have:
  • A Daily Brief generating automatically every morning via a GitHub Actions workflow
  • Mobile access configured (Slack, Telegram, or Claude native, your call)
  • Decision Engine activated in your brief with structured recommendations and a Monday summary
  • The Autonomy Ladder internalised so you know how systems earn autonomy
  • Vocabulary for Skills, Hooks, and Subagents when you're ready to extend
This is where the AI OS stops being a tool you talk to and starts being a system that works for you.
01

What Function Actually Is

Function is the action layer. Anything your AI OS produces, decides, runs on a schedule, or delegates to an agent. That's Function.

What This Module Teaches

Four high-leverage starting points:

  • Daily Brief. Morning intelligence report, generated automatically.
  • Mobile access. Chat-bot or native app, reachable anywhere.
  • Decision Engine. Activates in Section 4. Learns how you decide, earns autonomy over time through your morning brief.

Beyond These Three

Function covers anything you can describe. Four categories:

TypeExamples
AutomationsPetty tasks that save 10 minutes a day. Bigger ones that replace a team member.
Analysis layersCohort analysis. Customer health scoring. Variance vs plan. Trend detection.
AgentsFollow-up drafters. Lead qualifiers. Meeting-to-action-item extractors.
SchedulesStalled-deal pings. Ad anomaly alerts. Client-going-quiet warnings.

If you can describe a process in words, you can turn it into a Function.

⚠️ Don't skip to Function. It's only as good as the Context and Data underneath it. Thin layers below means generic outputs that read like anyone's. Rich layers below means work that reads like yours. Module 2 and 3 aren't optional. They're what makes this module worth your time.

Sections 2-4 are the three starting points. Section 5 (Skills, Hooks, Subagents) is how you extend.

02

Build Your Daily Brief

This is where the AI OS starts working for you. The Daily Brief is your first real output. A scheduled workflow that runs every morning, reads your context and data, and hands you a structured snapshot of your business before your day starts. What's happening in sales, what the team's working on, which clients need attention, what you should focus on today. You'll plan it, build it, generate the first one manually to check it, then automate it. End to end, the first concrete proof the system is alive.

Step 1: Plan Your Brief

Before Claude writes any code, you need to decide what your Daily Brief actually covers. Generic answer: "how's the business?" Useful answer: a structured read that forces you to look at the same six things every morning so you spot change before it becomes a problem.

Every good Daily Brief covers:

  1. Revenue and cash position. Your financial pulse yesterday, this week, this month, with pipeline outlook.
  2. Growth signals. Content, leads, and top-of-funnel trends with week-over-week deltas.
  3. Yesterday's decisions and actions. What was agreed, what's still open, what's slipping.
  4. Team and community pulse. Who's active, who's stuck, who hasn't been contacted in too long.
  5. SWOT. Strengths, weaknesses, opportunities, threats updated daily based on what actually moved.
  6. Today's focus. 3–5 priorities ranked by leverage.

Every brief covers these six. What varies is what you pull into each one based on your business. Paste this into the Claude Code panel:

💬 Prompt: I want to build a Daily Brief, a morning intelligence report that reads my context and data every day and tells me what matters. Use /create-plan.

Read my context files and check what data sources are connected. Then design a brief that covers these 6 sections, adapted to my specific business:

  1. Revenue and cash position
  2. Growth signals (content, leads, pipeline trends)
  3. Yesterday's decisions and actions (meetings, messages, commitments)
  4. Team and community pulse (activity, concentration risks, relationship health)
  5. SWOT, daily, specific, data-backed
  6. Today's focus: 3–5 priorities ranked by leverage

For each section, propose specific analyses based on my context, not a generic dashboard. Prioritise leverage over vanity (show rate over close rate, revenue per activity over raw volume). Map cascade effects where an upstream metric shift signals a downstream risk in 2 to 3 weeks. End every section with implications, not just numbers. Close the brief with data gaps I should close for the next version. Show me the plan before you build. I'll tell you which sections to expand, which metrics to add or drop, and whether anything's missing.

Claude reads your context (Module 2), checks what data sources are connected (Module 3), and designs a brief that layers your specific analyses over the 6-section spine. Review the plan before moving to Step 2. Make sure every section has implications (not just numbers), flags concentration risk where it applies, and ends with the data gaps to close for next time.

Step 2: Build the Brief Script

/implement executes the plan Claude just wrote, step by step. It writes real code that reads your data, structures the output, and saves it to your project. Expect this to take a few minutes and touch several files. Paste this (replace the path with what Claude gave you at the end of Step 1):

💬 Prompt: /implement [plan path that Claude provided]

Claude walks the plan step by step. Let it work. When it finishes, you have a working brief generation script.

Step 3: Generate Your First Brief

Before automating, run it manually once. You want to see the output, catch anything off, and tune before the workflow starts posting this every morning.

💬 Prompt: Generate today's Daily Brief and save it to outputs/briefs/ with today's date.

This is the moment. Your AI OS reads your context, pulls your live data, and produces an intelligence report tailored to your business. Open the file in outputs/briefs/ and read it back. Does it sound like your business? If it feels generic, strengthen the layers below.

🔑 This is what the layers are for. Your brief is only as good as your Context (does the AI understand your priorities?) and your Data (does it have real numbers?). If the brief feels generic, go back to Module 2 or Module 3 and strengthen the weak layer.

Step 4: Automate It with GitHub Actions

What a workflow is: A GitHub Actions workflow is a YAML file in .github/workflows/ that runs on GitHub's runners on a cron. It checks out your project, installs Node, runs a script that calls the Anthropic API with your context, and posts the output wherever you want (Slack, email, Notion, a file committed back to the repo). Your computer can be off. The workflow still runs.

Why you're doing it now: You just generated the brief manually. Every morning doing that manually isn't a system, it's a chore. Automating it is what turns this into something that works for you on its own.

Note if you've used Routines before: earlier guidance pointed at Anthropic's Routines for this. Routines couldn't reach Supabase or run TypeScript sync scripts reliably, so the guide moved to GitHub Actions in May 2026. If you set up a Routine, migrate it via the prompt below.

In the Claude Code panel, paste:

💬 Prompt: Read reference/scheduling.md and help me set up a GitHub Actions workflow to generate my Daily Brief every morning automatically. Use /create-plan first.

Claude walks you through copying the canonical workflow template (.github/workflows/daily-brief.yml.example), customising it for your timezone, adding the secrets in GitHub (ANTHROPIC_API_KEY, SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY, optional SLACK_WEBHOOK_URL), and triggering a manual run from the Actions tab to confirm it works. Once it's live, the brief generates every morning, even when your computer's off. No server needed. A single workflow can chain output steps: generate the brief, save the full version to outputs/briefs/, post the headline to Slack via webhook, email you the summary.

💡 What scheduled workflows cost. A Daily Brief averages roughly $0.30 to $1.00 per day in Anthropic API tokens, depending on context size and model. GitHub Actions free tier covers 2,000 minutes/month for private repos - a daily 5-minute job uses about 150 minutes/month. You'll need an Anthropic API key separate from your Pro/Max plan, generate one at console.anthropic.com. Pro/Max covers your interactive Claude Code sessions; the API key covers your scheduled workflow runs.
03

Set Up Mobile Access

Your AI OS should be reachable anywhere, not just at your desk. Morning briefs on your commute. Quick questions from client meetings. Approving long-running Routines while you're out. Below are three paths for doing that. Pick one to start.

Two Different Jobs

There are two reasons to have mobile access, and they call for different tools.

Chat-bot UX (Slack / Telegram)Claude-native UX (Mobile app + Remote Control)
Feels likeA person messaging youA tool you open
Best forQuick queries, proactive nudges, team-shared accessBuilding, editing, reviewing diffs, long work
Setup effortMedium. Webhook or managed connector.Low. Pair via QR in 60 seconds.
Shareable with team?Yes. Group chats or channels.No. Tied to your account.
💡 The recommended endgame is both. Chat-bot for the assistant UX (morning brief, proactive pings, quick questions). Claude mobile or Web for the workshop UX (actual work on the go). Start with one. Add the other when you see what the first unlocks.
Path A: Slack Bot

If your team lives in Slack, this is the strongest play. Near-zero backend.

Before you start: You'll need the Daily Brief workflow from Section 2 of this module. Path A is the Slack delivery layer for that Brief. If you're skipping Section 2 for now, go with Path B or Path C instead, neither depends on it.

Primary setup: Daily Brief workflow posts to a Slack channel every morning via an incoming webhook.

  1. Create a Slack incoming webhook. In Slack: Apps - Incoming Webhooks - Add to Slack - pick the channel (e.g. #daily-brief) - copy the webhook URL.
  2. Add the webhook URL as a GitHub secret. In your repo on GitHub: Settings - Secrets and variables - Actions - New repository secret. Name it SLACK_WEBHOOK_URL, paste the URL.
  3. Wire it into your Daily Brief workflow. In Claude Code, paste:
💬 Prompt: Add a step to my Daily Brief workflow that posts the brief headline to Slack via my SLACK_WEBHOOK_URL secret. Update scripts/run-brief.ts to fetch the webhook URL from env vars and post the headline at the end of the script.

Claude updates the workflow file and the script, you commit and push. The next scheduled run posts to the channel. Your AI OS posts its Daily Brief to the channel every morning. The team sees it, reacts, discusses. Pros: Simplest setup. One credential (the webhook URL). No managed connector dependency. Free. Cons: Outbound only. Posts, doesn't reply. For interactive @mention replies, see the variant below.

Interactive variant: @mention replies via Slack app + serverless

Use this if you want your AI OS to reply when teammates @mention it in Slack (not just post the morning brief). Same pattern as Path B's Cloudflare Workers variant, just with Slack's API surface. Step 1. Create a Slack app. Go to api.slack.com/apps. Create a new app. Copy the bot token (xoxb-...) and signing secret. Step 2. Configure the app. Subscribe to the app_mention event. Add chat:write and app_mentions:read scopes. Install the app to your workspace. Step 3. Build the bot. In Claude Code, paste:

💬 Prompt: I've got a Slack app with a bot token (starts xoxb-), a signing secret, and the app_mention event subscribed. Build me a Slack bot using Cloudflare Workers (or Vercel if you prefer) that listens for @mentions of my bot, verifies the Slack signature, calls Anthropic with my full AI OS context, and posts the reply back via chat.postMessage. Respond to Slack's webhook immediately with 200 OK and do the Anthropic call plus the reply async so we don't hit Slack's 3-second timeout. Put the bot token, signing secret, and my Anthropic API key in Worker env vars. Use /create-plan first.

Claude designs the plan, then builds the serverless function, deploys it, and configures the Slack app's Events Request URL to point at the Worker. Cost: roughly $0/month for a solo user on light traffic. Check Cloudflare Workers' and Vercel's current free-tier limits if you're expecting team-level volume. Pros: Two-way. Team can @mention your AI OS and get context-loaded replies. Works unattended. Cons: More setup. Needs a serverless host. Two API surfaces to maintain (Slack + Anthropic).

Path B: Telegram Bot

Universal messaging, works on any phone, shareable. For Telegram, Claude Code has a native plugin that makes setup properly simple. The Cloudflare Workers route is available if you need a bot that runs when Claude Code is off.

Before you start: Requires Claude Code v2.1.80+ and Bun installed.

Primary setup: Anthropic's official Telegram plugin.

  1. Create a Telegram bot. Open @BotFather on Telegram. Send /newbot, follow the prompts, copy the token it returns.
  2. Install the plugin. In Claude Code, paste:
💬 Prompt: /plugin install telegram@claude-plugins-official
  1. Configure your token.
💬 Prompt: /telegram:configure <your-bot-token>
  1. Restart Claude Code with the channels flag. Exit Claude Code. In your terminal, relaunch it with claude --channels plugin:telegram@claude-plugins-official.
  2. Pair your account. Message your bot on Telegram. It replies with a pairing code. Back in Claude Code:
💬 Prompt: /telegram:access pair <code>

Then lock it down so only your account can message the bot:

💬 Prompt: /telegram:access policy allowlist

The channel runs while Claude Code is running. Close the terminal and the bot pauses. If you need a bot that works unattended, see the variant below.

Pros: Simplest setup. Official plugin. Pairs in minutes. No serverless host. Free. Cons: Runs only while Claude Code is running.

Unattended variant: Cloudflare Workers

Use this if you need the bot to respond when Claude Code is off, you're building for team-scale traffic, or you want to attach the bot to other systems (CI, webhooks). Step 1. Create a Telegram bot. Open @BotFather on Telegram. Send /newbot, follow prompts, copy the token. Step 2. Build the bot. In Claude Code, paste:

💬 Prompt: I've got a Telegram bot token from @BotFather and an Anthropic API key ready. Build me a Telegram bot using Cloudflare Workers (or Vercel if you prefer) that relays messages to my AI OS. Put both into Worker env vars. Use /create-plan first.

Claude designs the plan, then builds the serverless function, deploys it, and configures the Telegram webhook. Cost: roughly $0/month for a solo user on light traffic. Check Cloudflare Workers' and Vercel's current free-tier limits if you're expecting team-level volume. Pros: Works unattended. Scales to team traffic. Free-tier-friendly for light use. Cons: More setup. Needs a serverless host. More to maintain.

⚠️ The old pattern was a Python script running forever on a VPS. That's not the April 2026 pattern. Serverless webhook means it runs only when a message arrives.
Path C: Claude Remote Control (Vibe-Code On The Go)

For when you need full Claude Code power on mobile: reviewing diffs, running long Routines, editing context files. This complements Path A or B. It doesn't replace them.

Before you start: Pro, Max, Team, or Enterprise plan (API keys aren't supported). Claude Code v2.1.79+ for the VS Code command. v2.1.110+ for push notifications. Run claude in your project directory once to accept the workspace trust dialog.

  1. Download the Claude mobile app. From the App Store or Play Store. Or run /mobile in Claude Code to get a download QR code.
  2. Sign in. Open the Claude app and sign in with the same claude.ai account you use for Claude Code.
  3. Start a Remote Control session. In your Claude Code session (CLI or VS Code), type:
💬 Prompt: /remote-control

A session URL and a QR code appear.

  1. Pair your phone. Scan the QR code with your phone's camera, or open the session URL in any browser. Your phone is now driving the session that's running on your machine. The conversation syncs across every connected device.
  2. (Optional) Enable push notifications. So Claude can ping you when a long task finishes. In your terminal, run /config and turn on "Push when Claude decides".

Your phone now has full access to the session running on your machine: filesystem, MCP connectors, env variables. Nothing moves to the cloud. Your phone is just a window.

Limitations: Local process must keep running. Close the terminal and the session ends. Network outages over 10 minutes time out the session. Some commands stay local-only: /mcp, /plugin, /resume.

Alternative: Claude Code on the Web (claude.ai/code). Different tool, different use case. Runs in Anthropic's cloud, cloned from GitHub. No local machine required. Use this when you want to kick off a task without any local setup.

Which Should I Start With?
SituationRecommendation
Your team or you already live in SlackA (Slack). Easiest, highest-frequency touch.
You want an assistant feel, no SlackB (Telegram). Universal, modern pattern.
You want to actually work on mobileC (Claude app). Add alongside A or B.
You want the assistant UX and mobile workA or B + C. The recommended endgame.

Start with one chat-bot path this week. Add the Claude mobile app when you next travel or want to work from your phone.

What You Can Do Once It's Live

Once connected, you can message your AI OS from your phone to:

  • Ask for today's brief
  • Search your meeting notes
  • Query your CRM data
  • Log a decision
  • Ask any question about your business

Claude responds with full access to your Context, Data, and Functions. Not a chatbot with canned responses. Your actual AI OS, in your pocket.

04

Activate Your Decision Engine

The Decision Engine is where your AI OS learns how you think. Every decision you log, and every recommendation you accept or reject from your morning brief, trains it. Not on someone else's decisions. On yours. Over months, it stops guessing and starts remembering: "you've faced this before, here's what you did, here's what happened."

This section introduces the engine and walks you through activating it. After activation, two things start happening. First, each morning your Daily Brief gets a new Section 7 added, with 1 to 3 specific recommendations you can accept or reject. Second, every decision you log gets embedded into a queryable store so the engine can spot patterns and match similar situations when they come up again.

⚠️ Don't activate yet if your Daily Brief isn't live. This section builds on top of the Daily Brief you set up in Section 2. The engine adds a new Section 7 to your existing brief, and on Mondays a Section 8. It doesn't create a separate brief. There's nothing to plug into if Section 2 isn't complete. Finish Section 2 first, then come back.
What Changes When You Activate

Three new things get added to the Daily Brief you built in Section 2 once the engine is live. A new Section 7 in your morning brief. After the existing six sections (Revenue, Growth, Meetings, Team, SWOT, Today’s Focus), the brief appends 1 to 3 specific, tracked recommendations. Each has a short ID you reply to. Example of what it looks like:

## 7. Today’s Recommendations

[rec_a7f2k3] Test a payment plan on sales calls. Close rate dropped to 24%, pricing is the main objection in 60% of lost calls last week.

[rec_b3k9m2] Cancel the 2pm with Mark tomorrow. Three meetings tomorrow that could be emails, this one has no agenda and you cancelled the last two.

An evening recap at 6pm. The system sweeps the morning’s recommendations. If you haven’t accepted or rejected any, you see them again in a compact list with one-line reply instructions. Three taps and you’re done.

## Evening Recap

### This morning’s recs, quick sweep

[rec_a7f2k3] Payment plan test. Act on this today?

[rec_b3k9m2] Cancel 2pm with Mark. Act on this today?

Reply in one line:

/decide accept rec_a7f2k3
/decide reject rec_b3k9m2 no-time

A Weekly Decision Summary on Mondays. Your Monday morning brief appends a Section 8 with last week’s activity, your true acceptance rate, where the AI is still missing context, deferred items coming back soon, and which modules are ready to move up the Autonomy Ladder.

The 5 Ways to Say No (and Why They Matter)

When you reject a recommendation, you tell the engine which kind of "no" it is. The command is /decide reject rec_xxxxxx <category>, where <category> is one of the five below. Example: /decide reject rec_a7f2k3 disagree Sarah is in board prep this week, premature to push. Each category tells the engine something different. Pick the one that fits why you’re saying no. This is what makes the acceptance rate honest, a busy-week "no-time" doesn’t get lumped in with a genuine disagreement.

CategoryUse it when...What it signals
disagreeYou don’t think this is the right call at all.Real rejection. Counts against the AI in your acceptance rate.
no-timeGood idea, no capacity today.Neutral. Your busy day, not the AI’s bad suggestion.
redundantAlready done. Already knew.Your Context layer is missing this info. Update it.
wrong-contextAI is missing a key piece of data that would change this.Your Data layer has a gap. Strengthen it.
later [N]Good idea, just not now. Resurface in N days (default 7).Deferred. Comes back automatically in your brief’s Revisit block.
💡 Why five categories, not one. An honest acceptance rate means only the recs you actively disagreed with count against the AI. A busy week where you said "no-time" ten times doesn’t punish it. "Already done" isn’t the AI being wrong, it’s your Context being stale. Separating these is how you get a truthful signal on whether the AI is actually getting smarter.
How the Engine Actually Learns

Before the morning brief emits a new recommendation, the engine runs one quick check: "have I seen similar recommendations before, and how did they land?" If you’ve disagreed with 3 or more similar recommendations in the past: the engine suppresses the new one. It never appears in your brief. You see the debug note in logs if you’re curious, but the recommendation itself is filtered out. The engine stops wasting your time on patterns you’ve already pushed back on. If you’ve accepted 80% or more of similar past recommendations: the engine emits the new one with a confidence marker. You’ll see something like [rec_a7f2k3, boosted: 86% on 7 similar past]. That tag tells you the system has strong historical evidence you’d accept this. If there isn’t enough history yet (under 3 similar past recs): the engine emits normally. No marker either way. This is the feedback loop. Simple, transparent, honest. The engine gets better at picking what to surface without ever deciding on your behalf.

Why Recommendations Don’t Pile Up

Three rules keep the queue manageable, always. 72-hour auto-expire. A recommendation you didn’t accept or reject within 72 hours quietly expires. It doesn’t count for or against the AI. It just goes away so it doesn’t clutter your evening recap forever. Max 3 pending. If you’re already sitting on 3 open recommendations, tomorrow morning’s brief won’t add more. Instead you see a short message: "You have 3 recs still open from previous days. Clear them first." This stops the backlog problem dead. Same-issue dedup. If "reach out to Sarah" is already pending, and tomorrow the system would have generated the same suggestion, it skips. No nagging. Your evening recap stays short. Your morning brief stays focused. The engine respects your time.

The Autonomy Ladder, Contextualised

Your AI OS progresses through four phases. Promotion between phases is always your call, but the Monday Weekly Decision Summary shows you when each module is ready.

PhaseModeWhat Happens
1InformAI collects data and presents it. You read and act.
2RecommendAI suggests specific actions with reasoning. You decide.
3ConfirmAI drafts and queues actions. You approve or reject.
4AutonomousAI executes routine decisions within guardrails.

Guardrails, always in force regardless of phase:

  • Financial transactions
  • External communications to clients or customers
  • Hiring decisions
  • Strategic commitments
💡 True acceptance rate is the measure. Accepted divided by (accepted + disagree). Only explicit disagreement counts against the AI. Neutral categories (no-time, redundant, wrong-context, later) are excluded. This means a busy week where you said "no-time" a lot doesn’t drag you down the ladder, but a week where you genuinely disagreed with half the recs does.

Your Monday Section 8 shows the trailing-50 true acceptance rate for each module (Daily Brief, Sales, Team, etc.). When a module crosses 80% over 50 recommendations, it’s eligible to promote to Recommend. When it crosses 90% over 100 queued actions, it’s eligible for Confirm. You decide when to flip the switch.

Activation: The One Prompt

Before you start:

  • Sections 2 to 3 of this module complete (your Daily Brief is live)
  • A Voyage API key in your project’s .env.local as VOYAGE_API_KEY. Free key at console.voyageai.com if you don’t have one.

In Claude Code, paste:

💬 Prompt: /activate-decision-engine

Claude reads the implementation spec, designs a plan tailored to your setup (your exact brief structure, your scheduler, your optional Telegram or Slack bot), and walks you through approval before building anything. Expect the full activation to take 5 to 10 minutes.

Claude runs a verification pass during activation. If any part of your system doesn’t pass, Claude stops and fixes it before reporting success. The acceptance gate catches bugs before they hit your real morning brief. What gets built:

  • The schema on your Supabase so decisions, status, and categories can be tracked
  • The helper scripts your brief generator calls
  • Edits to your existing Daily Brief to add Section 7 (preserves your original six sections exactly)
  • A new 6pm evening recap workflow (.github/workflows/evening-recap.yml)
  • A Monday 06:30 rollup workflow that feeds Section 8 (.github/workflows/weekly-rollup.yml)
  • If you have a Telegram or Slack bot: the accept and reject flow works directly from there too

What happens to your existing /decide decisions: every Markdown file in data/decisions/ gets imported into the Decision Engine. Your history is preserved. Nothing you’ve already logged is wasted.

Start Logging Now (even before activation)

/decide is for logging decisions you’ve made. Not questions you want the system to answer, not ideas you’re weighing. Actual decisions - the moment after you’ve chosen a path, you run /decide to capture what you chose, why you chose it, and what you expect to happen. That’s what the engine learns from. It works today, before you activate. Use it for significant business calls: pricing, hiring, strategic commitments, client decisions, process changes. Activation imports every decision you’ve logged, so there’s no reason to wait.

💬 Prompt: /decide I’ve raised retainer pricing by 20% for new clients only. Close rate of 42% signalled underpricing, and I’d rather have fewer clients at higher margins.

Claude asks for context, options, rationale, and expected outcome. A structured decision file lands in data/decisions/. After activation, that file becomes a row in the Decision Engine, ready for similarity matching and 30-day review.

🔑 Log early, log often. Every decision is a training data point. After 20 logged, you’ll start seeing patterns. After 50, the engine recognises your pricing, hiring, or client-scope decisions and surfaces relevant history when you face similar calls. The compounding is real.
What to Expect in the First Week After Activation
  • Tomorrow morning: your brief has a new Section 7 with 1 to 3 recommendations. Reply with /decide accept rec_xxxxxx or /decide reject rec_xxxxxx <category>.
  • Tomorrow evening at 6pm: the evening recap sweeps any morning recs you haven’t closed out. One-line reply and you’re done.
  • Next Monday morning: Section 8 Weekly Decision Summary appears. Activity last week, acceptance rate, Context gaps, Ladder status.
  • 30 days from now: your first 30-day review prompt appears in your morning brief. "You logged X decisions last month. Here are the ones due for review."
  • 60 days from now: pattern clustering gets meaningful. The Monday summary starts showing genuinely useful trends.
  • 90 days and beyond: the Autonomy Ladder has real substance behind it and it’s time for you to /create-plan to use your system’s new intelligence to begin automating areas of your business.
05

Advanced: Skills, Hooks, and Subagents

Three Claude Code features you should know exist. You don't need to use them in week one, but you should know what they are so you can reach for them when you hit a ceiling.

Skills are your own custom /commands. Hooks trigger automation on session events. Subagents are focused AI agents spawned for a specific task with their own context window. Each one multiplies what your AI OS can do once you're comfortable with the basics.

Every /command you've used so far (/prime, /build-context, /connect-data, /create-plan, /implement, /decide, /activate-decision-engine) is already a Skill. Naming the feature unlocks your ability to build your own.

Skills, Hooks, Subagents: What They Are
FeatureWhat It DoesExample Use
SkillsCustom /your-command shortcuts. Store in .claude/commands/ with frontmatter metadata.Build a /weekly-review skill that runs a specific multi-step analysis every Monday
HooksTrigger automation on lifecycle events (session start, before or after tool use, session end).Auto-run /prime at session start so you never forget context loading
SubagentsSpawn focused AI agents for sub-tasks with their own context window.Research one topic deeply without polluting the main session context

Docs: Skills · Hooks · Subagents

💡 When to use these. Most members stick to Skills in month one. Hooks shine in month two (automate session start). Subagents shine in month three, especially when building sellable systems where you want specialist agents focused on different tasks.

Think About What You've Built

🧠 Take 5 minutes to reflect before you move on:
  • Of the three pillars in this module (Daily Brief, mobile access, Decision Engine), which one will compound the fastest for your business?
  • Which phase of the Autonomy Ladder are your scheduled workflows at right now? Which ones could progress to the next phase in the next 30 days?
  • What's a decision you've been sitting on that you should log in the Decision Engine today?
✅ Module 4 complete. Your AI OS is operating on its own. Brief every morning with structured recommendations you can accept or reject, evening recap at 6pm, Weekly Decision Summary on Mondays, accessible anywhere, specialist agents at your fingertips.
←  03  ·  Data