amm-founding-circle

A pre-publish checkpoint for a client blog/content draft — grammar and mechanics, brand voice against a per-client profile, and factual claims checked against the client's own site — that ends in one verdict a VA or owner can act on without reading the whole report: SHIP / SHIP WITH FIXES / HOLD. Use when a user asks to "QA this draft," "check this post before it goes live," "run content QA for [client]," "does this sound like [client]," or wants a pre-publish gate so nothing ships with an embarrassing factual miss, an off-voice line, or a typo in the headline.

A local tabbed dashboard showing all six AMM Founding Circle tools' reports in one place (Connection Sentinel, Bug Hunter, Content QA, Lead Grader, Penny Dashboard, Outbound Engine), each with a Refresh button that re-runs that tool's own command and pulls its latest report back in. Use when a member wants one place to check every tool at a glance instead of hunting down six separate report files, when presenting results live to a client or teammate, or when a specific tool's tab needs re-running after config changes.

Find the ghost tokens. Audit Claude Code or Codex setup, see where context goes, fix it. Use when context feels tight.

Compute per-client cost/billing profitability (Penny Dashboard) and generate an internal owner view plus a locked-down, client-safe HTML page per client. Use when an agency owner asks to run their Penny Dashboard, check which clients are unprofitable, see margin by client, or generate a client-safe cost/spend page to send a client.

Sweep every client site and Google Ads account for real, client-visible errors — broken links, disapproved ads, dead tracking tags, broken redirect chains. Use when the user says "run my bug hunt", "sweep my clients", "check my client sites for errors", "audit my Google Ads accounts for problems", or wants to know what's broken before a client finds it. Read-only — never edits, pauses, or posts anything.

An always-on checker that pings every API/MCP connection your automations depend on and alerts you the moment one silently dies -- email + macOS notification, plus a tiny local status board. Use when you want to know instantly if a connection (Search Atlas MCP, Google Ads, GA4, Meta, CallRail, Smartlead, ClickUp, Slack, or anything else) has gone down, when a scheduled automation "seems quiet" and you need ground truth instead of guessing, or when you're setting up your first always-on agent and want a watch on it from day one.

Grade inbound leads (CallRail calls today; LSA/form-fills/outbound leads later) against a per-client rubric — 🔥 Hot / ✅ Qualified / ⚠️ Weak / 🗑️ Junk with a one-line reason and the key quote. Use when the user says "grade my calls/leads", "run my lead grader", "how good were today's calls", or "build a scoring rubric for [client]".

Run a prospecting pipeline that finds website visitors who look like real buyers, scores them against your ICP, drafts a personalized cold email, and queues it for your approval — before anything ever touches a real send. Packages the proven website-visitor-to-Smartlead stack an AMM member built that replaced a ~$700/mo Apollo + Hunter.io spend. Use when you want to run your outbound pipeline, review pending outreach drafts, build your Ideal Customer Profile, or generate a weekly pipeline report. This build is dry-run only — it never sends a real email or calls a real Visual Visitor/Smartlead API.

Hand a multi-day job to your agent and walk away — for real. You set the rails once (what it can touch, what it can never touch, how long it runs, what pulls it back to you), then it works for days on its own and comes back only when something genuinely needs a human. It saves its place so a crash or a closed laptop doesn't cost the work, and it leaves a log that proves it stayed inside the rails. Use when you want days of throughput without babysitting — a batch audit of every client site, a multi-site refresh, a long overnight-into-the-next-day job — when you're afraid to leave an agent running unwatched because you can't be sure what it'll touch, or when you're on Level 9 and want the "set the rails and leave" step done right.

Stop trusting one model's answer on work that's expensive to get wrong. Send the same task to two or three models, have them independently judge it against a rubric you wrote, surface where they disagree, and take the version they converge on — majority decides, or you break the tie. One model can be confidently, fluently wrong; a council catches that before it reaches a client. Use for high-stakes work where a mistake costs real money — a repricing memo, a positioning call, a strategy or audit that goes to a client — when you've been burned by a confident answer that turned out wrong, or when you're on Level 7 and want the "route it to a council, not one opinion" step done right.

