The Compile Cut Kit (free)

A free Overyield tool. Everything you need to walk into one mid-sized company, replace one recurring AI workflow with deterministic code, and bill from the measured savings.

You do not need to be a developer. You need a Google Sheet, a chat model (Claude, Gemini, or ChatGPT), one of Apps Script or n8n or Make, and one company that already has an AI bill they cannot defend. Work top to bottom. The first compile takes a weekend. After that, each one is faster.

One repeatable process: pick one recurring AI workflow at a 25 to 150 person agency or ops team, pull 30 days of their usage and a handful of sample outputs, interview the human who actually runs it, encode the tacit rules into a deterministic script with a sheet for the input and the output, run it side by side with their existing agent for two weeks, and bill from the verified savings. You are not selling AI. You are selling a smaller invoice with the same work shipped.

Your whole operation lives in one folder with six sub-folders. Set them up empty now; the steps fill them:

Not every AI task is a Compile candidate. The math only works on tasks that look the same week to week. Use this filter.

GOOD candidates (compile these):
- Weekly client performance reports from ad platforms.
- Monthly account review decks built from standard inputs.
- Proposal or quote drafts from a known template and a CRM field.
- Lead screening or lead enrichment from a form or a CSV.
- Customer-success or QBR summaries from call recordings or ticket logs.
- Content refreshes or SEO updates on existing pages.
- Invoice or expense classification.
- Recruiting screens from inbound applications.

BAD candidates (do NOT compile these):
- Open-ended strategy or brainstorming.
- One-off research projects.
- Anything where every input is a unique shape.
- High-stakes final decisions where 99% accuracy is not enough (medical, legal final filings, irreversible financial commitments).

The 50-run rule. If the workflow runs fewer than 50 times a month, the savings will not pay for your time. Pass.

The $300 rule. If the current monthly cost is under $300, pass. The math will not be clean enough to defend.

Cold or warm, the note is the same. Send it to agency owners, ops leads, and finance leads in your target vertical.

Reply rate target: about 10 to 20% on warm outreach (people who already know you); on true cold, expect 3 to 10% (see the cold-outreach bonus below). From 20 warm notes, expect 2 to 4 conversations. From those, expect 1 yes.

Ask these six questions. Write down the answers.

End the call with the offer: $500 diagnostic deposit up front, $750 build fee on acceptance, 25% of verified savings for 3 months capped at $1,000. “If the math is not real, you stop paying. The whole thing is built around a measured savings receipt.”

If they say yes, ask for two things in writing: 30 days of usage and 20 redacted sample outputs. Without those, walk.

Schedule a 45-minute screen share with the person who actually runs the workflow. Not the owner. The person.

Open with: “I am going to ask you a lot of small questions. Please show me the same example you would do on a normal Tuesday.”

Then walk through, in this order:

Record it. Run the transcript through this prompt:

This output goes into 03-rules. This is your product. Everything downstream is just executing it.

The reflex is to over-engineer. Do not. Use the simplest stack the job needs.

Default stack (works for 70% of agency workflows):
- Google Sheet for inputs and outputs.
- Apps Script (free, lives inside the Sheet) for parsing, calculations, lookups, formatting, and templated language.
- One small model call (Claude Haiku, Gemini Flash, or GPT-mini) for the parts that genuinely need prose or judgment.
- A second tab as the audit trail: timestamp, input ID, who reviewed, pass/fail/review.

Fallback stack (when the data lives across systems):
- n8n or Make for orchestration.
- Airtable for state.
- Same one-small-model-call rule.

The rule of one model call. A compiled workflow makes at most ONE model call per run, on the part that truly needs judgment. Everything else is deterministic code. If you are calling the model three times per run, the architecture is wrong. Go back to the rules doc.

Build the first version in 4 to 6 hours. Get to runnable, not pretty.

Open a sheet with 20 rows. Each row is one historical input from 02-samples.

Columns:
- Input ID
- Date of original run
- Original AI output (paste)
- Compiled output (paste)
- Pass / Fail / Human-review
- Notes
- Cost of original run (estimated from usage log)
- Cost of compiled run (measured)

Run all 20 cases through the compiled workflow. Compare side by side. Aim for:
- Pass rate above 90% on normal cases.
- All edge cases routed to human review (not silently mis-answered).
- Cost per run at least 50% lower (most compiles hit 80 to 99% lower).

If you cannot hit those numbers, go back to the rules doc. Do not ship.

