Synthos AIOS — initial build

.claude/skills/audit/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: audit
+description: Use when someone asks for an AIOS audit, asks to score their setup against the Four Cs, or says "is my AIOS working" / "audit my setup" / "find gaps in my AIOS". Produces a Four-Cs scoreboard with top-3 fixes ranked by leverage.
+---
+
+## What this skill does
+
+Runs the **Four Cs Audit** on the current Claude Code project. Reads (never writes) the project's operating manual, memory, skills, agents, MCPs, decisions, and references. Scores each of the Four Cs out of 25. Surfaces strengths and the top 3 leverage-weighted gaps with concrete next-step commands.
+
+**Scope is structural — "is the AIOS built right?"** It is NOT a capability planner. Capability gaps ("you could build a daily brief if you connected calendar") belong to `/level-up`. The audit answers: are the files, folders, registries, and connections in good shape?
+
+First run is the baseline. Re-run weekly to watch the score climb. That's the compounding hook.
+
+## Today's context
+
+- **Date:** !`date +%Y-%m-%d`
+- **Project root:** the current working directory
+
+## The Four Cs (scored 25 each = 100 total)
+
+| Layer | Test |
+|---|---|
+| **Context** | Knows the business — identity, team, voice, decisions, references |
+| **Connections** | Reaches the user's stuff — MCPs, integrations, data sources |
+| **Capabilities** | Knows how to do work — skills + agents |
+| **Cadence** | Runs without being asked — schedules, hooks, recurring rituals |
+
+## Execution
+
+### Step 1: Discover the project shape
+
+The audit looks for **patterns and intent**, not exact paths. File names vary. Use Glob and Read to check:
+
+**Operating manual:** `CLAUDE.md` (root), `CLAUDE.local.md` (gitignored).
+**Memory:** `MEMORY.md` (root), `~/.claude/projects/<id>/memory/MEMORY.md`, or `memory/` folder.
+**Skills:** `.claude/skills/*/SKILL.md` — count + frontmatter.
+**Agents:** `.claude/agents/*.md` — count + frontmatter.
+**Connection mechanisms** (any of these = "reachable"):
+- MCPs: `.mcp.json`, `.claude/settings.json` (mcpServers key), `.claude/settings.local.json`
+- API scripts: `scripts/*.py|.js|.ts` documented in CLAUDE.md
+- Export pipelines: `data/`, `imports/`, `exports/` with refresh script + last-run timestamp
+- API keys + reference guide: `.env` entries + corresponding `references/{tool}-api.md`
+
+**Connections registry:** `connections.md` (anywhere).
+**Reference guides:** `references/{tool}-api.md`, `references/*-reference.md`, or equivalent.
+**Decisions:** `decisions/log.md`, `decisions.md`, or any append-only decisions file.
+**References / SOPs:** `references/`, `docs/`, `sops/` folders.
+**Templates:** `templates/`, `.claude/templates/`.
+**Hooks / scheduled jobs:** `.claude/settings.json` hooks key, or skill names matching `morning-*`, `weekly-*`, `daily-*`, `monthly-*`, `standup`.
+
+Don't penalize for non-canonical names if equivalent intent is captured elsewhere.
+
+### Step 2: Score each C (25 points each)
+
+#### Context (25 pts)
+
+| Criterion | Points | How to detect |
+|---|---|---|
+| Operating manual exists and is substantive (>200 words) | 5 | Read CLAUDE.md, count words |
+| Identity / role / voice captured | 5 | CLAUDE.md mentions who the user is + role/mission, OR `.claude/rules/*.md` exists |
+| Persistent memory exists with multiple entries | 5 | MEMORY.md exists with >3 entries, OR `memory/` has >3 files |
+| Reference docs exist | 5 | `references/`, `docs/`, or `sops/` has ≥1 file |
+| Decisions captured | 5 | `decisions/log.md` or equivalent has ≥1 entry |
+
+#### Connections (25 pts) — domain-aware, mechanism-agnostic
+
+A "reachable" connection counts via ANY mechanism: MCP, script, export pipeline, or `.env` key + `references/{tool}-api.md`. The kit is API-first; the audit doesn't prefer MCPs.
+
+**The 7 Tier-1 Universal Data Domains:**
+
+| # | Domain | Examples |
+|---|---|---|
+| 1 | Revenue / Financials | Stripe, Skool, GoHighLevel, QuickBooks, Looker |
+| 2 | Customer interactions | HubSpot, Salesforce, Gmail-as-CRM, Skool DMs |
+| 3 | Calendar | Google Cal, Outlook, Calendly |
+| 4 | Communication | Gmail, Outlook, Slack, Teams |
+| 5 | Project / task tracking | ClickUp, Asana, Linear, Notion DB, Jira |
+| 6 | Meeting intelligence | Granola, Otter, Fireflies, Gong, Zoom |
+| 7 | Knowledge / files | Notion, Drive, Dropbox, Confluence, SharePoint |
+
+**Tier-2 (bonus):** AI service API keys (OpenRouter, Anthropic, OpenAI), decisions/history, content/publishing.
+
+| Criterion | Points | How to detect |
+|---|---|---|
+| Tier-1 domain coverage | 10 | 1.4 pts per tier-1 domain reachable. Round to nearest 0.5. Cap 10. |
+| Reference guide presence | 5 | -1 per connected tool with no `references/{tool}-api.md`. Floor 0. |
+| Auth / pipeline freshness | 5 | -1 per connection in `needs-auth`/`expired` state, or script with no run within 30 days. Floor 0. |
+| Documentation in `connections.md` | 3 | 0 if missing; 1 sparse; 2 most; 3 covers all reachable. |
+| Read-AND-write balance | 2 | At least one connection can WRITE (send email, post update, etc.). 0 if all read-only — the AIOS is a viewer not an OS. |
+
+#### Capabilities (25 pts)
+
+| Criterion | Points | How to detect |
+|---|---|---|
+| 3+ skills installed | 10 | Count `.claude/skills/*/SKILL.md` |
+| 1+ user-built skill | 10 | Skill names not in: `onboard`, `audit`, `level-up`, `skill-creator`, `skill-builder`, `decision`, `connect`, `connect-check`, `memory-prune`, `scaffold-skill`, `scaffold-agent`, `draft`, `standup` (canonical AIS-OS + Anthropic shipped skills) |
+| 1+ agent defined | 5 | Count `.claude/agents/*.md` ≥ 1 |
+
+#### Cadence (25 pts)
+
+| Criterion | Points | How to detect |
+|---|---|---|
+| 1+ recurring/scheduled trigger | 10 | `.claude/settings.json` hooks, OR skill name matches `morning-*` / `daily-*` / `weekly-*` / `monthly-*` / `standup` |
+| Recent activity / usage signal | 10 | Files in `.claude/skills/` modified within 30 days, OR `decisions/log.md` has entry within 30 days |
+| Templates folder populated | 5 | `templates/` or `.claude/templates/` has ≥1 file |
+
+### Step 3: Identify top 3 gaps by leverage
+
+For each criterion that lost points: leverage = (points lost) × (impact multiplier).
+
+**Impact multipliers:**
+- 0 tier-1 domains reachable: **4x** (AIOS is blind to the business)
+- Operating manual missing or thin: **3x** (foundation)
+- ≤2 tier-1 domains reachable: **3x** (Connections is the gateway to live data)
+- 0 skills: **2x** (no Capabilities = no AIOS)
+- No recurring trigger: **2x** (no Cadence = no autonomy)
+- All connections read-only: **2x** (viewer, not an OS)
+- 0 reference guides for connected tools: **1.5x** (every future skill re-researches the same APIs)
+- No decisions log: **1.5x**
+- All others: **1x**
+
+Sort gaps by leverage descending. Take top 3. For each, write a one-line concrete next step:
+- **Need a new skill?** Recommend `skill-creator` (Anthropic) or `skill-builder` (if local), or "write SKILL.md at `.claude/skills/<name>/SKILL.md` with YAML frontmatter."
+- **Need to log a decision?** "Append to `decisions/log.md`."
+- **Need to reach a tier-1 domain?** Prefer API+script (write `scripts/{tool}_api.py` + save `references/{tool}-api.md`). Recommend `claude mcp add` only if no API path exists.
+- **Connected tool missing a reference guide?** "Research the API once, save endpoints + auth + common queries to `references/{tool}-api.md`."
+- **Need a recurring trigger?** "Add a hook to `.claude/settings.json`, or write a skill named `daily-*` you run each morning."
+
+### Step 4: Output the report
+
+Print directly in chat (Markdown). Format:
+
+```
+# AIOS Audit — {date}
+**Score: {total}/100** ({stage})
+
+Stage thresholds:
+- 0-39 → Stage 0: Foundation
+- 40-69 → Stage 1: Built
+- 70-89 → Stage 2: Compounding
+- 90-100 → Stage 3: Autonomous
+
+## Scoreboard
+
+Context        {bar}  {n}/25  {label}
+Connections    {bar}  {n}/25  {label}
+Capabilities   {bar}  {n}/25  {label}
+Cadence        {bar}  {n}/25  {label}
+
+(bar = ## per 5pts; label = "Strong" ≥20, "Solid" 15-19, "Thin" 8-14, "Missing" <8)
+
+## Strengths
+- {1-3 short bullets from highest-scoring criteria}
+
+## Top 3 Gaps (ranked by leverage)
+1. **{gap name}** (-{points} × {multiplier})
+   → {concrete next-step}
+2. **{gap name}** (-{points} × {multiplier})
+   → {concrete next-step}
+3. **{gap name}** (-{points} × {multiplier})
+   → {concrete next-step}
+
+## Suggested next: {single most leveraged action}
+
+---
+Structural gaps only. To explore CAPABILITY gaps (what your AIOS could DO that it can't yet), run /level-up after this audit.
+```
+
+### Step 5: Offer to save the report
+
+After printing, ask: "Save this audit to `audits/audit-{date}.md` so you can track score over time?" If yes, write it (creating `audits/` folder if needed). This is the only writable side effect.
+
+## Notes
+
+- **Read-only by default.** Never modify CLAUDE.md, memory, skills, or any project files. Only optional write is the audit report.
+- **Be flexible about file names.** Don't penalize for using non-canonical names if intent is captured.
+- **Be honest, not generous.** A 95/100 is a flex. Most setups land 40-70.
+- **Don't suggest skills that don't exist.** Point at what's actually available.
+- **Speed matters.** Report in under 60 seconds wall-clock. Read targeted files, count skill folders without reading each fully (frontmatter only).
+- **Cadence detection is fuzzy.** Infer from skill names if hooks/cron data isn't cleanly available.

