The Skill Pack Builder

A free Overyield tool. Everything you need to package one workflow you know cold into a sellable skill pack: the spec sheet, the pre-loaded context file, the 10-case eval, the paste-in package, the listing, and the teardown post that sells it.

You do not need code. You need one workflow you have run 50 or more times, a frontier chat subscription (Claude or ChatGPT) or about $10 of API credit, a free Lemon Squeezy or Gumroad account, and a Google Drive folder. The first build takes 10-12 hours across a week. Every build after that gets faster.

What you are building (the 60-second overview)

A digital product that sells the durable layer of the AI stack. Between June 24 and July 2, 2026, the model layer proved it is rented and repriceable: Fable 5 returned July 1 after 19 days offline (AI Daily Brief, Jul 1), and Sonnet 5 launched June 30 at $2/$10 per million tokens with the discount expiring August 31 (TechCrunch, Jun 30). Meanwhile the pain above the model stayed quantified: workers report losing 6.4 hours a week to bot-sitting, and 60% rerun the same prompts across tools (Glean, via AI Daily Brief, Jun 26).

A skill pack sells that layer: a spec, a pre-loaded context file, and a 10-case eval, packaged so a buyer pastes it in and the workflow just runs. Price: $99-$249, one time, zero marginal cost per sale.

Three rules before you start:

Scope one workflow. The best model completes 16.1% of freelance tasks at professional quality (Remote Labor Index, via AI Daily Brief, Jul 2). Your pack lives inside the 16% or it dies in refunds.
The eval is the warranty label. No eval, no pack. It is also your entire sales page.
Never promise the buyer’s hours or income. Publish your own measured numbers. Let the buyer do their own napkin.

The artifact structure (set this up first, 15 minutes)

One folder per pack: Pack Studio - [Pack Name], containing:

01-spec (the spec sheet, versioned)
02-context (the context file + a source note for every fact in it)
03-eval (the 10 cases, expected outputs, dated run logs)
04-package (the assembled bundle the buyer downloads)
05-sales (listing copy, the eval table, the teardown post)
06-support (buyer questions log, update notes)

One Google Sheet, "The Pack Ledger," five tabs:

Candidates: workflow, times you have run it, trigger definable (Y/N), output checkable (Y/N), where buyers congregate, packability score.
Eval runs: date, model + version, case #, pass/fail, notes.
Sales: date, platform, price, fees, net.
Support: date, question, answer, add-to-FAQ (Y/N).
Updates: date, what changed (model swap, context fix), version number, buyers notified (Y/N).

Tab 2 feeds your sales page. Tab 5 becomes your marketing calendar. More on both below.

Step 1: Pick the workflow (the packability scorecard)

Score each candidate workflow 1 to 5 on each row. Kill anything under 20 total, or with any 1 in the first three rows.

| Criterion | 1 (bad) | 5 (good) |
|---|---|---|
| You know it cold | Ran it a few times | 50+ runs; you could teach it from memory |
| Checkable output | “Feels right” is the test | Pass/fail criteria you can write down |
| Definable trigger | “Whenever” | A schedule or event (“the Monday export lands”) |
| Buyer density | Only you run this | A titled role runs it weekly (PM, recruiter, analyst, RevOps) |
| Congregation | Buyers are scattered | Two or more named communities where they gather |
| Pain already felt | They enjoy the task | They visibly complain about the hours |

Aim the vertical at expensive hours: the Anthropic Economic Index found high-wage professionals consume up to 2.5x more AI tokens than everyone else (TLDR AI, Jun 29). The buyer whose hour costs $60+ does the payback math fastest.

Step 2: The spec sheet (the minimum-viable-agent frame)

This is the skeleton Greg Isenberg laid out on July 1 for what makes an agent deployable: trigger, context, tools, approvals, escalations. Fill every field. Vague fields become refund requests.

```
PACK SPEC v1.0 : [Pack Name]

WORKFLOW: [one sentence: input -> output]
TRIGGER: [the schedule or event that starts a run]
INPUTS: [the exact files/exports/text the buyer supplies each run]
CONTEXT REQUIRED: [what the model must know; all of it ships in CONTEXT.md]
TOOLS: [default tier: any frontier chat. Note anything else honestly.]
STEPS: [numbered; what the model does, in order]
APPROVAL POINTS: [what a human must review before anything is used or sent]
ESCALATION RULES: [conditions where the model must stop and flag a human]
SUCCESS CRITERIA: [the checkable definition of a good output]
OUT OF SCOPE: [what this pack does NOT do; write this section generously]
```