For two weeks, run both versions in parallel.

Each day:
- Log every run through the old agent and the new compiled workflow.
- Note any divergence.
- Have the operator review the compiled output (not just the AI output) for the first week, then random spot-checks in the second.

End of day 14, fill the savings receipt.

The 30-day before/after that justifies the success fee. Define every term before you start.

Attribution rules (use these exactly):

Track these:

Screenshot the baseline. Email the after. That one image is your testimonial, your case study, and the reason your next agency client signs without negotiation.

A realistic worked example, so you know exactly what you are delivering.

The client: a 45-person paid media agency that manages 80 client accounts. They send a weekly performance report on every account. That is roughly 320 reports a month, plus retries and edits, plus mid-month QBRs. Call it 500 AI runs a month.

Their setup: one long Claude prompt that ingests the Meta Ads CSV export and the Google Ads CSV export, then writes the full report. Cost per run, all-in: about $2. Monthly bill: about $1,000.

The diagnostic call (Step 3). The owner shows the bill on screen, confirms 500 runs a month, says the analyst spends 4 minutes editing each report on average. They agree to $500 + $750 + 25% capped at $1,000.

The interview (Step 4). The analyst shows you a normal Tuesday. She opens the CSVs, scans for the four things she actually cares about (spend pacing vs budget, CPA movement week over week, ROAS movement week over week, anomalies in conversion volume). Then she scans for two flags: “is this account at risk of pacing low” and “did we make a creative change this week.” Then she fixes the AI’s two recurring tells: it makes up account history, and it pads the executive summary.

The rules document writes itself:
- IF spend pacing under 80% with one week left, FLAG.
- IF spend pacing over 110% with one week left, FLAG.
- IF CPA up more than 20% week over week, FLAG.
- IF ROAS down more than 15% week over week, FLAG.
- IF conversion volume zero for any campaign, FLAG.
- NEVER reference account history beyond the data in this report.
- Executive summary: exactly two sentences. One sentence on the result. One sentence on the next action. No marketing language.

The compile (Step 5). A Google Sheet ingests both CSVs into two tabs. Apps Script does all the math. The script fills a report template from a master tab with one row per account. The flagged accounts get a one-call summary written by Gemini Flash (one model call per FLAGGED account, not per account). Most accounts that week are clean, so the model gets called maybe 12 to 20 times across 80 accounts. Each call costs cents.

The 20-case eval (Step 6). You run 20 historical Tuesdays through the compiled workflow. 18 pass. 2 route to human review (one had a missing field in the CSV, one had a brand-new conversion event the rules did not know about). Cost per run, compiled: about 50 cents.

The 14-day test (Step 7). Side by side. The analyst keeps editing both for a week. By day 10, she stops editing the compiled output entirely. By day 14, the owner asks if you can do the QBR summary the same way.

The savings receipt (Step 8):

Your total from this one client: $500 + $750 + $562 = $1,812.

Then the owner asks you to do the QBR summary. That is the second compile, no diagnostic discount: $750 build + 3 months of 25% savings on whatever that workflow saves. Then they ask if you can do recruiting screens, a third compile at the same shape. Two more compiles at roughly $1,200 to $1,500 each takes this client to about $4,000 to $5,000 by end of quarter one. And you have a screenshot that closes the next three. Round down on the upside; the worked example here is the proof, not the ceiling.

Numbers here are illustrative and conservative. Real results vary by vertical, workflow complexity, and how disciplined the buyer is about logging runs. Never promise a number before the eval. Show the method and let the savings receipt speak.

You do not need a month. You need a week and a willing operator.

That is the install. The savings receipt goes out 30 days later.

If the client cannot get you 30 days of usage and 20 sample outputs in 48 hours, the plan slips by however long they take. That is normal.

You will hit this on most engagements. The buyer knows the bill is too high but cannot tell you cost per run. Use this two-step.

Divide total spend by run count. That is your baseline cost per run. Note it in 01-baseline with the calculation written out so you can defend it.

If the workflow shares an API key with other work, ask the client to either split keys before the test or to estimate the % of usage attributable to this workflow. Document the assumption.

The free kit is the method. The Pro Operator’s Edition ships the working scripts as they roll out. If you are building from scratch, here is the skeleton for the paid-media weekly report compile, the most common case. Drop it into Apps Script (Extensions: Apps Script in your Sheet), wire it to the right tabs, and extend.

