The Prompt Contract

# The Prompt Contract: how to make your AI ship the right answer on the first try

Your AI isn't giving you bad answers. You're giving it bad asks.

Most people prompt like they're texting a friend — "fix the login thing", "make this faster",
"clean up the code" — and then blame the model when it guesses wrong. But it only ever knew what
you told it. A vague ask doesn't save you time; it just moves the work to the end, where you
rewrite the same request four more times. This is the exact fix I use: a tiny, reusable
contract you write your asks against, so almost every one comes back right the first time.

The kit is free. On Instagram you can also comment PROMPT and the bot will DM it to you;
everywhere else the download button above is it.

It's a habit, not a tool — three short files you can read in ten minutes and use on your very next
prompt. No install, no account, no API key.

- The Prompt Contract (prompt-contract.md): the six clauses that turn a vague ask into
one that ships first try, each with a before/after example.
- The first-try checklist (first-try-checklist.md): the 6-point pass to run any important
ask through *before you hit enter* — plus a 10-second version.
- The debugging guide (debugging-asks.md): the single highest-leverage pattern for bug
prompts — expected vs. received — that lands the real bug in one turn.

A contract-grade ask replaces the guesses the AI would otherwise have to make:

1. Name the exact target. The file, the function, the artifact — by name, not "the login
thing".
2. State one verifiable success criterion. Say what "done" looks like in a way you could
actually check ("done = an empty password shows an error and the form doesn't submit").
3. Declare the constraints and gates. Say what it may and may not touch, *before* it has to
guess. Unstated permissions default to "closed".
4. Give references, not adjectives. Paste the error, the sample, the schema — "match this"
beats "make it good".
5. State, don't hedge. An instruction, not a "maybe we could…". If it's genuinely fuzzy, say
"ask me first" on purpose.
6. End with the next step. Tell it how to report back — show the passing test, list what
changed, or "end with N of M done, next is X".

The whole thing in one line:

> Name the target · one checkable goal · the gates · the references · say it straight · the next step.

The text (what most people send):

fix the login bug

It guesses which bug, guesses what "fixed" means, guesses what it's allowed to change — and you
spend four rounds correcting it.

The contract (what ships first try):

In src/auth/login.ts, submitting an empty password currently succeeds.
Expected: an empty password shows "Password required" and the form does not submit.
You may edit login.ts and login.test.ts. Don't touch the API layer.
When done, show me the new test passing and what you changed.

Same task. One of these comes back right the first time. That's the whole contract.

Stop saying "it's broken, fix it" — that makes the AI re-derive the whole problem and usually
guess wrong. Instead, hand over three things:

• Input — exactly what went in (the data, the command).
• Expected — what you thought would happen.
• Received — what actually happened (paste it verbatim — the error, the output).

Now it's debugging the same gap you are. "Received now equals expected" becomes the success
criterion, and the bug gets fixed in one turn instead of four.

A vague ask typically costs several correction rounds before it lands; a contract-grade ask ships
on the first try, so those rework loops drop to zero — 4 → 0 in the video. Treat that as a
representative, illustrative figure for the cost of a bad ask, not an audited personal metric:
the real number depends on your task, but the direction is the whole point.

A tool you install once and forget. A *habit* pays off on every ask you ever write, across every
project, forever. Learn the six clauses one time and you stop losing hours to rewrite loops for
the rest of your life as an AI user. That's the compounding: one-time cost, permanent payoff.

- [Claude Code](https://docs.claude.com/en/docs/claude-code) — or any AI you already prompt.
The contract is provider-agnostic; it's about *your* half of the conversation.
- The kit itself — the contract, the first-try checklist, and the debugging guide, all in one
zip: download it here.

Take the next thing you were about to ask your AI. Before you send it, name the exact file, write
the one "done =" line, and say what it may touch. Send that instead. The first time an ask comes
back right on the first try, you'll never write a lazy one again.