Give your client a live, branded view of the work your agents are doing — without giving them your tools, your logins, or a plugin bolted into their site. Each agent run writes a small results file; a self-contained branded HTML dashboard is regenerated from it and hosted as a static page the client just opens. Read-only by construction. Use when a client wants to "see what you're doing," when you're tired of hand-building status decks, when you want to extend your Command Center with a client-visible view, or when you've been asked for a client dashboard and your instinct was a WordPress plugin (don't — read the cautionary tale below).

Run an agency's worth of work from your phone. You send one line of intent — the outcome you want, not the keystrokes — from anywhere, an always-on machine picks it up and puts your agents to work on the rails you built, and it messages back one briefing you read in a minute. The phone is a trigger surface, never a coding surface: you command, you don't operate. Tool-agnostic — works over any messaging channel your always-on machine can watch. Use when you're away from the desk and a client job can't wait, when you want to stop being the bottleneck that has to be at the keyboard to kick off every run, when your agents are good enough to run unwatched and you just need to point them, or when you're on Level 10 and want the "command the fleet from your phone" step done right.

Split one big job across several agents running at once — and write each one a tight, self-contained brief so it works its slice instead of burning its effort rediscovering the whole job. This is context engineering made practical: the agent only knows what you tell it, so a good brief is the difference between "five agents at once" being leverage and being five shallow drafts. Teaches split → brief → gate, and how to keep your main conversation lean by delegating the messy work. Use when a job is too big for one pass (a multi-section audit, a batch of pages, a repo-wide cleanup), when parallel agents keep coming back with thin or overlapping work, when your main chat gets clogged with raw output, or when you're on Level 4 and want the split/brief step done right.

Do ONE real client task through the agent, by voice, in about an hour — and prove it shipped. The Level-1 on-ramp for anyone who feels behind or is starting over: it shrinks "learn this whole new way of working" down to a single job you already have on your plate today. Walks you through the first fifteen minutes, gives you the exact words to say out loud, saves every step so nothing can be lost, and ends with a checklist that proves the work is real. Use when you're overwhelmed and don't know where to start, when you're re-joining after time away and everything feels like a fire hose, when you've watched the demos but haven't done a real task yourself yet, or when you want your first genuine win instead of another practice prompt.

Package the rules, skills, and brand you built in Levels 1–3 into one repo a teammate — or your own second machine — clones and runs a single install command against, so everyone runs the exact same agent setup instead of reinventing it. Turns "here's my setup, good luck" into "clone this, run ./install.sh, you're me." Use when you want to onboard a teammate onto your agent stack, when your own setup won't follow you between machines (your CLAUDE.md / skills / brand kit live on one laptop and not the other), when you keep re-sending config over Slack, or when you're on Level 4 and the "share the foundation with your team" step has nothing runnable behind it.

Your autonomous morning chief-of-staff for the agency. Sweeps YOUR own connected sources (inbox, tasks, calendar, CRM/GBP), correlates related threads ACROSS sources so it only surfaces what you genuinely still owe, triages by urgency and importance, drafts replies in your voice, and leaves a one-page brief you read over coffee. Read-only by default. Use when you want to wake up to a decision-ready day instead of an hour of digging, or when asked to "run my morning brief" or "what's on my plate today".

The mental model behind an always-on system — a tool is something you invoke, an agent is something that runs, and the gap between them is a trigger. Teaches the Sense → Correlate → Judge → Act → Report loop every agent shares, the two ways to deploy it (a job scheduled on your machine vs. a hosted routine that runs 24/7 even with the laptop closed), the real gotchas that quietly break both, and the Observe → Propose → Act trust ladder that keeps it from doing damage while you sleep. Use when you keep hand-running the same job, when you want to understand what "agentic" actually means before you build, when a "set it and forget it" agent isn't firing on its own, or when you're deciding whether a job should run on your machine or in the cloud.

Map what your agent can actually DO across your stack today versus what's gapped, and learn the two workarounds that bridge a missing action. Use when you've built a good agent but keep hitting a wall where it can read a tool but can't act in it — "everything is 80% and I can't get the last 20% agentic" — usually a write-scope your ad platform, CRM, or form provider doesn't expose to the agent. Teaches you to inventory YOUR OWN stack's coverage (not a fixed platform list), find the exact gapped actions, and pick the right bridge for each one.

Put a watch on your always-on agent so silence can never masquerade as success. Checks that the connections an unattended run depends on — MCP logins, the API/CLI it calls, the session itself — are actually alive, and pings you the moment one drops instead of letting you discover it hours later. Ships a runnable checker, a tiny local status page, and a quiet-until-it-matters watch loop with bounded escalation. Use when you've put an agent on a schedule and need to trust that it's still running, when a login silently expired mid-run, when a job "finished" but nothing actually happened, or when you want to be told the instant a connection breaks.

Turn a fuzzy repeatable job into a deterministic, versioned skill so the output is the same quality every single run — not "good when I'm watching, random when I'm not." One skill per repeatable process, versioned in a shared repo, with a judge-skill that scores each run against a rubric and blocks a bad result from going out. Use when the same task comes out great one day and sloppy the next, when you're about to hand a repeatable job to an unattended run and need the output to hold up, when a teammate can't reproduce your result, or when you keep re-typing the same long prompt and getting a different answer each time.

Keep a long or overnight agent run's memory in files on disk, not in the chat window, so a crash, a restart, a closed laptop, or a hand-off to another machine can't kill the work. The run resumes from three files (contract / progress / state). Use when a job runs for hours or overnight, when a dead laptop or a crash has already cost you a session and you never want that again, when you want to start something on one machine and finish it on another, or when work spans more than one sitting and you keep losing your place.

Stop babysitting a long job. Tell your agent the finish line — "keep working until X" — and it works toward it on its own instead of stopping every few minutes to ask you what to do next. It pings your computer when something meaningful changes and again when it's done, so you can walk away and get pulled back only when it matters. Use when you're stuck hand-nudging a long run ("keep going", "continue", "next") to keep it alive, when you want to work until a real condition is true (all tests pass, the draft is finished, the file is clean) and be notified instead of watching, or when you say "work until X and tell me when it changes".

Give an always-on agent enough model capacity that a long overnight run never dies halfway from a hidden limit — the ToS-clean way. Explains the recommended budgeted API-key lane (a spending cap plus an automatic fallback to a second provider), and the wrapper-with-fallback pattern (provider-first, direct-CLI fallback), 429 cooldown, and token refresh in plain terms. Use when a scheduled or overnight run keeps stopping on a rate limit or quota wall, when you're on a subscription plan and worried about capacity, when you're tempted to "stack accounts" to get more headroom, or when you want to know the one capacity trick that gets accounts banned so you never do it by accident.

Get your agent off your laptop. Installs an auto-save hook so an overnight run never loses work, plus a scheduled unattended runner (launchd on Mac / Task Scheduler on Windows / cron on Linux) that fires one of your own recurring jobs on a schedule and leaves a finished morning artifact. Use when you want an agent to run while your machine sleeps, when you're tired of hand-running ./run.sh and babysitting a terminal, when a crash or dead laptop keeps killing a session, or when you want to "set it and forget it" for a job you do every day.

Routing runbook for engineering tasks across the agent stack (ao spawn, GSD, OMC, /goal, /loop, /schedule, inline, codex, gemini, Claude Flow swarm). Use when uncertain which execution mode to choose, before any non-trivial action. Outputs a composed pipeline, not just one mode. Hard rules and gates live in global CLAUDE.md; this skill is the HOW for routing.

Show accurate Claude/Codex account usage from provider quota APIs where exposed and local session ledgers otherwise.

Verify web pages with real browser evidence: screenshots, console checks, form interactions, and responsive views. Use when a task affects anything a user can see or click.

Use installed AI CLIs for second opinions, latest-docs checks, and long-context review. Avoid raw provider API calls unless a project explicitly requires API integration.

ClickUp v3 API conventions, channel/DM creation rules, thread reply endpoints, and the company-wide 🧞 emoji prefix requirement for any Claude-authored ClickUp message. Use when sending ClickUp messages, creating channels, replying to threads, or scripting against the ClickUp API.

Generate or refresh a codebase structural map for the current repo. Use proactively when entering a repo that lacks .claude/codebase-map.md, or when the user asks to map/index a codebase.

Reflect on recent engineering work across repos, reconstruct what happened, extract reusable engineering lessons, generate research questions, and produce a morning HTML report. Use after project execution, coding sessions, long agent runs, failed loops, multi-repo work, or before starting the next day with a clearer backlog of questions and compounding insights.

Self-contained HTML report archetypes. Pick the right shape for the document — Folio (book), Stage (slides), Atlas (dashboard), Field (editorial long-read), Ledger (comparison matrix), Timeline (chronological story). Single-file, date-stamped outputs, no external deps, light-mode by default.

Bridge GSD milestone patterns/lessons into the instinct pipeline as candidates

Cluster related instincts by trigger family and lexical similarity, identify skill-creation candidates

Score existing instincts, execute status transitions, prune stale candidates, write scorecard

Extract instincts from the current session — corrections, confirmations, and tool-usage patterns

Promote proven project instincts to global scope with lineage tracking

Convert a proven instinct cluster into a GSD-compatible skill definition

Run a bounded overnight AOSwarm-style analysis across recently active repos, using isolated workers to inspect architecture, tests, tooling, performance, safety, and agent-readiness, then synthesize a self-contained morning HTML report. Use for unattended nightly work blocks, architecture review swarms, cross-repo improvement mining, and robust fallback execution across Claude, Codex, and Gemini.

Protect agent sessions from malicious or accidental instructions embedded in fetched web pages, documents, transcripts, issue text, screenshots, or logs.