```javascript
// THE COMPILE CUT: paid-media weekly report starter
// Run from the Sheet menu: Compile > Run weekly report

function onOpen() {
SpreadsheetApp.getUi()
.createMenu('Compile')
.addItem('Run weekly report', 'runWeeklyReport')
.addToUi();
}

function runWeeklyReport() {
const ss = SpreadsheetApp.getActiveSpreadsheet();
const meta = ss.getSheetByName('meta_ads_raw').getDataRange().getValues();
const google = ss.getSheetByName('google_ads_raw').getDataRange().getValues();
const out = ss.getSheetByName('report_out');
out.clear();
out.appendRow(['Account', 'Spend Pacing', 'CPA WoW', 'ROAS WoW', 'Convs', 'Flag', 'Summary']);

const byAccount = aggregate(meta, google);
for (const acct in byAccount) {
const row = byAccount[acct];
const pacing = pacingPct(row.spend, row.budget, row.daysLeft);
const cpaWoW = pctChange(row.cpaThisWk, row.cpaLastWk);
const roasWoW = pctChange(row.roasThisWk, row.roasLastWk);
const flag = computeFlag(pacing, cpaWoW, roasWoW, row.convs);
const summary = flag ? callGeminiSummary(acct, row, flag) : '';
out.appendRow([acct, pacing, cpaWoW, roasWoW, row.convs, flag, summary]);
}
}

function aggregate(meta, google) {
// group rows by account, sum spend, convs; capture last/this week cpa+roas
// implementation depends on your CSV columns
}

function pacingPct(spend, budget, daysLeft) {
if (!budget) return null;
return Math.round((spend / budget) * 100);
}

function pctChange(a, b) {
if (!b) return null;
return Math.round(((a - b) / b) * 100);
}

function computeFlag(pacing, cpaWoW, roasWoW, convs) {
// FLAG returned as a non-empty string triggers the model call
if (pacing != null && (pacing < 80 || pacing > 110)) return 'PACING';
if (cpaWoW != null && cpaWoW > 20) return 'CPA_UP';
if (roasWoW != null && roasWoW < -15) return 'ROAS_DOWN';
if (convs === 0) return 'NO_CONVS';
return '';
}

function callGeminiSummary(account, row, flag) {
// ONE small model call per FLAGGED account. Use Gemini Flash, Haiku, or GPT mini.
// Return exactly two sentences: one on the result, one on the next action.
// Use UrlFetchApp.fetch + your API key (store via PropertiesService).
return ''; // operator wires in their key
}
```

Extend this for the other six workflows by changing the input tabs, the aggregation, and the flag logic. The compile pattern (deterministic math + flag + one model call per flagged row) stays the same.

The Pro Operator’s Edition ships the full plain-English contract as part of its rolling build. If you are writing your own to ship today, do not leave without these four clauses. Adapt them with a real lawyer if the deal is over $10K.

These are the protection clauses. The Pro contract adds: confidentiality, data-handling, termination, IP ownership of the compiled script, and the data-privacy guardrails below.

The 20-note play above works on warm outreach (people who already know you) at 10 to 20% reply. On true cold, expect 3 to 10%.

For US cold outreach (CAN-SPAM): include a physical address, an opt-out, and accurate sender ID. Reply-only to opt-ins for the second touch.

For EU/UK cold outreach (GDPR): cold B2B email is not safe-by-default. Lean on warm intros, in-person events, or opt-in lists. If you do cold, document a legitimate-interest basis and respect any data-subject request immediately.

The compile touches ad-platform exports, CRM records, call transcripts, and sometimes resumes or invoices. Four rules.

This checklist is the product. It is why you get paid $1,800 to compile one workflow instead of $50 for a prompt template.

The free kit is the runnable starter. The Pro version is the Compile Cut Operator’s Edition: the seven highest-yield agency workflows (weekly performance report, monthly client review, proposal draft, content refresh brief, recruiting screen, customer-success summary, invoice classification), each delivered as a complete install: the filled rules document, the working script, the 20-case test set, and the savings dashboard your client wants to see. These ship to members as a rolling build, flagship weekly report first, and founding members set the order of the rest. Plus the closer scripts, the contract template, the share-of-savings tracking sheet, and the playbook for stepping up from one workflow to a company-wide compile.

Founding rate: $129 a year, locked forever. It closes when the first 25 members are in.

This kit is from Overyield: make money with AI, one play at a time. Educational, not legal or business advice. Follow your local rules for client data handling, customer information, and contracts. Numbers in examples are illustrative.