Filled example (the worked case in this kit):

```
PACK SPEC v1.0 : The Pipeline Review Pack

WORKFLOW: Monday CRM pipeline export -> stage-movement summary with stalled-deal and risk flags.
TRIGGER: Weekly, when the Monday pipeline CSV lands.
INPUTS: One pipeline CSV (fields listed in CONTEXT.md), the prior week’s export for comparison.
CONTEXT REQUIRED: Stage definitions, stall thresholds, win-rate benchmarks, output template. All in CONTEXT.md.
TOOLS: Any frontier chat model. No integrations.
STEPS: 1) Validate the CSV fields. 2) Compare week-over-week stage movement. 3) Flag deals stalled past threshold. 4) Flag risk patterns per the rules. 5) Fill the output template.
APPROVAL POINTS: The human verifies flagged numbers against the CRM before the summary is shared.
ESCALATION RULES: Any deal over $50K moving backward is flagged for a human read, never auto-summarized. Missing or malformed fields stop the run.
SUCCESS CRITERIA: Every number traceable to the CSV; all deals past stall threshold flagged; output matches the template.
OUT OF SCOPE: Forecasting, quota math, rep performance judgments, anything requiring data not in the export.
```

The escalation rules are a selling point, not a weakness. A spec that says “never auto-send” reads as professional. Write the honest one.

Step 3: The context file (the asset that kills bot-sitting)

CONTEXT.md is why the buyer pays. It is everything they would otherwise feed in by hand, week after week. The checklist of what to pre-load:

Definitions: every term of art in the workflow, defined the way a practitioner uses it.
Formats: the exact output template, field by field.
Gold examples: 2-3 finished outputs, annotated (“this is what good looks like, because...”).
Edge cases: the weird inputs you have hit and how to handle each.
Tone rules: how the output should read, with one good and one bad sentence.
The never-do list: invented numbers, guessed fields, skipped escalations.

The extraction prompt (run it on your own past outputs and notes to draft CONTEXT.md fast):

❝

You are helping me package a workflow I run every week into a reusable context file. Below are several of my past outputs and working notes for this workflow. Extract: (1) every term of art and its working definition, (2) the implicit output format as an explicit template, (3) the rules I appear to follow, stated as instructions, (4) edge cases visible in the material and how I handled them. Do not invent rules that the material does not support; where you are inferring, mark the line [INFERRED] so I can confirm or delete it. MATERIAL: [paste]

You review every [INFERRED] line. The model drafts; you verify. Same division of labor you are selling.

The legal box, before you paste anything: your ex-employer’s data is not yours. No client lists, internal benchmarks, proprietary templates, or confidential numbers go into a pack, ever. Rebuild definitions and thresholds from public knowledge and your own general expertise. You are selling your method, not someone else’s data. If a rule only exists inside one company’s walls, generalize it or cut it.

Step 4: The 10-case eval (the warranty label)

Ten realistic inputs with known-good outputs. Composition:

6 typical cases: ordinary inputs, the workflow’s bread and butter.
2 edge cases: the messy-but-legitimate inputs (a half-empty export, an outlier value).
2 integrity traps: one case with missing data where the correct behavior is to flag it and refuse to guess, and one case where the correct answer is “escalate to a human.” These two catch the failure mode that ruins packs: confident fabrication.

The eval runner prompt:

❝

Run the packaged workflow below on the test input. Follow the spec exactly, including escalation rules. Produce only the workflow’s defined output. SPEC: [paste] CONTEXT: [paste] TEST INPUT: [paste case]

Score each case pass/fail against your written expected output. Pass bar: 8 of 10, with zero fails on the two integrity traps. Below the bar, fix the spec or the context, not the scoring.

The eval table template (this goes on your sales page):

Attribution rules for anything you publish (use them exactly, or publish nothing):

Stamp every table with the date and the exact model + version. Undated eval claims are worthless.
Keep the raw run logs in 03-eval. Never publish a row you cannot reproduce.
Any time-saved claim is YOUR timed number, phrased as yours: “the old way took me about 3 hours; the packaged way takes me about 40 minutes.” Never state it as the buyer’s guaranteed outcome.
Re-run and re-date the table after any model swap or pack update. A stale table is a false claim with a delay.

Step 5: Package it (the tier ladder)

Default tier: the paste-in bundle. One zip, five files:

