CHRISTINE Hire Your AI Agents Like You'd Hire People
Agent Architect runs any agent idea through a real hiring pipeline — one duty, a one-page Build Spec, bounded sources, and a graduation standard written before the first run — so your automation ships scoped, fails loud instead of silent, and earns its autonomy.
← Back to the Skills LibraryInstalled in under a minute. No tech skills required.
You don't need to know how to code, and you don't need to set anything up. There are two blocks below. If you can copy and paste, you can install this.
Paste the instruction
Copy the first block and paste it into a brand-new Claude conversation. Don't hit send yet — it's the note that tells Claude what to do.
Paste the skill underneath, then send
Copy the full skill block and paste it right below the instruction. Send it. Claude builds the skill, personalizes it to your business, and confirms when it's ready.
Install the skill below for me. Keep the skill text exactly as written, then personalize its defaults from what you already know about me — my business, my voice, my priorities, and the places I keep my notes and files. Confirm when it's installed and show me exactly how to run it.
---
name: agent-architect
description: Design, scope, deploy, and graduate AI agents and automated routines using a hiring standard that puts a quality gate at every stage. Use this skill whenever you say "design an agent," "agent architect," "run agent architect," "hire an agent," "spec this agent," "I want an agent that...," "automate this role," or want to turn a recurring duty into a scoped, deployed, trustworthy automated routine. Also trigger when you have an agent idea that feels too big, an automation that silently failed, or a roster of agent ideas with nothing actually running. This is the bridge between "I want AI doing this for me" and a deployed agent that earned its autonomy through a graduation process.
---
# Agent Architect
Hiring an agent is hiring. Treat it with the same seriousness a good hire gets, and it pays you back the same way. This skill runs any agent idea through a hiring pipeline with a quality gate at each stage, so the agent ships scoped and earns its autonomy over time.
## The Big Idea
Most agent projects die one of two deaths: scoped so big they never ship, or shipped so loose they fail silently until someone notices weeks later. The fix is a hiring pipeline with a quality gate at each end. An agent earns its job through a Build Spec, earns trust through an On-Ramp, and earns autonomy through graduation. Nothing skips a stage.
**The pipeline:** Roster → Scoping Standard → Build Spec → Deploy → On-Ramp → Graduation → Ownership Flip.
## Stage 1: The Roster (hire for the gap)
Keep one canonical roster of every agent: running, designed, and imagined. Each row carries a name, a status (Concept → Designed → Building → On-Ramp → Active → Paused), and the business gap it closes.
The hiring trigger is a named leak or a named gap, never a cool demo. "Money walks out of the pipeline because follow-up lives in my memory" hires an agent. "It would be neat if AI did X" does not. If you cannot name what the agent's absence costs, you are not ready to hire it yet.
## Stage 2: The Scoping Standard (seven rules, all of them)
Every agent gets scoped against these rules before any building happens:
1. **One duty.** Version 1 does exactly one job. Future duties get listed under "v2 and Beyond" and wait until the first duty graduates. An agent with three duties is three agents wearing a coat.
2. **Scheduled, never continuous.** The agent runs on a clock (daily at 5:15 AM, weekly Mondays), does its job, and stops. Always-on agents are debugging nightmares and cost leaks.
3. **Cheapest passing model.** Start with the cheapest model that passes review for the work type. Drop a tier only when review stays clean. Frontier models design the agent, cheaper models run it forever.
4. **Bounded sources.** The agent reads from an explicit, finite list of sources and nothing else. Name every database, API, and document. Unbounded reading is unbounded risk.
5. **Memory loop.** Every run starts by reading the standing memory entries (corrections, rules, patterns from past runs) and ends by writing one observation. Agents that cannot remember corrections repeat them forever.
6. **Failure protocol: loud beats silent.** A blocked run writes a blocker report naming the source, the error, and the timestamp, where you will see it the next morning. One retry with backoff, then stop. The cautionary tale: an agent that died of an expired auth token and nobody knew for weeks.
7. **Graduation criteria written before deployment.** Define what "trustworthy" means in observable terms before the first run, so trust is earned against a written standard you set down first.
## Stage 3: The Build Spec
One page, written before any code. Sections, in order:
- **Role.** The job in two sentences, including what stops leaking when this works.
- **Single Duty (v1).** The one job as a numbered run order, ending with what the agent does NOT do ("Stop. Nothing sends.").
- **Trigger.** The schedule, in your timezone.
- **Reads From.** The bounded source list.
- **Writes To.** Every destination, including the memory entry.
- **Handoff.** What you own. If output reaches the outside world (sends, publishes, charges), you own that step until graduation says otherwise. Drafts stage for review, the agent never touches the send button in v1.
- **Model and Home.** The model tier and where the agent physically runs (a cloud automation platform, a scheduled task on your own machine, and so on), with the honest constraints of that home stated (a laptop-bound routine needs the laptop open).
- **Failure Protocol.** Rule 6 made specific to this agent's sources.
- **Prerequisites Before Deployment.** The hard blockers, named. If a prerequisite is missing, the agent can still deploy in fail-loud mode: every run reports the missing prerequisite until it exists. A loud gate beats a delayed build.
- **On-Ramp Plan.** See Stage 4.
- **Graduation Criteria.** See Stage 5.
- **v2 and Beyond.** Everything you resisted putting in v1, parked.
## Stage 4: Deploy + On-Ramp (the quality gate between built and trusted)
Deploy on your green light. Then run a structured testing window (default 7 days for daily routines, 3 to 4 runs for weekly ones):
- The agent runs on its real schedule against real data.
- Each run gets verified by you against reality and logged clean, intervened, or wrong.
- Every output carries an On-Ramp label so nobody treats unverified output as gospel.
- The agent registers in a routine registry you keep (name, layer, schedule, status, last run) the day it deploys.
A failed On-Ramp gets a root-cause diagnosis, a fix, and a fresh clock. Only extend trust to an agent that has earned it on schedule.
## Stage 5: Graduation + Ownership Flip
Graduation criteria follow the pattern: **N clean runs, zero manual intervention, and outputs that pass review without revision twice in a row.** On graduation:
1. The registry row flips to Active.
2. The ownership flip completes: the duty's owner of record changes from you to the agent, and your job becomes reviewing the agent's output while it does the work.
3. The next duty (from v2 and Beyond) becomes eligible for its own pipeline run.
The ownership flip is the whole point. An agent that runs but never takes ownership just added a supervision job.
## Worked Example 1: A Follow-Up Agent
The gap: roughly $250K of named pipeline value sitting stale because follow-up lived in your memory. The spec: one duty (a daily weekday sweep of your CRM for due follow-up touches against a written cadence standard, drafts staged for morning review, nothing sends). Bounded sources: the CRM, the cadence standard, the voice guide, the memory entries. It deployed honestly gated: a live probe proved the CRM's lifecycle stages did not exist yet, so the agent deployed in fail-loud mode, writing a blocker report naming the missing stages every morning until a short setup unblocked real sweeps. The dry sweep that proved the gate also surfaced the stale pipeline, which became its own revival campaign. The gate was a finding, never a failure.
## Worked Example 2: A Library-Integrity Agent
The gap: a large skill library with no integrity check, where "built" claims had already been caught false twice. The spec: one duty (a weekly sweep verifying every index row against the real file on disk, recommendations only, nothing merged or deleted). First supervised sweep: every artifact verified, a handful of hygiene findings, and one genuine conflict surfaced to you for a decision. Registered at On-Ramp with a short window. The lesson it proves: read-only agents with loud findings build trust fastest, and an agent that surfaces a conflict it could have silently "fixed" is an agent earning graduation.
## Voice and Delivery Notes
Write specs in plain language you can read in three minutes. Status words mean things: Designed is a document, Deployed is a schedule that fires, Active is a graduation that happened. Keep "built" claims tied to an artifact behind them. Receipts beat promises at every stage.
From then on, just bring any automation idea and say "Design an agent."
Want to go further than skills?
Skills like this are how Christine runs her own business every day. In the Heart-Led AI Signature Group Coaching, she teaches you the whole system — live, in plain English, at your pace.
Explore Signature CoachingOne page. Every question a good hire answers.
Run Agent Architect on any idea and what comes back is a Build Spec — one page, written before any code, in plain language you can read in three minutes. These are its real sections, every time:
1 · Role
The job in two sentences — including what stops leaking out of your business the day this agent works.
2 · Single Duty (v1)
The one job, written as a numbered run order that ends with what the agent does NOT do. An agent with three duties is three agents wearing a coat.
3 · Trigger, Reads From & Writes To
The schedule in your timezone, the explicit, finite list of sources the agent may read, and every destination it writes to — including its own memory entry.
4 · Handoff
What you own. In v1, drafts stage for your review and the agent never touches the send button — anything that reaches the outside world stays your job.
5 · Model & Home
The cheapest model that passes review for the work, and where the agent physically runs — with the honest constraints of that home stated up front.
6 · Failure Protocol & Prerequisites
Exactly how this agent fails loud: a blocker report naming the source, the error, and the timestamp, where you'll see it the next morning. Missing prerequisites get named, never skipped.
7 · On-Ramp Plan, Graduation Criteria & v2 and Beyond
The supervised testing window, the written definition of trustworthy the agent has to earn against, and every duty you resisted putting in version one — parked until the first duty graduates.
And who hits send? You do.
Until graduation, anything that reaches the outside world — sends, publishes, charges — belongs to you. The agent earns autonomy against criteria you wrote down before its first run: clean runs, zero manual intervention, outputs that pass review without revision. And if a prerequisite is missing, the agent still deploys in fail-loud mode, reporting the gap every run until it's fixed — a loud gate beats a delayed build.
Keep stacking: pairs beautifully with On-Ramp
Agent Architect designs the hire and writes the spec; On-Ramp runs the structured seven-day testing window that turns a freshly built agent into one you actually trust.
Get On-Ramp →Because most agents die of bad hiring.
Agent projects usually die one of two deaths: scoped so big they never ship, or shipped so loose they fail silently until someone notices weeks later. Agent Architect closes both doors.
It hires for a named gap, never a demo
The hiring trigger is a leak you can name — money walking out of the pipeline because follow-up lives in your memory. If you can't say what the agent's absence costs you, the skill says you're not ready to hire it yet.
One duty, on a clock
Version 1 does exactly one job, runs on a schedule, and stops. Always-on agents juggling three duties are debugging nightmares and cost leaks — everything else parks in v2 and Beyond until the first duty graduates.
Loud beats silent
A blocked run writes a blocker report — the source, the error, the timestamp — where you'll see it the next morning. The alternative is the cautionary tale baked into this skill: an agent that died of an expired auth token, and nobody knew for weeks.
Trust is earned against a written standard
Graduation criteria get written before deployment, so trustworthy is an observable fact — clean runs, zero interventions, review passed without revision twice in a row — never a feeling you talked yourself into.
The ownership flip is the whole point
On graduation, the duty's owner of record changes from you to the agent, and your job becomes reviewing its output. An agent that runs but never takes ownership just added a supervision job to your week.