CHRISTINE Make Every New Automation Earn Your Trust
On-Ramp puts any new agent, cron job, or automated workflow through a structured 7-day testing protocol before it gets more responsibility. The agent evaluates itself after every run — you review one message on Day 7 and reply with one word.
← 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: on-ramp description: Run a structured 7-day MVP testing protocol after any new agent build, cron job, or automated workflow goes live. This is the quality gate between "it's built" and "it's trusted." Use this skill whenever I say "on-ramp," "run on-ramp," "MVP test," "test this build," "graduation checklist," "is this ready for the next phase," or any variation of wanting to validate that a live build is actually working before adding more responsibility. Also trigger when I just deployed a new agent, cron job, or automation and haven't set up a testing protocol yet. If I move straight from building to Phase 2 without running on-ramp, suggest it. Pre-flight is the steering wheel before you build. On-ramp is the quality gate after the engine starts running. --- # Agent On-Ramp — Trust Before You Scale Run a structured 7-day MVP testing protocol after any new agent build, cron job, or automated workflow goes live. The agent evaluates itself. I review one message. That's it. The principle: Building it is step one. Trusting it is step two. On-ramp is how you earn trust before giving an agent more responsibility. ## When to Use This Any time a new agent, cron job, or automated workflow just went live and needs validation before scaling. This includes: - A new agent running its first cron job - A new automation running on a schedule - A new automated pipeline writing to a tracker or database - Any build that runs autonomously without me starting it - Any build moving from Phase 1 (capture/categorize) to Phase 2 (autonomous implementation) If the build is a one-time manual task (running a script once, testing a single API call), skip this. On-ramp is for things that run repeatedly and autonomously. ## Trigger Phrases - "on-ramp" - "run on-ramp" - "MVP test" - "test this build" - "graduation checklist" - "is this ready" - "ready for the next phase" - "validate this build" - "how do we know this is working" ## The On-Ramp Protocol ### Step 1: Identify What's Being On-Ramped Confirm with me: - What agent or automation just went live? - What does it do? (one sentence) - Where does it write output? (my tracker, a file, my phone or chat, wherever the results land) - How often does it run? (cron schedule) If this is already clear from the conversation, don't re-ask. Move to Step 2. ### Step 2: Set Up the Accountability Log The agent being on-ramped needs a place to log its own performance after every run. Check whether I already have a tracker set up for this, wherever I track work. If one exists, use it. If it doesn't, set one up with these fields: - **Run Date** (Title): Date of the run - **Agent** (Select): Which agent ran (the agent being tested, named however I refer to it) - **Run Status** (Select): Success / Partial / Failed - **Items Found** (Number): How many new items were detected - **Items Processed** (Number): How many were fully processed - **Items Skipped** (Number): How many were skipped and why - **Errors** (Text): Any failures, auth issues, or timeouts. "None" if clean. - **Output Accuracy** (Select): Yes / No (did output land correctly in the target system) - **Confidence** (Number): The agent's self-assessed confidence in its output quality (1-5) - **Notable Item** (Text): The single most valuable item from this run - **Security Check** (Select): Clean / Issue Found ### Step 3: Write the Agent Instructions Draft the message I send to my agent (via my phone, chat, or a workspace file) that turns on the on-ramp protocol. The message must include: 1. **What to log**: Every field from the Accountability Log, filled out after every run 2. **When to log**: Immediately after each run completes 3. **The 7-day graduation report**: On Day 7, the agent sends me a message (on my phone or chat) with this format: --- **[AGENT NAME] — 7-DAY ON-RAMP REPORT** **TL;DR:** [emoji signal] + one sentence summary Emoji signals: - 🟢 = Ready to graduate - 🟡 = Needs another week - 🔴 = Real issues found Then list each checklist item with an emoji signal: - Cron ran all 7 days without manual intervention - Zero duplicate entries in the target system - Zero authentication or credential failures - Average confidence score 4+ out of 5 - Output landed correctly in the target system every run - Briefings/notifications sent on time every day - Credentials stored in locked files, not in chat or workspace files - Operating with minimum necessary permissions **By the numbers:** - Total items processed across 7 days - Total entries created in the target system - High-value items flagged **Your call. Reply with one:** - **"Graduate"** — Agent moves to the next phase - **"Run another week"** — 7 more days at the current level - **"Fix [issue]"** — Tell the agent what needs adjusting --- ### Step 4: Confirm the Protocol Present the full on-ramp setup to me: - Where the Accountability Log lives - What the agent will log after every run - When the graduation report arrives - What the response options are Then say: > **On-ramp is set. The agent handles everything. You review one message on Day 7 and reply with one word. Ready to activate?** ### Step 5: Activate Once confirmed, I send the instructions to my agent. On-ramp is live. I do nothing for 7 days except keep using the system naturally (the normal action that triggers the agent's work). ### Step 6: Graduation (Day 7) When the graduation report arrives: - **All green** = the build earned trust. Move to the next phase. Update the build tracker. - **Yellow items** = the build is close but needs refinement. Fix the flagged issues and run another 7 days. - **Red items** = something is broken. Fix the root cause before continuing. After graduation, log the result in my build tracker, if I keep one, with a one-line graduation statement: what the agent proved and what it earned the right to do next. ## Voice and Tone - Direct. No fluff. - This is not a test I administer. This is a test the agent administers on itself, and I review. - My time is protected. The whole point is that the agent does the evaluation work. - Keep the energy forward-moving. On-ramp is not a gate that blocks progress. It's the bridge between "built" and "trusted." ## Key Principles - Building something is exciting. Trusting it requires evidence. - The most dangerous moment in agentic AI is when something works once and you assume it works always. On-ramp catches the gap between "it worked in the test" and "it works reliably." - Agents should evaluate themselves. Humans should review the evaluation. That's the right division of labor. - Security is baked into the on-ramp from Day 1, not saved for a later phase. - This protocol is reusable. Every new agent, every new cron job, every new automation gets the same on-ramp. One Accountability Log supports all agents. The graduation report format stays consistent. The response options are always the same. Systems create trust at scale.
From then on, whenever a new build goes live, just say "Run on-ramp."
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 CoachingA full testing protocol, set up in one conversation.
Run On-Ramp right after a new build goes live and it hands you everything the 7-day test needs — then gets out of your way for a week. Here's what gets set up:
1 · The Accountability Log
A tracker where the agent records every single run: status, items found and processed, errors, whether the output landed correctly, a 1-to-5 confidence score, and a security check. If you already have one, it gets reused.
2 · The Agent's Instructions, Written for You
The exact message you send to switch the protocol on — what to log, when to log it, and precisely how the Day 7 report should arrive. You send it once.
3 · The 7-Day Graduation Report
On Day 7, one message lands with a green, yellow, or red signal up top, then the checklist: ran all seven days without you stepping in, zero duplicates, zero credential failures, confidence averaging 4-plus, output landing correctly, and security clean.
4 · A One-Word Decision
You reply Graduate, Run another week, or Fix — naming the issue. That's the entire ask of your time. The agent did the evaluation; you make the call.
5 · The Graduation Entry
Once you make the call, the result lands in your build tracker with a one-line graduation statement: what the agent proved over seven days, and what it earned the right to do next.
Green doesn't mean 'probably fine'
Graduation gets earned against a real checklist — seven days of runs without you stepping in, zero duplicates, zero credential failures, and security clean from day one, with credentials locked down and minimum permissions only. Yellow means another week at the current level. Red means fix the root cause before anything scales. And if your build is a one-time manual task, On-Ramp tells you to skip it entirely — this protocol is for things that run repeatedly on their own.
Keep stacking: pairs beautifully with Agent Architect
Agent Architect designs, scopes, and deploys an agent through a full hiring pipeline — On-Ramp is the testing week inside it, where a finished build earns the trust to take on more.
Get Agent Architect →Because working once isn't the same as working.
The most dangerous moment in agentic AI is when something works once and you assume it works always. On-Ramp exists to catch the gap between 'it worked in the test' and 'it works reliably.'
Trust needs evidence, not a demo
Building something is exciting — trusting it requires proof. Seven days of real, logged runs surfaces what a single successful test never shows: the missed schedule, the duplicate entry, the credential failure on day four.
The agent grades itself — you review
That's the right division of labor. The agent fills out the log after every run and writes its own report; you read one message and make one judgment call. Your time stays protected the whole week.
Security is baked in from day one
Credentials in locked files, minimum necessary permissions, and a security check logged on every run — not a hardening pass you schedule for later. A build doesn't graduate until security is clean.
The signals leave no room for spin
Green, yellow, or red — every checklist item gets one. A report that has to declare zero duplicates and zero credential failures can't hide a rough week behind a cheerful summary.
One protocol covers every build you'll ever launch
The same log, the same report format, the same three replies — for every agent, cron job, and automation from here on. Systems create trust at scale, and this is the system.