.claude/skills/level-up/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: level-up
+description: Use weekly to find and ship one new automation. Walks the 3Ms interview — Mindset (find the candidate) → Method (scope one) → Machine (build it). Trigger on "let's level up", "what should I automate next", "find me leverage this week", or as a Friday ritual. One run = one shipped artifact.
+---
+
+> *Adapted from The Three Ms of AI™. © 2026 Nate Herk. All rights reserved.*
+> *The Three Ms of AI™ is a trademark of Nate Herk.*
+
+## What this skill does
+
+Walks the user through the 3Ms each week to surface and ship one new automation. **One interview = one artifact.** It also installs the 3Ms framework into the user's head over time — after 4-6 runs, the user starts spotting opportunities mid-week without prompting because the questions have become internal defaults.
+
+This is the brain-rewire mechanism. The kit doesn't need cron jobs to anchor behavior; it needs `/level-up` running every Friday.
+
+## What `/level-up` is NOT
+
+- Not `/audit`. `/audit` is structural ("is the AIOS built right?"). `/level-up` is functional ("what business leverage am I missing?"). Run `/audit` first if structure is messy.
+- Not a multi-candidate planner. One run = one shipped artifact.
+- Not a coach. The user does the thinking. The skill conducts the interview.
+
+## When `/level-up` runs
+
+- **First run: Day 14.** After the user has connected ≥1 MCP/script and run `/audit` once. Earlier yields trivial output.
+- **Cadence: weekly, Friday afternoon.** Review the week, surface one automation, ship Monday.
+- **On-demand any time.** Mid-week if a manual task itches.
+
+## Inputs the skill reads
+
+- `context/priorities.md` — what the user said matters
+- `context/about-me.md` — top_pain, role
+- `connections.md` — what's reachable, by what mechanism
+- `references/3ms-framework.md` — the framework (used to quote principles back)
+- `decisions/log.md` — recent decisions (what's already shipped or considered)
+- `.claude/skills/*/SKILL.md` frontmatter — what capabilities exist
+- Recent `audits/audit-{date}.md` if present
+
+## Execution — three phases
+
+### Phase 1 — Mindset interview (find the candidate)
+
+Surface 1-3 candidates ranked by leverage. Ask these in order, conversationally:
+
+1. *"Walk me through your week. What did you do 3+ times?"* (frequency)
+2. *"Anything that felt manual, boring, or copy-paste?"* (drudgery)
+3. *"Anything where you thought 'a smart intern could handle this'?"* (delegation)
+4. *"If 500 new clients showed up tomorrow, what would break first?"* (constraint)
+5. *"What would give you 500 more clients tomorrow?"* (growth lever)
+
+Quote relevant Mindset principles when they fit:
+- *"Sounds like the Default Shift applies — to what extent could AI be leveraged here?"*
+- *"This is the Function Breakdown — you're not automating the whole job, just this one piece."*
+- *"AI is better than you think and improving faster than you think. If it couldn't do this last quarter, it might be ready now."*
+
+**Output of Phase 1:** numbered list of 1-3 candidate opportunities, one-line "why this is leverage" per candidate. Ask: *"Pick one to scope."*
+
+### Phase 2 — Method interview (scope one)
+
+User picks one candidate. Walk the 5-step Method pipeline:
+
+**Step 1 — Find the constraint.** Which bottleneck does this solve, or which growth lever does it open? Tie back to Phase 1 answers.
+
+**Step 2 — EAD: Eliminate / Automate / Delegate.**
+- **Eliminate first:** *"What happens if we just stop doing this?"* If the answer is "nothing breaks" → skill exits cheerfully. *"Don't automate waste."* This is a win, log to `decisions/log.md` and stop.
+- **Automate second:** apply 60/30/10 framing. ~60% deterministic, ~30% AI-assisted, ~10% manual.
+- **Delegate third:** if too complex/variable/judgment-heavy → suggest a person. Skill exits with a delegation suggestion, log it.
+
+**Step 3 — Map the process.** Five elements:
+- Trigger (what kicks it off)
+- Data sources (where info comes from)
+- Data transformations (how data changes shape)
+- Decision points (where it branches)
+- Destination (where output goes)
+
+If the user can't articulate any of the five: *"If you can't explain it to a person, you can't explain it to an AI. Sketch it on paper first, then come back."* Skill stops.
+
+**Step 4 — Pick the autonomy level.**
+
+| Level | Name | What happens |
+|---|---|---|
+| L0 | Manual | No AI |
+| L1 | Suggested | AI suggests, human decides every step |
+| L2 | Drafted | AI drafts, human reviews and edits |
+| L3 | Supervised | AI runs, human validates periodically |
+| L4 | Autonomous | AI handles end-to-end |
+
+**Default = lowest level that solves the problem.** Push back on L4 unless the user has explicitly run lower levels first. *"Workflows beat agents. If a decision doesn't HAVE to be made by AI, don't let AI make it."*
+
+**Step 5 — Tie to a KPI.** Which of the Three Buckets does this move?
+- More customers
+- More value per customer
+- Less cost
+
+Plus a specific metric (response time, error rate, conversion rate, time-to-completion). **If the user can't name a bucket and a metric, skill stops.** *"If your automation doesn't move a number, why are you building it?"*
+
+**Output of Phase 2:** scoped automation spec written to `decisions/log.md` as a dated entry with all five answers + autonomy level + KPI. Durable record of what was decided and why.
+
+### Phase 3 — Machine handoff (build it)
+
+Ask: *"How do you want to ship this?"* Options ordered by Boring-is-Beautiful default:
+
+1. **Prompt-only** — saved prompt template the user runs by hand. Zero infrastructure. Highest manual involvement.
+2. **Deterministic skill** — SKILL.md that runs a script (no AI step). Best for transformations with clear rules.
+3. **AI-assisted skill** — SKILL.md with one AI call inside. Drafts, classifies, summarizes.
+4. **Sub-agent** — multi-step agent. Last resort. Only if the work genuinely needs reasoning + tool use.
+
+**Default selected = highest non-AI option that solves the problem.** User has to explicitly choose more autonomy.
+
+Once chosen, route to the appropriate scaffolder:
+- `skill-creator` if available globally (Anthropic-shipped)
+- `skill-builder` if user has it locally
+- Otherwise write a SKILL.md / agent file inline with frontmatter, location, and contents
+
+**Every scaffolded artifact ships with these two headers at top:**
+
+```markdown
+---
+bike-method-phase: 1  # Phase 1 — Training wheels. Run manually first.
+three-ms-attribution: |
+  Adapted from The Three Ms of AI™ © 2026 Nate Herk.
+---
+```
+
+This locks the user into Phase 1 of the Bike Method on first build. They can't silently skip manual validation. Phase advances only by explicit edit.
+
+Surface the Machine principles when scaffolding:
+- **Lego Principle** — smallest steps, zero-AI first if possible
+- **Validation Chain** — test each step before chaining
+- **Iteration Mindset** — ship the POC, expand from real usage
+
+## Output contract
+
+Every `/level-up` run produces:
+
+1. **One `decisions/log.md` entry** — dated, with the Method spec
+2. **One scaffolded artifact** — prompt, skill, or agent file
+3. **A one-screen close** — what was scoped, what was built, and the Bike Method Phase 1 reminder
+
+## Critical implementation rules
+
+1. **One interview = one artifact.** No multi-candidate parallel scoping.
+2. **Mindset phase always runs first.** Even if user comes in with a pre-formed idea.
+3. **EAD enforces "eliminate first."** If the answer is Eliminate, exit cheerfully — that's a win, not a failure.
+4. **Default to the lowest autonomy level that works.** Push back on L4.
+5. **Boring-is-Beautiful default in Machine handoff.** Default = highest non-AI option.
+6. **Tie-to-KPI is mandatory.** If user can't name bucket + metric, skill stops.
+7. **Bike Method ships into every artifact.** `bike-method-phase: 1` in frontmatter.
+8. **Read-only on user files except `decisions/log.md` and the new artifact.** Don't modify other existing files.
+9. **Trademark + attribution on output.** Every report and every scaffolded artifact references the framework.
+
+## Verification (for the implementer)
+
+- **Dry run on Nate's Herk-2** with no prompt. Expected: skill surfaces 2-3 candidates pulled from his recent activity, priorities, and top_pain. Generic output ("you should build a brief") = fail.
+- **Eliminate-first test.** Feed an obviously eliminate-able candidate. Expected: skill suggests Eliminate, exits, logs the win.
+- **L4 push-back test.** User asks for autonomous email-replier on first build. Expected: skill insists on L1/L2 first, won't ship L4 without explicit override.
+- **Boring-is-Beautiful test.** Candidate solvable with deterministic Python. Expected: skill recommends `(2) deterministic skill` as default.
+- **Bike Method anti-skip.** User scaffolds, asks to advance to Phase 4 immediately. Expected: skill makes them read what each phase means and confirm they've validated lower phases.
+
+---
+
+> *The Three Ms of AI™ is a trademark of Nate Herk. © 2026 Nate Herk. All rights reserved.*

.claude/skills/onboard/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: onboard
+description: Use on Day 1 of an AIS-OS install, when someone says "set me up", "onboard me", "let's get started", "fill in my AIOS", or has just cloned the kit. Combined wizard — runs the 7-question intake AND scaffolds the Day-1 file set at the end. Idempotent — re-run any time after editing aios-intake.md.
+---
+
+## What this skill does
+
+Single combined wizard. Reads or writes `aios-intake.md` (the canonical intake), conducts the 7-question interview if the file isn't filled, then scaffolds the Day-1 file set inline at the end of the run. No separate `/scaffold-from-intake` skill — this is one flow.
+
+**The wow moment:** at the end, suggest the closing prompt *"Try this — ask me: what should I focus on this week?"* The user runs it once. That's the wow. There's no `/today` skill to save — the prompt itself plants the Mindset framework (Default Shift) for them to internalize.
+
+## When NOT to run this
+
+- If the user has already onboarded and wants to refresh: still run, but skip questions already answered (idempotent).
+- If the user wants to add a new connection: that's not onboarding — point them at `connections.md` to edit directly, or schedule a `/level-up` Phase 2 walk.
+
+## Execution
+
+### Step 1: Read the intake
+
+Read `aios-intake.md`. Check which Q1-Q7 sections have content vs. `[Your answer here]` placeholders.
+
+- **All filled** → skip Step 2, jump to Step 3 (scaffold).
+- **Some filled** → ask the user: "I see Q1, Q3, Q4 are answered. Want to fill the rest now, or scaffold from what's there?" Their call.
+- **None filled (fresh clone)** → run Step 2 conversationally.
+
+### Step 2: The interview (7 questions, hard cap)
+
+Ask one at a time. Write each answer into `aios-intake.md` as you go (so the user can resume if interrupted).
+
+**Q1 — Who are you, what do you sell, who do you sell it to?**
+Identity, offer, ICP. One paragraph each is fine.
+
+**Q2 — Paste 1-2 things you've written recently. Don't edit them.**
+*This is the only question with a hard rule.* Voice samples MUST be pasted, not typed mid-conversation. If the user starts typing fresh prose, refuse:
+
+> *"Stop — paste it raw. If you type it here while we're talking, the sample is already shaped by our conversation. Open your last email or LinkedIn post in another tab and paste the unedited text. This is the one rule I can't bend."*
+
+Ask for two samples. One email, one post. Or two of either.
+
+**Q3 — What are your 2-3 biggest priorities for the next 90 days?**
+Quarterly priorities. Push back if they say "grow my business" — make them name a number, a deadline, or a deliverable.
+
+**Q4 — Where does revenue actually land, and where is it tracked?**
+Multiple answers OK. Map to Tier-1 Domain 1 (Revenue/Financials).
+
+**Q5 — Where do you talk to customers, your team, and the outside world day-to-day?**
+Email (Gmail/Outlook), Slack/Teams/Discord, DMs. Map to Domains 2 + 4.
+
+**Q6 — Where do meeting recordings, notes, and important docs live?**
+Map to Domains 6 + 7.
+
+**Q7 — What's the one task that eats your week, and where do you currently track work?**
+Capture top_pain (used by `/level-up` Day-14) + Domain 5 (tasks).
+
+Domain 3 (Calendar) is auto-inferred from Q5: Gmail → Google Cal; Outlook → Outlook Cal. Confirm in Step 3.
+
+### Step 3: Scaffold the Day-1 file set
+
+Once the intake is complete, generate these files (or update if re-running). Back up originals to `archives/intake-{YYYY-MM-DD-HHMM}/` if any exist.
+
+1. **`context/about-me.md`** — from Q1 (identity, role) + Q7 (top_pain). One short paragraph each.
+2. **`context/about-business.md`** — from Q1 (offer, ICP) + Q4 (revenue model). One paragraph.
+3. **`context/priorities.md`** — from Q3. Numbered list, one line per priority.
+4. **`references/voice.md`** — from Q2. Paste samples verbatim with a short header explaining their use ("Match this register when drafting; don't fake voice on external content without showing me first").
+5. **`connections.md`** — populate the 7-row table from Q4-Q7 answers. Each row gets `mechanism: not yet connected`, `auth: —`, `last checked: —`. The user wires connections on Day 2.
+6. **`CLAUDE.md`** — fill all `{{...}}` placeholders. Substitute the user's name, stated priority, voice register summary, and a brief connections summary.
+
+### Step 4: The closing screen
+
+Print one screen. Three lines max:
+
+```
+✓ Day 1 done. Your AIOS knows who you are, what you sell, what matters this quarter, and how you sound.
+
+Today: ask me — "what should I focus on this week?"
+Tomorrow: pick one tool from connections.md and wire it up (manual MCP install or write a small API script + save references/{tool}-api.md).
+Day 7: run /audit to see your score.
+```
+
+When the user runs the closing prompt ("what should I focus on this week?"), respond using only the new context files. Hit:
+- 3-bullet priority list, in their voice register from Q2
+- Each bullet ties back to a stated 90-day priority from Q3
+- Final line: *"If I had to pick one thing for Monday, it'd be [X], because [reason from priorities]. Want me to draft the first email? And — where could the Default Shift apply here? To what extent could AI be leveraged on this task?"*
+
+The Default Shift question seeds the Mindset framework before `/level-up` formally introduces it on Day 14.
+
+## Critical implementation rules
+
+1. **The 7-question cap is non-negotiable.** Don't add Q8 in conversation.
+2. **Voice paste cannot be skipped.** If the user types samples mid-chat, refuse and tell them to paste from real writing.
+3. **One-shot scaffold.** After Step 2 ends, write Step 3 files in a single batch. No multi-turn confirmation. The user iterates by editing `aios-intake.md` and re-running.
+4. **Idempotent.** Re-running with an edited intake refreshes context files; backs up originals to `archives/intake-{ts}/`. Skips questions already answered unless the user wants to revise.
+5. **Closing screen is three lines.** Not a menu.
+6. **No extra skills generated.** Don't scaffold `/today`, `/draft`, `/connect`, etc. The kit ships 3 skills; the user authors more via `/level-up`.
+7. **Read-only on `references/3ms-framework.md`.** It already ships in the kit. Don't overwrite.
+8. **No `.env` writes.** Don't ask for API keys on Day 1. Connections come Day 2.
+
+## Verification (for the implementer)
+
+- Cold-test: clone a fresh kit, run `/onboard`, fill 7 answers, scaffold runs, ask the wow prompt, response cites Q1 + Q3 + Q7 specifically. Generic = fail.
+- Idempotency: re-run `/onboard` with one Q3 priority changed. Expected: only `context/priorities.md` and `CLAUDE.md`'s priority section update; backup created in `archives/intake-{ts}/`.
+- Voice rejection: type a sample mid-chat. Expected: skill refuses, asks for paste.
+
+> *Adapted from The Three Ms of AI™ © 2026 Nate Herk. The Mindset language used in the closing screen comes from `references/3ms-framework.md`.*

.gitignore

@@ -0,0 +1,8 @@
+.env
+.env.local
+.DS_Store
+*.log
+__pycache__/
+node_modules/
+.claude/settings.local.json
+audits/

CLAUDE.md

@@ -0,0 +1,46 @@
+# {{Your Name}}'s AI Operating System
+
+You are {{Your Name}}'s personal AIOS. Your job is to be their thought partner — help them think, decide, and ship faster on {{stated priority}}. You're a learning companion, not a vending machine.
+
+## Your operator brain — the 3Ms
+
+Read `references/3ms-framework.md` once. It's how {{Your Name}} thinks about AI work. Mindset (how to think), Method (how to decide), Machine (how to build). Reference it when running `/level-up`.
+
+> *The Three Ms of AI™ is a trademark of Nate Herk. © 2026 Nate Herk.*
+
+## Your skills
+
+- `/onboard` — already run if you're seeing this filled in. Re-run any time to refresh from an edited `aios-intake.md`.
+- `/audit` — Four-Cs gap report. Run on Day 7, then weekly. Watch your score climb.
+- `/level-up` — Weekly 3Ms interview. Find one automation, scope it, ship it. One per week.
+
+## Where things live
+
+- `context/` — about you, your business, your priorities (filled by `/onboard`)
+- `references/` — frameworks, voice samples, API guides as you connect tools
+- `connections.md` — registry of every system your AIOS can reach
+- `decisions/log.md` — append-only record of decisions and why
+- `archives/` — old stuff. Don't delete. Move here.
+
+See `EXPANSIONS.md` for what to add as you grow.
+
+## Knowledge base
+
+{{Filled by /onboard from Q1 + Q3 — what you do, who you serve, what matters this quarter.}}
+
+## Voice
+
+Match the register in `references/voice.md`. Casual but professional. Short sentences. No em dashes. Bullet points over paragraphs. Don't fake my voice on external content (LinkedIn, email to clients) without showing me a draft first.
+
+## Connections
+
+{{Filled by /onboard from Q4-Q7. Each entry is a tool the AIOS knows about but may not be connected to yet. Run /audit to see freshness.}}
+
+## How you work with me
+
+- Be direct, concise, and clear. No fluff.
+- Lead with what needs action, not status updates.
+- When I ask a question, answer it. Don't pad with restating the question.
+- When I make a decision, suggest logging it via the decisions log.
+- When you spot a manual task I'm doing 3+ times, surface it next time `/level-up` runs.
+- Default Shift: when I bring a new task, ask "to what extent could AI be leveraged here?" before assuming I'll do it the old way.

EXPANSIONS.md

@@ -0,0 +1,77 @@
+# EXPANSIONS — what to add as you grow
+
+The kit ships lean on purpose. Three skills, six folders, one framework reference. That's it. As you use it, you'll outgrow the base — this guide tells you what to add, when, and why.
+
+The AIOS structure should look like a small, well-run business. Not a hoarder's basement.
+
+---
+
+## What ships in the kit (don't remove)
+
+| Folder / file | Purpose |
+|---|---|
+| `context/` | About you, your business, your priorities. Filled by `/onboard`. |
+| `references/` | Frameworks, voice samples, API guides, SOPs as you build them. |
+| `decisions/log.md` | Append-only record of what was decided and why. |
+| `archives/` | Old files. Don't delete — move here. |
+| `connections.md` | Registry of every system your AIOS can reach. |
+| `.claude/skills/` | Your skills: `/onboard`, `/audit`, `/level-up`. Add more via `/level-up`. |
+| `aios-intake.md` | Source-of-truth for `/onboard`. Edit and re-run any time. |
+| `CLAUDE.md` | Root operating manual. Filled by `/onboard`. Edit when your role/voice changes. |
+
+---
+
+## What to add as you grow
+
+| Folder / file | Add when | Why |
+|---|---|---|
+| `projects/` | You start running 2+ ongoing workstreams that have their own context | Active projects need scoped context separate from the evergreen `context/` files |
+| `templates/` | You catch yourself copy-pasting the same prompts or doc scaffolds | Reusable, parameterized starting points; reduces drift |
+| `brand-assets/` | You generate visual content (carousels, slides, thumbnails, images) | Centralizes logos, palettes, fonts, voice/tone — the AIOS reaches in instead of guessing |
+| `references/sops/` | You document how recurring processes run | Standard operating procedures the AIOS reads to run things consistently |
+| `references/{tool}-api.md` | You connect a new API or MCP and figure out how it works | Researched-once-saved-forever. `/audit` rewards this; future skills don't re-research. |
+| `scripts/` | You write Python or Bash to hit APIs not covered by MCPs | Most people's second connection is a script, not an MCP |
+| `.claude/agents/` | You need a sub-assistant for repeatable, multi-step research/writing | Agents run on cheaper models in their own context — keep your main session lean |
+| Sub-OS folders (e.g. `youtube-os/`) | You have a vertical with its own data, sheets, transcripts, scripts | Isolation pattern — vertical workflows get their own scoped operating manual + skills |
+
+---
+
+## Suggested cadences
+
+When each surface gets routinely touched:
+
+- `decisions/log.md` — every meaningful decision (`/level-up` Phase 2 captures these automatically)
+- `archives/` — quarterly cleanup; move stale projects, deprecated skills, old intake versions
+- `references/sops/` — when a process gets re-run by someone new, write the SOP
+- `connections.md` — every time a new tool gets wired in, add a row
+- `references/{tool}-api.md` — same time as `connections.md` update; capture the API once
+- `CLAUDE.md` — quarterly review; rewrite the persona/priorities section after `/level-up` Q90
+
+---
+
+## What NOT to add
+
+Anti-patterns. These look helpful but rot the structure:
+
+- **Don't dump raw email/Slack archives into `references/`.** The wiki is not a doc dump. Interpreted facts only.
+- **Don't build folder-of-folders for organization theater.** Flat with good naming beats deep nesting. If you need a folder hierarchy to find something, you have a search problem, not an organization problem.
+- **Don't add `notes/`, `misc/`, `tmp/`, or `inbox/`.** Graveyards. Use `archives/` if it's old, write a real file in the right place if it's new.
+- **Don't pre-create folders you don't need yet.** Empty folders are noise. The AIOS will tell you when it's time.
+- **Don't have parallel `decisions.md` and `decisions/log.md`.** Pick one. The kit ships `decisions/log.md`.
+- **Don't fork your operating manual.** One `CLAUDE.md` at the root. Sub-OS folders can have their own scoped CLAUDE.md, but the root is canonical.
+
+---
+
+## How to tell when it's time to add a folder
+
+Ask three questions:
+
+1. **Is this conceptually new?** Or does it fit somewhere existing?
+2. **Will I touch this 3+ times in the next month?** If not, it's premature.
+3. **Could `/level-up` route a future skill into here naturally?** If yes, the AIOS will use it. If no, you're organizing for yourself, not for the system.
+
+Two yeses = add. One yes = wait.
+
+---
+
+> *Your AIOS structure should look like a small, well-run business — not a hoarder's basement. When you can't find something, that's a signal to consolidate, not to add another folder.*

LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Copyright (c) 2026 Nate Herk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Three Ms of AI™ is a trademark of Nate Herk. The framework content in
+references/3ms-framework.md is shared under the same MIT terms; the trademark
+on the name is reserved.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,133 @@
+# AIS-OS — AI Operating System starter kit for Claude Code
+
+A free, MIT-licensed starter kit that turns Claude Code into your personal **AI Operating System (AIOS)**. Audience: anyone building automations — solopreneurs, small business operators, managers, creators, AI consultants. Pairs with a companion masterclass video.
+
+The kit personalizes itself to you via an `/onboard` interview, then gives you two recurring thinking skills (`/audit`, `/level-up`) to keep building leverage week over week.
+
+> **AIS-OS** stands for **AI Automation Society OS** — the way Nate designed this AIOS to be set up for members of his community, [AI Automation Society](https://www.skool.com/ai-automation-society). The kit is universal (it works for anyone), but the structure mirrors how AIS members run their own businesses on top of it.
+
+---
+
+## The litmus test
+
+> **"While you're not at your desk, your AIS-OS observes one real-world event and produces an output that's faster and more accurate than what you'd produce yourself."**
+
+Every design decision in this kit rolls up to that test. If a layer, skill, or template doesn't contribute to it, it doesn't ship.
+
+---
+
+## How you'll know it's working
+
+Three felt **success indicators** tell you the AIOS is actually changing how you work. Not KPIs — there's no objective metric. These are lived experiences that show up in your week.
+
+**1. Team-reaches-out:**
+
+> *"A teammate messages you with a question. You realize your AIOS would answer it better, faster, and with exact sources — even if you were awake and free. So you ask your AIOS too. That's the moment you stop being a bottleneck for your own knowledge."*
+
+**2. Context-switching reduction:**
+
+> *"You stop opening new tabs. You stop launching the desktop app. When something new lands, your first move is to ask the AIOS, not to open six things. The default surface for thought work shifts. Silent. Compounding."*
+
+**3. Knowledge-leaves-your-head:**
+
+> *"You stop trying to remember business facts. You don't rehearse what you decided last quarter or what your customer said in that meeting. You trust the retrieval. The AIOS holds the truth, you hold the questions."*
+
+**Personal foundation → company AI-readiness.** Once these indicators show up for one person, the same data architecture powers everything else. Custom dashboards on the data you already collect. Automations on top of the connections you already wired. Team rollout where everyone has theirs. *A company where every operator runs a personal AIOS is a company that's actually AI-ready.*
+
+The kit teaches personal AIOS first. Everything scales from there.
+
+---
+
+## Two frameworks
+
+The kit teaches two complementary frameworks. **Three Ms first, Four Cs second.** Without the brain rewire, the architecture is just a folder structure.
+
+### The Three Ms — operator brain (how you think)
+
+| M | One-liner |
+|---|---|
+| **Mindset** | Default Shift, Function Breakdown, Curiosity Rule. *To what extent can AI be leveraged here?* |
+| **Method** | Find Constraint → EAD (Eliminate, Automate, Delegate) → Map Process → Pick Autonomy Level → Tie to KPI. |
+| **Machine** | Lego Principle, Validation Chain, Bike Method, Intern Rule, Kill Switch. *Boring is beautiful. Workflows beat agents.* |
+
+Full breakdown in `references/3ms-framework.md`. The `/level-up` skill walks you through all three weekly.
+
+> *The Three Ms of AI™ is a trademark of Nate Herk. © 2026 Nate Herk.*
+
+### The Four Cs — architecture (what you build)
+
+| # | Layer | One-liner | "This layer is in place" test |
+|---|---|---|---|
+| 1 | **Context** | Knows your business | Fresh Claude session answers "what does this business do and who works here?" without browsing |
+| 2 | **Connections** | Reaches your stuff | "What's on my calendar tomorrow and what tasks are due?" → live data, no paste |
+| 3 | **Capabilities** | Knows how to do the work | A short phrase triggers a multi-step workflow that produces an artifact |
+| 4 | **Cadence** | Runs without being asked | Laptop closed. A brief lands in the inbox. A teammate messages it and gets a real answer |
+
+**Brand line:** Context. Connections. Capabilities. Cadence.
+
+> *The Four Cs of an AIOS™ is a trademark of Nate Herk. © 2026 Nate Herk.*
+
+Dependency graph: Context is non-skippable. Connections + Capabilities can build in parallel. Cadence is last — don't automate workflows that don't work manually.
+
+---
+
+## What ships — 3 skills
+
+The kit is intentionally lean. Skills here are ideation prompts and thinking tools, not heavy automations. You hack on top of the structure.
+
+| Skill | Type | When to run |
+|---|---|---|
+| `/onboard` | Setup wizard (one-time) | Day 1, immediately after clone. 7-question interview. Generates Day-1 file set + fills `CLAUDE.md`. |
+| `/audit` | Recurring thinking skill | Day 7, then weekly. Four-Cs gap report. Read-only. Watch the score climb. |
+| `/level-up` | Recurring thinking skill | Day 14, then weekly. Three Ms interview (Mindset → Method → Machine). One run = one shipped artifact. |
+
+`/audit` asks *"is the AIOS built right?"* (form). `/level-up` asks *"what business leverage am I missing?"* (function). They work in series — fix structure first, then capability planning becomes meaningful.
+
+---
+
+## Quick start
+
+1. **Clone the repo** to a working folder on your machine.
+2. **Open it in Claude Code** and run `/onboard`. Answer the 7 questions honestly. Voice samples must be pasted, not described. Takes ~15 minutes. Day-1 file set drops at the end.
+3. **Use it for a week.** Bring real questions. Make real decisions. Log them via `/decision` (or just append to `decisions/log.md`).
+4. **Day 7:** run `/audit`. Read the Four-Cs gap report. Pick one gap to close.
+5. **Day 14:** run `/level-up`. The Three Ms interview surfaces one automation worth building. Build it.
+6. **Week 3+:** weekly `/level-up` ritual. One shipped artifact per week.
+
+---
+
+## Repo layout
+
+```
+AIS-OS/
+├── README.md
+├── CLAUDE.md                        ← Your operating manual (filled by /onboard)
+├── EXPANSIONS.md                    ← What to add as you grow
+├── LICENSE
+├── .gitignore
+├── aios-intake.md                   ← Source-of-truth for /onboard. Edit + re-run any time.
+├── connections.md                   ← Registry of every system your AIOS can reach
+├── context/                         ← About you, your business (filled by /onboard)
+├── references/
+│   └── 3ms-framework.md             ← The operator brain
+├── decisions/
+│   └── log.md                       ← Append-only record of what was decided and why
+├── archives/                        ← Old stuff. Don't delete. Move here.
+└── .claude/
+    └── skills/
+        ├── onboard/SKILL.md
+        ├── audit/SKILL.md
+        └── level-up/SKILL.md
+```
+
+See `EXPANSIONS.md` for what to add as you grow (`projects/`, `templates/`, `scripts/`, `.claude/agents/`, sub-OS folders, etc.).
+
+---
+
+## License + attribution
+
+MIT License. © 2026 Nate Herk.
+
+The Three Ms of AI™ and The Four Cs of an AIOS™ are trademarks of Nate Herk. Both frameworks ship in this repo with attribution. Use freely; don't repackage as your own.
+
+The companion masterclass video walks you through the kit step by step. Link will land here once it ships.

aios-intake.md

@@ -0,0 +1,85 @@
+# AIS-OS Intake
+
+This is the source-of-truth file for your AIOS. Fill it in by typing, voice-pasting (Wispr Flow / OS dictation), or running `/onboard` for a guided conversation. Whichever mode, this file is what `/onboard` reads to scaffold your Day-1 setup.
+
+**Hard cap: 7 questions.** Each answerable in under 60 seconds. Don't overthink — you can edit and re-run `/onboard` any time.
+
+---
+
+## Q1 — Who are you, what do you sell, who do you sell it to?
+
+Identity, offer, ICP. One paragraph each is fine.
+
+```
+[Your answer here]
+```
+
+---
+
+## Q2 — Paste 1-2 things you've written recently. Don't edit them.
+
+An email, a LinkedIn post, a DM, a doc — anything that sounds like you when you're not trying. **Paste verbatim.** Do not type these mid-conversation with Claude — chat-shaped samples are worse than no samples (voice contamination).
+
+```
+[Sample 1 — paste raw]
+```
+
+```
+[Sample 2 — paste raw]
+```
+
+---
+
+## Q3 — What are your 2-3 biggest priorities for the next 90 days?
+
+Quarterly priorities. Not yearly aspirations. Things that, if not done by July, would make you say "I wasted Q2."
+
+```
+1. [Priority 1]
+2. [Priority 2]
+3. [Priority 3]
+```
+
+---
+
+## Q4 — Where does revenue actually land, and where is it tracked?
+
+Multiple answers OK. Stripe? Skool? GoHighLevel? QuickBooks? A spreadsheet?
+
+```
+[Your answer here]
+```
+
+---
+
+## Q5 — Where do you talk to customers, your team, and the outside world day-to-day?
+
+Email (which one — Gmail / Outlook)? Slack? Teams? DMs (Skool / Discord / iMessage)? Phone?
+
+```
+[Your answer here]
+```
+
+---
+
+## Q6 — Where do meeting recordings, notes, and important docs live?
+
+Granola? Otter? Fireflies? Google Drive? Notion? Dropbox? A folder on your desktop you keep meaning to organize?
+
+```
+[Your answer here]
+```
+
+---
+
+## Q7 — What's the one task that eats your week, and where do you currently track work?
+
+The single biggest time-suck or recurring drudgery. Plus where tasks/projects live (ClickUp / Asana / Linear / Notion / a notebook).
+
+```
+[Your answer here]
+```
+
+---
+
+When this file is filled, run `/onboard` (or re-run it) and the wizard will scaffold your Day-1 file set: `context/`, `references/voice.md`, populated `connections.md`, and a filled `CLAUDE.md`.

connections.md

@@ -0,0 +1,17 @@
+# Connections
+
+Registry of every system your AIOS can reach. Filled by `/onboard` from Q4-Q7 answers; expanded over time as you wire new tools. `/audit` checks this file for domain coverage and freshness.
+
+| # | Domain | Tool | Mechanism | Auth | Last checked |
+|---|---|---|---|---|---|
+| 1 | Revenue / Financials | _filled by /onboard_ | not yet connected | — | — |
+| 2 | Customer interactions | _filled by /onboard_ | not yet connected | — | — |
+| 3 | Calendar | _filled by /onboard_ | not yet connected | — | — |
+| 4 | Communication | _filled by /onboard_ | not yet connected | — | — |
+| 5 | Project / task tracking | _filled by /onboard_ | not yet connected | — | — |
+| 6 | Meeting intelligence | _filled by /onboard_ | not yet connected | — | — |
+| 7 | Knowledge / files | _filled by /onboard_ | not yet connected | — | — |
+
+**Mechanism options:** `mcp` (MCP server), `script` (Python/Bash hitting an API, in `scripts/`), `export` (CSV/JSON dump pipeline), `key+ref` (`.env` key + `references/{tool}-api.md` guide), `not yet connected`.
+
+When you wire a new tool, also save `references/{tool}-api.md` capturing endpoints, auth flow, and common queries — researched-once-saved-forever.

decisions/log.md

@@ -0,0 +1,21 @@
+# Decisions Log
+
+Append-only record of meaningful decisions and why they were made. `/level-up` Phase 2 (Method interview) writes scoped automation specs here. You can also append manually whenever you decide something worth remembering.
+
+**Format per entry:**
+
+```
+## YYYY-MM-DD — Short title
+
+**Decision:** what was decided.
+
+**Why:** the reasoning, constraints, and what would change your mind.
+
+**Alternatives considered:** what else was on the table.
+
+**Owner:** who's accountable.
+```
+
+Keep it terse. Future-you will thank present-you for capturing the *why*, not just the *what*.
+
+---

references/3ms-framework.md

@@ -0,0 +1,236 @@
+# The Three Ms of AI™ — Mindset, Method, Machine
+
+> *Adapted from The Three Ms of AI™. © 2026 Nate Herk. All rights reserved.*
+> *The Three Ms of AI™ is a trademark of Nate Herk.*
+
+> *"The best automation is the one you barely notice. Start by eliminating what doesn't need to exist, then automate what's left with the least amount of AI possible."*
+
+**Boring is Beautiful.**
+
+---
+
+## Why this is in your kit
+
+This framework is the operator brain you'll use every time you run `/level-up`. Three layers, each one builds on the last. Read it once, refer back as needed.
+
+Here's the thing most people get wrong: they think AI automation is about tools. It's not. Tools change every six months. The platform you're using today might not exist next year. What doesn't change is how you THINK about automation, how you DECIDE what to automate, and how you BUILD and OPERATE the thing once it's running. That's what The Three Ms of AI™ gives you. A way to think that works regardless of platform, model, or hype cycle.
+
+This framework is for everyone. Business owners hearing about AI for the first time. Engineers exploring automation. Consultants who need a methodology they can hand to a client. It scales.
+
+---
+
+## Layer 1 — MINDSET (How to Think)
+
+Before you touch a single tool, you need to rewire how you approach work. The way you think about tasks determines whether you'll spot automation opportunities or walk past them every day.
+
+### 1. The Default Shift
+
+The core habit: before doing any task the old way, ask "How could AI do this?"
+
+If the answer is "it can't do all of it," the follow-up: "How could AI assist with the first 30%?"
+
+It's never binary. The real question is always **"to what extent can AI be leveraged here?"** Maybe 80%. Maybe 10%. You don't know until you ask.
+
+**Real example.** Updating tracking links across 300+ YouTube video descriptions. The old way: open each video in YouTube Studio, find the link, replace it, save, next. Hours of mind-numbing work. The new way: describe the problem to Claude Code and walk to the kitchen for water. By the time you come back, it's researched the YouTube Data API, figured out quota limits, written a script, and laid out a plan. Approve, run, done. Now you have a reusable system.
+
+The Default Shift is like learning to type instead of writing by hand. Once it clicks, you physically cannot go back. Every manual task starts to itch.
+
+**One thing to internalize:** AI is better than you think, and improving faster than you think. Client needed infographic visuals; models couldn't deliver. Three months later, new model dropped. Shipped the work. *If AI can't do something today, try again next month. Seriously.*
+
+### 2. The Function Breakdown
+
+Your role is a set of functions. Your job description has about five bullet points. Each breaks into dozens of tiny tasks. **You don't automate your whole job. You automate one tiny piece. Then another. Then chain them.**
+
+Think "automate a YouTube video." Sounds impossible. Break it down: ideation, scripting, title generation, thumbnail generation, description writing, comment replies, timestamps, analytics. Each piece is its own automation. Build one, get it working, move on.
+
+One small task per day. Six months later, hundreds automated. Compounding is real.
+
+### 3. The Curiosity Rule
+
+Never accept AI output without asking why. Ask for three alternatives. Ask which one it thinks is best and why. Push back. Dig in.
+
+This is the antidote to "dark code" — automations or code you don't understand. **If you build something and you can't explain how it works, you've built a liability, not an asset.** When it breaks (and it will), you'll have no idea where to start.
+
+Treat AI as a mentor, not a vending machine. The vending machine gives you output. The mentor gives you understanding.
+
+### Expect the Dip
+
+Productivity dip at the start: ~20% less output for the first week or two. New workflows, new prompting cadence. That's normal. Within two weeks, baseline doubles. But you have to push through.
+
+**Fail fast, learn faster.** Get to your first 10 mistakes as safely and quickly as possible. That's where the real learning lives, not in your first 10 successes.
+
+---
+
+## Layer 2 — METHOD (How to Decide)
+
+Mindset tells you how to think. Method tells you what to do with that thinking. The operational core — turning "I should probably automate something" into "here's exactly what I'm building and why."
+
+### 1. Find the Constraint
+
+Two power questions surface everything:
+
+**Q1:** *"If 500 new clients showed up tomorrow, what would break first?"* — finds bottlenecks (clogs in the pipe). Onboarding? Invoicing? Support response times?
+
+**Q2:** *"What would give you 500 more clients tomorrow?"* — finds growth opportunities (untapped pipe). Content you're not creating? Outreach you're not doing? Leads you're not following up on?
+
+One finds what's broken. The other finds what could scale. Start with the constraint.
+
+### 2. EAD: Eliminate, Automate, Delegate
+
+For every process, run EAD — in this order.
+
+**Eliminate first.** *"What happens if we just stop doing this?"* You'd be surprised how many processes exist because they always have. Reports nobody reads. Approval steps that add no value. **If nobody would notice it disappeared, kill it. Don't automate waste.**
+
+**Automate second.** Apply the **60/30/10 Golden Rule:**
+- ~60% fully automated (no human touch)
+- ~30% AI-assisted (AI does the work, human reviews before it goes out)
+- ~10% stays manual (too nuanced, too risky, or too rare)
+
+This ratio normalizes expectations. **Full automation is rarely the goal.** If someone promises 100% on anything meaningful, they're selling you something.
+
+**Delegate third.** If a process can't hit 60/30/10 — too complex, too variable, too judgment-dependent — delegate to a person. Not everything should be automated.
+
+The key: nothing stays as-is. Every process gets killed, automated, or handed off.
+
+### 3. Map the Process
+
+Before you touch any tool, write every step on paper. Five elements per process:
+
+- **Trigger** — what kicks it off (form submission, calendar event, email, time of day)
+- **Data Sources** — where information comes from (CRM, spreadsheet, inbox)
+- **Data Transformations** — how data changes shape (reformatting, filtering, combining)
+- **Decision Points** — where it branches (if qualified, do X; if not, do Y)
+- **Destination** — where output goes (back to CRM, email, Slack, document)
+
+**Rule:** *if you can't explain it to a person, you can't explain it to an AI.* The map forces clarity. Skip this step and you'll build something that sort of works but breaks in weird ways.
+
+### 4. The Autonomy Spectrum
+
+Each step gets an autonomy level:
+
+| Level | Name | What Happens |
+|-------|------|-------------|
+| L0 | Manual | No AI. Human does it. |
+| L1 | Suggested | AI suggests, human decides every step. |
+| L2 | Drafted | AI drafts, human reviews and edits. |
+| L3 | Supervised | Rules set, AI runs, human validates. |
+| L4 | Autonomous | AI handles end-to-end. |
+
+**Governing principle: default to the LOWEST level that works.**
+
+Most people get this backwards. They hear "AI automation" and jump to L4. That's where things go wrong. Boring is Beautiful. Deterministic beats non-deterministic. **Workflows beat agents.** If a decision doesn't HAVE to be made by AI, don't let AI make it.
+
+Push autonomy up only when you've proven the lower level works.
+
+### 5. Tie It to a KPI
+
+If your automation doesn't move a number, why are you building it?
+
+**The Three Buckets** (every business metric falls into one):
+
+1. **Get more customers** — content, prospecting, outreach, ads, lead gen
+2. **Make each customer worth more** — premium services at lower cost, upselling, retention
+3. **Cut costs** — eliminate drudgery, reduce errors, boost productivity
+
+**Specific KPIs** are tied to the individual automation: response time, error rate, tickets per month, conversion rate, time-to-completion.
+
+If your automation doesn't improve a metric in one of the three buckets, stop. *"Because it's cool"* isn't a business case.
+
+---
+
+## Layer 3 — MACHINE (How to Build and Operate)
+
+You've got the thinking (Mindset) and the decisions (Method). Now you build and run the thing. Two halves: BUILD and OPERATE.
+
+### BUILD
+
+#### 1. The Lego Principle
+
+Smallest possible steps. One input, one output per block. Output of block 1 becomes input of block 2.
+
+Start with **zero-AI steps first**. Get the deterministic pieces working — data fetching, formatting, routing. Then layer in AI where actually needed.
+
+This makes the project less overwhelming and lets you validate as you go. If block 3 produces garbage, you know exactly where to look. **Modularity is freedom.**
+
+#### 2. The Assembly Line
+
+Each AI step does one specialized job. Like workers on an assembly line.
+
+**Don't build a generalist.** One model call for copywriting. Another for reasoning. Another for classification. Keep them separate. Easier to debug, swap models, adjust prompts.
+
+#### 3. The Validation Chain
+
+Validate each step's output before chaining. **Do NOT build the whole pipeline and test end-to-end.** That's a recipe for "it doesn't work and I have no idea why."
+
+Build step 1. Run it. Confirm output. Build step 2. Run with step 1's actual output. Confirm. Chain. Add step 3. This is how POCs actually work.
+
+#### 4. The Iteration Mindset
+
+There's no finished product — especially with AI. Deterministic scripts CAN be done (a CSV reformatter, sure). AI steps are always evolving. New models. New capabilities. The prompt that was optimal six months ago is verbose and expensive today.
+
+Ship the POC. Get real-usage feedback. Expand. Iterate. **Perfectionism is the enemy of deployment.**
+
+### OPERATE
+
+#### 5. The Bike Method
+
+Roll out in phases, like teaching a kid to ride.
+
+- **Phase 1 — Training wheels.** Run manually. Watch everything. Correct mistakes by hand.
+- **Phase 2 — Guided.** Automation runs but you review every output. It drafts, doesn't send.
+- **Phase 3 — Watched.** Runs autonomously. You monitor. Alerts for anomalies. Periodic batch review.
+- **Phase 4 — Hands-off.** Helmet on, go ride.
+
+Even at 90% confidence, roll out 10% of volume first. Watch a week. Add 20% more. Like drug trials — not full dose to everyone day one.
+
+Use confidence thresholds: high → auto-send, medium → draft queue, low → escalate to human. Tighten or loosen as data accumulates.
+
+#### 6. The Intern Rule
+
+Treat AI like a brand-new hire on day one.
+
+- **Own identity.** Its own email, accounts, credentials. Never yours.
+- **Read-only by default.** View-only until you've proven write access is needed.
+- **Never impersonates you.** Signs off as "[your name]'s AI assistant."
+- **No personal credentials.** No passwords, bank info, personal logins.
+- **Full audit trail.** Visibility into everything it did, spent, created, deleted.
+- **Scoped permissions.** API keys with minimal scope. Exactly what's needed, nothing more.
+
+*"You wouldn't trust someone you just met with your bank account."*
+
+#### 7. The Kill Switch
+
+Monitor what's running. If an automation consistently needs patches, produces low-quality output, or costs more to maintain than it saves — **tear it down.** Dismantle. Delete.
+
+Don't fall into the sunk cost trap. *"But I spent three weeks building this"* is not a reason to keep something running that doesn't work. **Good operators know when to build AND when to destroy.** The kill switch is just as important as the launch button.
+
+---
+
+## Governing Principles
+
+Three principles that sit above everything else. When in doubt, return to these.
+
+1. **Boring is beautiful.** Predictable beats clever. Default to the simplest, most deterministic approach that gets the job done.
+2. **Deterministic steps can be finished. AI steps are always evolving.** Set expectations — yours and your client's — accordingly. A rule-based filter is done. An AI classifier needs tuning forever.
+3. **Fail fast, learn faster.** Get to your first 10 mistakes safely and quickly. Real learning lives there, not in planning, not in your first 10 successes.
+
+---
+
+## Branch Frameworks (future hooks)
+
+The 3Ms is the mothership. Specific topics go deeper in dedicated frameworks. Most aren't built into this kit yet. They'll grow into `references/` over time:
+
+- **The Data Retrieval Hierarchy** — Filters, SQL, Full Context, RAG: when to use which
+- **The Integration Ladder** — API, CLI, Browser Automation, Scraping: hierarchy of reliability
+- **The Error Handling Playbook** — What to do when things break (and they will)
+- **The Model Selection Guide** — How to pick the right model for the right job
+- **The Context Engineering Framework** — How to feed AI the right information at the right time
+- **The Discovery Playbook** — How to run discovery with a client or team before building
+- **The Security and Permissions Playbook** — Access control, audit trails, risk management
+
+Each plugs into the 3Ms at specific points. Start here, branch out as you need depth.
+
+---
+
+> *Adapted from The Three Ms of AI™. © 2026 Nate Herk. All rights reserved.*
+> *Full breakdown with diagrams and examples: [insert link to YouTube companion video / public-facing page when published].*