README.md: the 5-minute install (open your chat model, paste MASTER-PROMPT, attach or paste CONTEXT, run your first input), plus the requirements line and the data note below.
MASTER-PROMPT.md: the spec converted into a single operating prompt.
CONTEXT.md: the context file.
EVAL-PACK.md: the 10 cases + expected outputs, so the buyer can verify on their own model.
SPEC.md: the human-readable spec sheet.

This tier works in any frontier chat with no installs. It is the tier that sells, because every buyer can run it in five minutes.

Upgrade tier 1: the Claude skill / custom GPT. Same assets, pre-wired as a Claude skill or a custom GPT configuration. Add it when buyers ask, price it $50-$100 above the base.

Upgrade tier 2: the MCP server. For technical sellers with technical buyers only. Do not lead with it, and do not build it before the paste-in tier has sold. A pack nobody can install is not a product.

Step 6: Price it and list it

The brackets:

$99: a narrow workflow, or your first pack while you learn.
$149: the default. One well-scoped professional workflow with a clean eval.
$249: the pack plus 12 months of updates. Only promise updates you will actually ship (Step 8 makes them cheap to ship).

The listing template (Lemon Squeezy or Gumroad; both handle checkout and sales tax as merchant of record):

Title formula: “The [Workflow] Pack: [output] in [your timed number], verified by a 10-case eval.”
The problem, two sentences: the bot-sitting hours, in the buyer’s own vocabulary.
What’s inside: the five files, listed plainly.
The eval table: pasted in full, dated, with the model named. This section does the selling.
Your timed numbers: old way vs packaged way, phrased as your own runs.
Requirements line (mandatory): “Requires your own Claude or ChatGPT subscription (about $20/month, not included). The pack contains no software.”
The boundary: what the pack does not do, from the spec’s OUT OF SCOPE section. Honesty here is what keeps refunds near zero.
Refund policy: 14 days, no questions. A confident policy sells; a defensive one leaks.
The buyer’s napkin, framed as theirs: “If your loaded hour costs $60 and this kills 2 of the hours you spend babysitting this workflow each week, that is $120 a week. Your math will vary; the eval is how you check before you rely on it.”

Step 7: The teardown post (distribution for a seller with no audience)

