12 prompts that make your AI agent actually useful
By Melody, The Lead Lab · For people who run agents, not just chat with them
Most people use an AI agent like a search box — ask, skim, move on. Operators use it like a junior colleague with a verification habit. The difference is rarely the model. It's a handful of instructions, given at the right moment, that force proof, structure, and memory. These are those instructions. Copy one, paste it into your session, fill in the brackets.
12prompts, ready to copy
4jobs: verify, delegate, orient, improve
$0no signup, no tool required
How to use this library
Don't read it like an article — run it like a toolkit. Each prompt names the moment it's for. When you hit that moment in a session, paste the prompt in as-is. The text in [brackets] is the only part you change.
Two habits make the whole library work harder: keep the outputs. A reconciliation, a debrief, a decision — save them where your agent can read them next session. And stack prompts: a delegation brief at the start of a task, a pre-send check at the end, a one-percent-better note to close the day.
Verify & trust
Agents sound certain about everything, including the things they got wrong. These four prompts make proof the default instead of the exception.
1Reconcile Before You Act
When: Before you act on any report, summary, or set of numbers an agent hands you.
Before we use any figure from this report, reconcile it. For each key number, find the primary source it came from — the original record, dataset, file, or page — and check the figure against it.
Give me a short table: the figure, where I can verify it, and whether it matches. Flag anything you cannot trace to a source as UNVERIFIED, and do not build conclusions on unverified numbers. If a figure disagrees with its source, say so plainly and use the source's number.
Why it helps
An agent will happily summarize a report that summarized another summary, and numbers quietly drift at every hop — a count becomes a claim, a claim becomes a decision. This prompt breaks the chain: every figure either traces to something real or gets labeled unverified before it can steer you. It takes two minutes and prevents the most expensive kind of error — the confident one you acted on.
2Show Your Work
When: Any time an agent does research or reports findings "from the web."
For every claim in your research, show your work: attach the source — a link, a document name, or the exact search you ran. Label each claim VERIFIED if you saw it in the source yourself, or INFERRED if you reasoned your way to it.
If you cannot source a claim, go find the source or delete the claim. End with a short list titled "What I could not verify" — I would rather see the gaps than discover them later.
Why it helps
The classic agent failure is a fluent summary of nothing — plausible, well-formatted, and sourced from vibes. Forcing a label on every claim changes the agent's behavior while it works, not just how it reports: it reads more carefully because it knows each line has to carry a receipt. The "could not verify" list is the most valuable part. An agent that shows you its gaps is one you can actually delegate to.
3Devil's Advocate, With Receipts
When: Before committing to a plan you already like.
Argue against this plan as hard as the evidence allows:
[paste the plan]
Use only specific evidence — data, precedents, documented failures — not general caution. For each objection, name the evidence behind it. Then tell me: what evidence, if it existed, would change your verdict?
Close with your honest call — proceed, proceed with changes, or stop — and the single strongest reason.
Why it helps
Ask an agent "is this a good idea?" and you'll get supportive mush, because agreement is its default setting. This prompt changes the job: dissent is now the assignment, and it has to be built from evidence rather than tone. The second half matters just as much — naming what would change the verdict turns an argument into a test. You find the hole in the plan while it's still cheap to fix.
4The Pre-Send Check
When: Before any email, message, or post leaves the building.
Stop before sending. Run this checklist on the message and show me the result, line by line:
1. Every name is spelled exactly the way that person or company spells it.
2. Every number, date, and price matches its source.
3. Every link opens, and goes where the text says it goes.
4. Every claim in the message traces to something we actually know — nothing invented, nothing rounded into a promise.
5. Nothing is included that this recipient does not need.
Fix anything that fails and show me the corrected draft before it goes out.
Why it helps
A sent message is the one output you can't edit. One wrong name, one stale price, one link to the wrong page can cost more than everything the agent saved you that week — and these are exactly the errors a fast draft breeds. Making the agent run a visible checklist slows it down at the only moment slowness is free. If it can't show the check, the message isn't ready.
Delegate & direct
Vague asks get vague work. These three prompts turn "can you handle this?" into assignments an agent can execute — and you can judge.
5The Delegation Brief
When: Handing an agent any task that matters more than a quick answer.
Before you start, turn my request into a brief and confirm it back to me:
WHAT — the exact deliverable, in one sentence.
HOW — the method you'll use, and any example of mine you should follow.
WHEN — the deadline, or the checkpoint where you'll report progress.
WHY — the reason this matters, so you can judge trade-offs I didn't specify.
GATE — how you'll prove it's done: a link, a file, a number, or a check I can run myself.
If any part is unclear, ask before you start, not after. And don't call it done until the gate passes — show me the proof, not just the claim.
Why it helps
Most bad agent output is a bad brief wearing a costume. The what/how/when/why structure forces the gaps into the open while they're still free to fix, and the "why" is the quiet superpower — an agent that knows the purpose can make a hundred small decisions the way you would. The gate ends the other classic failure: work declared "done" that nobody verified. If there is no gate, there is no done.
6Scope Before You Start
When: Starting anything big, ambiguous, or hard to undo.
Before you begin, restate this job in your own words: the goal, the exact deliverable, the constraints, and — just as important — what you will NOT do.
List every assumption you're making. If my request could reasonably be read two ways, show me both readings and tell me which one you're taking.
Then wait for my "go" before starting anything that would be hard to undo.
Why it helps
The most expensive agent failure isn't sloppiness — it's a flawless job on the wrong task. Newer users phrase requests loosely because they're still thinking out loud, and agents charge ahead because charging ahead is the default. Thirty seconds of restatement catches the misreading while it's still a sentence, not a rebuild. It also teaches you something valuable: how your agent actually hears you.
7Options, Not Essays
When: You need a decision made, not a topic explained.
I need a decision, not a report. Give me 2–3 real options for this:
[describe the decision]
For each option: what it is in one line, what it costs in time, money, and effort, what it risks, and what it makes possible.
End with your recommendation and the reason, in one or two sentences. If you need something from me to narrow it down, ask for exactly that — and nothing else.
Why it helps
Left alone, agents answer decisions with essays — thorough, balanced, and impossible to act on at a glance. This prompt changes the output shape: a small set of real choices, each carrying its price and its risk, plus a recommendation the agent has to stand behind. You stop doing homework and start deciding, which is the job only you can do. It also exposes fake options fast — an agent that can't name a second real option is telling you something.
Stay oriented
Long sessions fragment. Work piles up across chats, days, and half-finished threads. These two prompts keep the whole board — and the agent's memory of it — in one place.
8Explain What's Going On
When: You come back to a pile of active work and can't see the whole picture.
Give me the whole board in one message. Cover every active thread of work: what it is, its current status — based on evidence, not impressions — what's blocked and who it's blocked on, and what needs a decision from me.
Order it by what matters most. Keep each item to two or three lines. Put everything waiting on me in its own list at the end.
If something has quietly stalled, say so. A clean "nothing is waiting on you" is a fine answer if it's true.
Why it helps
Agent work multiplies quietly: three sessions, five threads, two things blocked on a reply you forgot you owed. Asking thread-by-thread gets you five confident status reports and no picture. This prompt forces a synthesis — one board, ranked, with the decision queue separated out. The "quietly stalled" line matters most: it's permission for the agent to surface bad news, which it will not volunteer on its own.
9Write It to Memory
When: At the end of any session where something was decided, learned, or left open.
Before we finish, write today's durable facts into our persistent notes: decisions we made and why, preferences I expressed, figures we'll need again, and open loops — each with its next step and who owns it.
Then read back what you saved, so I can confirm it landed.
Next session, read those notes before we start, and tell me anything in them that changes how you'd approach my first request.
Why it helps
An agent with no memory makes you the memory — re-explaining preferences, re-litigating settled decisions, re-discovering open loops. Writing facts down at the end of a session, and reading them back at the start of the next one, is the whole difference between an assistant and a colleague. The read-back step is not ceremony: it's how you catch the note that got saved wrong before it steers a week of work.
Measure & improve
Activity feels like progress. These three prompts measure what the activity bought, and convert each day's result — good or bad — into a permanent upgrade.
10The Counter-Read
When: Reviewing results from anything that consumed real hours, money, or attempts.
Report the results as rates, not just totals. For each effort, give me three numbers: the output (what we got), the input (hours, dollars, or attempts it consumed), and the rate between them — output per hour, per dollar, or per attempt.
Compare the rates across efforts, not the raw totals. End with a verdict for each one — scale, keep, or kill — based on the rate, and name the evidence behind each verdict.
Why it helps
Totals flatter whatever got the most effort. The channel with the biggest numbers usually just had the biggest budget of hours behind it. Rates tell the truth: what each hour actually bought, which is the only fair way to decide what gets more hours next week. This one prompt quietly upgrades every planning conversation after it, because "what's our rate?" becomes the question nobody can dodge with a big total.
11One Percent Better
When: Closing out a workday or a finished project.
Run today's debrief. Answer three things:
1. What did we learn today that we didn't know this morning — from results, not from activity?
2. What single change to our playbook follows from it?
3. Write that change into the playbook as a dated rule, so future work inherits it automatically.
One change only — the one with the most leverage. Show me the exact wording you added.
Why it helps
Compounding doesn't live in the doing; it lives in the debrief. Most agent sessions end with a summary that evaporates, so the same lessons get re-learned at full price. Forcing one dated rule into a written playbook turns each day into a small permanent upgrade — and limiting it to one change keeps the playbook a tool instead of a diary. A month of this is a different operation than the one you started with.
12The Failure Autopsy
When: Something went wrong — a bad send, a wrong number, a broken deliverable.
Something went wrong: [describe what happened]. Don't apologize — dissect it.
1. The root cause, in one sentence, with the evidence that separates it from other explanations.
2. The earliest moment we could have caught it — and with what check.
3. The rule or step we add so this exact failure can't happen the same way twice.
Write that rule into our notes and show me the exact wording.
Why it helps
Agents are trained to be agreeable, so failure usually buys you an apology and, later, a repeat performance. An autopsy refuses both. Naming the root cause with evidence stops the fix from landing on the wrong thing, and finding the earliest catch point shows you where your process is blind — which is almost never where the failure became visible. The output isn't blame; it's one more rule your future work runs on.
We publish research and tools like this for people who run things — businesses, teams, and now agents. The Lead Lab newsletter is where the new ones land first.