From Prompting to Delegation

You don't have a prompting problem. You have a specification problem wearing a prompting costume. When the AI misses, the reflex is to retry with more adjectives — and the retry loop is exactly the tax this course removes. A prompt fails for one of four boring reasons: you never named the deliverable, you withheld the context only you have, you didn't pin the output format, or you gave it no way to check its own work. Name the deliverable before you write a single instruction and most of the loop disappears. This module starts from your own most-retried task, not a toy example, because recognition on someone else's scenario is not transfer to yours. This is a 7-10 minute judgment module: you're not memorizing four labels, you're diagnosing one real failure of your own and rebuilding it. Worked example (Dana — founder of a 4-person brand & marketing studio; she runs client creative and ops with a small team and the same recurring deliverables every week — this module): you see the FULL install end to end — all five steps, every prompt written out — so you have a complete model before you build anything. Later modules strip a step at a time.

• →Audit one real recurring task you currently re-prompt 3+ times, and log the before-state: minutes per attempt and number of retries to a usable draft
• →Rewrite that task's prompt contract-first — deliverable named before the instruction — and produce a usable first draft of your own work in one pass
• →Diagnose your failed prompt against the four failure modes (no deliverable, no context, no format, no proof line) and label which one bit you

Do thisPick the task you most recently retried more than twice. Time one cold attempt the old way and log the minutes + retries. Then rewrite it contract-first using the Contract-First Skeleton prompt, run it once, and paste both outputs side by side into your workbook with the failure mode labeled.

Most operators burn a frontier model on a task a cheaper one handles, then call AI expensive. Cost discipline is a skill, not a setting — and it's the one almost no course grades. The move is a routing table: fast-and-cheap for sorting, summarizing, reformatting; default for drafting and reasoning; frontier only when the task genuinely needs it. You don't decide by vibe. You build a 20-minute eval — three inputs from your own work where you already know the good answer — and run any new model against it before you trust it on live work. The eval is reusable and it is your freshness insurance: every new model release, you re-run the same three inputs and watch which tier it earns, so your table stays current instead of going stale the week a new model ships. (Note: deciding WHICH of your tasks are AI-suitable in the first place is the job of Course 2's working-intelligence capability map — this module assumes you already have that list and routes it.) This is an 8-minute module: the routing table is fast to fill; the eval is where the minutes go.

• →Sort your real recurring tasks into three routing tiers (fast/cheap, default, frontier) and write a one-page routing table naming the model per tier
• →Build a 20-minute eval set of 3 fixed inputs from your own work and run it against two models, logging which held and which broke

Do thisList your five most frequent AI tasks. Assign each a routing tier and the model you'll actually call. Then take three real inputs you already know the right answer to, run them through a cheaper model and your default model, and log in your routing table which model cleared each at the lowest cost. Submit the table plus the eval log.

Prompting asks. Delegating specifies and verifies. The difference is that a delegation carries a proof line — the test the output must pass — so the AI can check itself and so can you. A five-part delegation states the deliverable, hands over the context only you hold, pins the format, sets the constraints, and ends with the proof line. Then the real skill: you don't accept the first output. You read it like an operator, name what's wrong in one or two lines, and redirect. Watching the AI work breeds overreliance; directing it is the higher-order skill this whole track sells. The second pass is not optional polish — it is the mechanism. One-shot submission is how you stay a prompter. This is a 7-10 minute judgment module because writing the redirect — naming exactly what missed, in two lines, without starting over — is the hardest move in the course.

• →Write a five-part delegation (deliverable, context, format, constraints, proof line) for one real recurring task and run it on live work
• →Direct and redirect the AI across a second pass: critique the first output against your proof line, name what's wrong, and iterate to a usable result

Do thisTake a real task from your studio — an update to a brand client, a section of a proposal, your weekly studio summary — and write it as a five-part delegation using the Five-Part Delegation Block. Run it. Then grade the output against your own proof line, write a two-line redirect naming exactly what missed, run the second pass, and submit both versions with your redirect note.

A delegation you wrote once and lost is a tax you pay again next week. The asset is a library that compounds — every entry is an SOP, not a sticky note. An SOP entry names the task, the input format it expects, the output format it returns, the edge cases that break it, and the test result that proves it works, so anyone (including future you, or an agent in Course 04) can run it cold. It lives in plain files in a folder you own, never trapped in one vendor's chat history. Then the rep: fifteen minutes a week, one entry added or sharpened. The library is your Craft gate and the raw material the next course turns over to an agent. This is a 10-minute build module — the longest in the course, because you're producing five real artifacts; if it runs longer than ~12 minutes you're polishing instead of shipping, so cut and submit at five working entries.

• →Document five delegations in SOP format — each with input format, output format, edge cases, and a logged test result — covering your real recurring tasks
• →Book a 15-minute weekly rep on your calendar to add or revise one library entry, with the troubleshooting move named in advance, and schedule the 24h/1-week/1-month artifact reviews

Do thisConvert your best delegations into five SOP-format library entries (use the SOP Library Entry template). Each entry names the task, the input it expects, the output format it returns, the edge cases that break it, and the test you ran with the result. Save them in a plain folder you own, book the weekly rep, schedule the three spaced reviews, and submit the library plus a screenshot of the calendar hold.