The proven engine from this window: Post For Me grew to a reported $10-11K MRR with almost no audience by turning real customer questions into resource articles that Google, ChatGPT, and Claude now pick up as answer sources (The Koerner Office, Ep #312, Jun 26). Copy the shape: one question-shaped post per pack, written to be the citable answer for that workflow’s question.

The template:

Title = the buyer’s question: “How do I [run the workflow] with AI without babysitting every run?”
The old way: the manual steps and your timed number.
The packaged way: spec + context + eval, what each part kills, your timed number.
The eval table, pasted in full.
The honest boundary: who this does not fit.
The link, once, at the end.
The engagement line: “If your version of this workflow differs, describe it and I will tell you straight whether the pack fits.”

Posting rules: read each community’s self-promotion rules before posting; many allow it only in weekly promo threads, and a ban costs more than a launch day. Lead with the teardown’s substance, not the link. Post to your own profile always. Two communities plus your profile is the whole month-one engine; more spray does not convert, it just burns goodwill.

Step 8: Support and updates (one hour a week)

Answer buyer questions within a day; log each in Support (tab 4); promote repeats into the listing FAQ.
The update flywheel: every model swap or repricing event triggers a re-run of the 10-case eval. This window produced two such events inside eight days (the Fable return, Jul 1; the Sonnet 5 intro pricing, Jun 30), so the cadence is real. Re-run, re-date the table, fix what broke, ship a vX.Y note to buyers. That note is also your marketing: “re-verified on [new model], table updated” is a reason to post the teardown again.
Version everything. Buyers of the $249 tier get every update; the update log (tab 5) is the receipt that the promise is being kept.

See it work: the Pipeline Review Pack, blank folder to first sale

The seller: a RevOps analyst who has run the Monday pipeline review for two years and is tired of watching peers rebuild the same prompt.

Monday evening (2 hours). Runs the packability scorecard: 27/30. Sets up the folder and the Ledger. Drafts the spec sheet from the template above.

Tuesday evening (2 hours). Runs the extraction prompt on six of her past pipeline summaries. Reviews every [INFERRED] line, deletes two, confirms the rest. CONTEXT.md drafted: stage definitions, stall thresholds rebuilt from public RevOps benchmarks (nothing proprietary), the output template, two annotated gold examples.

Wednesday evening (2 hours). Writes the 10 eval cases: six ordinary weeks, one half-empty export, one outlier quarter-end week, one missing-fields trap, one $60K-deal-moving-backward escalation trap.

Thursday evening (2 hours). Runs the eval on Sonnet 5. First pass: 8/10, but one integrity trap fails (the model guessed a missing close date). She tightens the never-do list in CONTEXT.md and the escalation wording in the spec. Second pass: 10/10. Total API spend across both passes: about $6 at the $2/$10 intro pricing (TechCrunch, Jun 30). Logs both runs, dated, model-stamped.

Saturday (3 hours). Assembles the five-file bundle. Writes the listing from the template: $149, the dated eval table pasted in, the requirements line, the out-of-scope section, 14-day refunds. Writes the teardown post: “How do I turn Monday pipeline reviews from 3 hours into 40 minutes without babysitting the AI?” with her own timed numbers.

Sunday. Posts the teardown to one RevOps Slack’s promo thread and one operations subreddit, plus her own profile. Answers four questions in the comments using the engagement line.

Week one result, the modest case: 2 sales from the communities, 1 from a comment thread. Week three, a colleague shares the post: 2 more. Month one: 5 sales, $745 gross, about $650 net after platform fees. Tab 3 has five rows. The eval table has been re-run once (a model version bump), which produced a v1.1 note and a second honest reason to post.

Numbers are illustrative and deliberately conservative; the model costs are drawn from the June 30, 2026 pricing cited above and will drift. What does not drift: publish only numbers you can reproduce from your own logs.

Your 7-day install plan

Day 1: Scorecard your three best-known workflows. Pick the winner. Set up the folder and the Ledger.
Day 2: Draft the spec sheet. Every field filled, out-of-scope written generously.
Day 3: Build CONTEXT.md with the extraction prompt. Verify every line. Run the legal box check.
Day 4: Write the 10 eval cases. Run the eval. Fix and re-run until 8/10 with clean integrity traps.
Day 5: Assemble the bundle. Write the listing with the dated eval table.
Day 6: Write the teardown post. Find the two communities and read their promo rules.
Day 7: Publish the listing, post the teardown, answer every comment. Log everything.

Then hold the weekly hour: support, eval re-runs on model news, and one fresh place to show the teardown.

Legal and honesty notes (read before you sell anything)

Employer and client IP (the big one): nothing confidential or proprietary from a current or former employer or client goes into a pack: no internal data, benchmarks, templates, or client information. Check any agreements you signed (confidentiality, IP assignment, moonlighting clauses) before selling a pack built near your day job’s territory. Rebuild from public knowledge; generalize or cut anything you cannot.
No income or time promises: your timed numbers are yours, phrased as yours. The buyer’s napkin is framed as the buyer’s. No “save 6 hours a week guaranteed.”
The eval table is a factual claim: real runs, dated, model-stamped, reproducible from logs you keep. The FTC’s rules on deceptive claims apply to a $149 pack the same as to anything else. No fake reviews, no invented testimonials, ever.
Refunds and platform terms: honor your stated policy without friction; follow the listing platform’s ToS, including any AI-disclosure requirements.
Buyer data note (put it in the README): the pack runs inside the buyer’s own model account, so their data goes wherever their model subscription sends it. Tell buyers plainly: “Run this only in tools your organization has approved; do not paste confidential data into personal accounts.”
Community rules: self-promotion where it is allowed, in the format it is allowed. One ban costs more than ten launches earn.
If you email buyers (updates, launches): CAN-SPAM basics apply: truthful subject, a working opt-out, honored promptly.

Want the line, not just the pack?

The free kit builds you one pack by hand. The Pack Line, this issue’s Pro upgrade, is the product-line layer: the niche-selection matrix that scores verticals by token intensity and willingness to pay, the three-tier pricing ladder ($99 / $249 with 12 months of updates / $499 team license with the expense-approval one-pager), the model-churn update flywheel that turns every reprice into a paid update and a marketing beat, and the teardown-post distribution template engineered to be the citable answer for your workflow’s question. It ships to members as a rolling build, and founding members set the order.

Founding rate: $129 a year, locked forever. Closes when the first 25 members are in; the standard price rises toward $399 as the Vault and the scorecard grow.

Join Overyield Pro founding

This kit is from Overyield: make money with AI, one play at a time. Educational, not legal or business advice. Check your own agreements before packaging work adjacent to your employment, follow the FTC’s truth-in-advertising rules, and publish only numbers you can defend. Numbers in examples are illustrative.

The Skill Pack Builder (free)