# Build your own AI agent stack **The CV Method · The Playbook · v1 · Aug 2026** *by Corina · @the_cv_method · hello.thecvmethod.com · current as of Aug 2026 — the AI space moves fast, so double-check tool names* A crew of small, single-job AI agents that quietly run your operations — brief you each morning, prep your meetings, build and ship your client work, run your content — with a human still approving every real move. This is the exact way I build mine. ## What you’re building Forget the one do-everything mega-bot. The trick is the opposite: **many narrow agents**, each with a single clear job, tight guardrails, and a human who ships. Small agents are easier to **trust, test, and fix** — and together they add up to a system that runs the business. You don’t launch the whole stack at once; you grow it one reliable agent at a time. ## Rule zero One job per agent — and a human still ships. It proposes, you approve. A narrow job is testable and safe; the human gate is the single thing that stops an agent from doing the wrong thing, confidently, at scale. ## Step 1 · Map the jobs *Start · your bottleneck* ### 01 · List the repeatable tasks bleeding your time The morning brief, the follow-ups you forget, the deploy, the content draft, the monthly report. Every task that **repeats** and has a clear **“done”** is a candidate for its own agent. Write them down, then pick the one costing you the most time this week — that’s agent #1. If you can’t say the job in one sentence, it’s too big — split it into two agents. ## Step 2 · Pick your stack Boring and bulletproof beats shiny. Here’s what I actually use — and the general equivalent so you can copy the shape without locking in. | Piece | What it does | I use | Swap for | |---|---|---|---| | Agent runtime | where the agents actually run & use tools | Claude Code or the Claude desktop app | any capable AI agent runtime | | A home + memory | one place agents read your world | an Obsidian vault + a CLAUDE.md system doc | any notes app + a “system” doc | | Where work ships | the apps/services agents act on | Cloudflare Workers / Pages | any serverless, or the tools you already pay for | | A registry | a list of what each agent does & when it fires | a small agents.js + a table | a spreadsheet or a single doc | | A schedule | runs the daily agents on their own | scheduled tasks (weekday routines) | any scheduler / cron | ## Step 3 · Give each agent its context *Memory · feed it your world* ### 03 · A home folder + a short “system” doc An agent is only as good as what it knows. Give it a folder and a short doc (mine is a **CLAUDE.md**) that spells out your world: what the project is, the stack, the commands, and the **always / never** rules. Feed it the real context **once** so it stops guessing on every run. Write the never-rules down explicitly: “never deploy without a security pass,” “never send an email — only draft.” The doc **is** the guardrail. ## Step 4 · Write the agent brief *The job · one page* ### 04 · Job, inputs, “done,” and guardrails For each agent write a tiny brief: its **one job**, the **inputs** it gets, the **output / definition of done**, and its **guardrails**. This is the whole difference between “vibes” and an agent you can rely on. Keep it short and specific — a paragraph, not a manifesto. Add a test: two example inputs and the right answers. That’s an “eval” in plain terms — you can’t trust what you never checked. ## Step 5 · Add the safety gate Rule zero, made real ### 05 · Nothing ships without a check + your yes Put a gate between “the agent did the work” and “it goes live”: a security / QA pass that returns **PASS or BLOCK** and **fails closed** (if in doubt, it blocks). The agent proposes; a human approves. This one habit is what lets you trust the rest of the stack. Make the gate boring and automatic — the same checklist every build has to clear, no exceptions, no “just this once.” ## Step 6 · Schedule it + keep a registry *Scale · grow the crew* ### 06 · Daily agents run themselves; the rest on demand Put the everyday agents (the brief, the end-of-day capture) on a **schedule** so they just happen; invoke the others when you need them. Keep a simple **registry** of what each agent does and when it fires, and review the outputs — tune the briefs as you learn. Start with **one** agent, make it reliable, then add the next. A stack is grown, not launched. One trustworthy agent beats ten half-built ones. ## The setup · copy these A · your system doc — the context every agent reads (a CLAUDE.md) ``` # — operating doc ## What this is ## The stack ## Always - propose, then wait for my approval before anything ships / sends / posts - keep client work anonymized (category labels, never real names) - write back what changed when you finish ## Never - deploy without a PASS from the security gate - send an email or post on your own — draft only - invent a number or a source ## The agents ``` *B · the agent brief — one per agent* ``` # Agent: Job: Trigger: "" Inputs: Steps: 1. 2. Done = Guardrails: - never - always a human approves before it ships Test: given , it should ``` C · the pre-ship security gate — the checklist it must clear ``` Before anything goes live, run the gate → return PASS or BLOCK (fail closed): [ ] Secrets / keys are server-side — never in code or prompts [ ] Access is scoped to only what this agent needs [ ] No private or client data would ship or leak [ ] Inputs are validated; errors fail safe [ ] A human has approved the go-live BLOCK if any box is unchecked. If in doubt, BLOCK. ``` D · spin up your first agent (paste this to scaffold it) ``` Help me stand up one AI agent, safely. The job I want to hand off first: . Give me: 1. a one-paragraph agent brief (job, inputs, "done", guardrails) 2. the always / never rules to add to my system doc 3. two test cases with the right answers 4. where a human should approve before anything ships Keep it narrow — one job — and assume it proposes, I approve. ``` ## Where to build this **Get the building blocks: github.com/anthropics/skills** — the **skill-creator** (it scaffolds an agent for you), a skill **template**, and the Agent Skills spec. In Claude Code: **/plugin marketplace add anthropics/skills**. **Run them:** each agent is a skill in your **.claude/skills/** folder, run by Claude Code — put the daily ones on a schedule so they fire on their own. On Claude.ai, you add them under **Customize → Skills**. **Don’t pull, build:** unlike off-the-shelf skills, your stack is **yours** — narrow jobs specific to your business. Use the scaffold prompt above (D), or the skill-creator, to stand up the first one. Docs: support.claude.com → “creating custom skills” · the open standard: agentskills.io ## Keep it honest & safe - **You approve** before anything ships - **No invented** metrics - Real work stays **anonymized** - **Responsible** data practices - Keep **secrets out** of prompts & anything you publish ## The starter checklist - One **job** written down for agent #1 - A **home folder** + a system doc (your world, always/never rules) - A **brief**: job · inputs · done · guardrails - A **test case** or two (your “eval”) - A **security / QA gate** that fails closed - The **daily** agents on a schedule - A **registry** of what each agent does - A **human approves** every live / irreversible action ### Want this built for you instead? I install the whole crew — briefs, guardrails, the security gate, and the schedule — wired into the tools you already use, and hand it over documented. That’s the CV Method. Start at **hello.thecvmethod.com**.