title: Plan Before Acting

description: Force an explicit plan before an agent touches anything.

content:
Before you make any change for this task: {{task}}

First produce a plan: the concrete steps in order, the files/systems each will touch, the risks, and how you'll verify success at the end. Do NOT make changes yet. Identify anything you're unsure about and ask me. Wait for my approval of the plan before executing.

task

description: The task to plan


title: Decompose into Subtasks

description: Break a large task into independent, parallelizable units.

content:
Break this large task into subtasks: {{task}}

For each subtask: a clear definition of done, its dependencies on other subtasks, and whether it can run in parallel. Identify which subtasks are on the critical path and which are independent. Produce a dependency-ordered plan. Flag any subtask that's underspecified and needs clarification before work starts.

description: The large task to decompose


title: Verify Your Own Work

description: Make an agent adversarially check what it just produced.

content:
You just completed: {{work}}

Now adversarially verify it before declaring done. Re-read the original requirements and check each one is actually met. Look for: edge cases you skipped, claims you didn't test, and places you assumed instead of confirming. Actually run/check rather than asserting it works. Report what you verified, what you couldn't, and any issue you found — don't just say 'looks good'.

work

description: What you just did


title: Explore Then Decide

description: Gather evidence from the codebase before proposing a change.

content:
For this task: {{task}}

First explore and gather facts — find the relevant files, existing patterns, and constraints. Report what you found before proposing anything. Ground every recommendation in something you actually observed in the code, not in assumptions. Then propose an approach that fits the existing conventions. If the codebase contradicts my framing of the task, tell me.

task

description: The task to ground


title: Define Done and Stop

description: Set explicit completion criteria so an agent doesn't over- or under-do it.

content:
Task: {{task}}

Before starting, state your completion criteria: exactly what 'done' means for this, and what is explicitly out of scope. Do the task to meet those criteria — no more (don't gold-plate or wander into adjacent improvements) and no less. When finished, confirm each criterion is met and then stop. If you discover the scope is wrong mid-task, surface it instead of silently expanding.

description: The task with a defined scope


title: Delegate to a Subagent

description: Write a crisp brief for handing work to another agent.

content:
I want to delegate this to a subagent: {{task}}

Write the brief you'd hand off: the goal, the context the subagent needs (it has none of ours), the exact deliverable and format, the constraints/guardrails, and how its output will be judged. Make it self-contained — assume the subagent can't ask follow-ups. Flag the one instruction most likely to be misinterpreted and make it unambiguous.

description: What to delegate


title: Recover From a Stuck State

description: Get an agent unstuck without thrashing.

content:
I'm stuck on: {{situation}}

I've already tried: {{attempts}}

Stop repeating approaches. Step back: restate the actual goal, question an assumption that might be wrong, and consider whether the problem is even framed correctly. Propose two genuinely different approaches, not variations of what failed. If I'm missing information that would unblock this, tell me exactly what to find.

situation

description: What you're stuck on

attempts

description: What you've already tried


title: Summarize Progress and Next Steps

description: Produce a handoff-ready status of an in-flight task.

content:
Summarize the current state of this work: {{work}}

Produce a handoff a fresh agent (or future me) could pick up cold: what's done and verified, what's in progress, what's left, the key decisions made and why, and the immediate next action. Note any landmine — a thing that looks done but isn't, or a constraint that isn't obvious from the code. Keep it tight and factual.

work

description: The work in progress


title: Decompose a Goal into Agent Tasks

description: Break a goal into tasks an agent fleet can execute.

content:
Decompose this goal into agent-executable tasks: {{goal}}

Produce a task list where each task has a single clear outcome, the inputs it needs, and how its result is verified. Mark which tasks are independent (parallelizable) and which depend on others, and name the dependency. Identify the task most likely to fail or need a human, and put a checkpoint there. Keep tasks small enough to verify but large enough to be worth a separate context.

goal

description: The goal to decompose


title: Design a Verification Loop

description: Make an agent check its own work before declaring done.

content:
My agent does this task: {{task}}

Design a verification loop so it can't declare success while wrong. Define the concrete check that proves the work (a test, a diff, a re-read, an independent recompute), what counts as pass versus fail, and what the agent does on fail (retry, narrow, escalate). Make the check independent of the thing being checked so a confident-but-wrong agent still trips it. Cap the retries and define the give-up signal.

task

description: What the agent does


title: Write a Tool-Use Policy

description: Tell an agent which tool to reach for and when.

content:
My agent has these tools: {{tools}}

Write a concise policy guiding when to use each, and just as importantly when NOT to. Resolve the overlaps (which tool wins when two could work), the ordering (cheap and safe checks before expensive or destructive actions), and the actions that require confirmation. State the default when no tool clearly fits. Keep it short enough to live in a system prompt and unambiguous enough to actually follow.

tools

description: The tools available


title: Plan a Multi-Agent Fan-out

description: Decide how to split work across parallel agents.

content:
I want to parallelize this work across agents: {{work}}

Design the fan-out. Decide the unit of work each agent owns, how to keep them from conflicting (isolation, partitioning, or a shared queue), and how their outputs are merged. Decide whether a barrier is needed or work can stream. Identify the step that must stay sequential and why. Flag the failure mode where one agent's bad output poisons the merge, and how to catch it.

work

description: The work to parallelize


title: Design a Retry and Backoff Policy

description: Decide how an agent or system retries failures.

content:
This step can fail transiently: {{operation}}

Design its retry policy. Decide what is worth retrying (transient: timeouts, rate limits, 5xx) versus what must NOT be retried (deterministic failures, non-idempotent writes without a guard). Specify the backoff (exponential + jitter), the max attempts, and the give-up behavior. Ensure retries can't duplicate side effects. Flag the failure mode where blind retries amplify an outage (retry storms) and how to avoid it.

operation

description: The operation that can fail


title: Write a Guardrail Policy

description: Tell an agent what it must never do, and when to stop.

content:
My agent does: {{task}}

Write the guardrails. Define the hard limits — actions it must never take, data it must never touch, and the spend or scope ceiling. Specify what requires human confirmation versus what it can do autonomously, and the signals that mean stop and escalate (repeated failures, uncertainty, irreversibility). Make the rules concrete enough to follow and short enough to live in a system prompt. Flag the gap an adversarial input would exploit.

task

description: What the agent does


title: Plan Checkpointing and Resume

description: Let a long agent task survive interruption.

content:
This long-running agent task needs to survive interruption: {{task}}

Design checkpointing. Decide what state must be persisted to resume correctly (progress, partial results, position in the work) and what can be recomputed. Pick the checkpoint points — frequent enough to limit lost work, not so frequent they dominate cost. Make resume idempotent so a crash mid-step doesn't double-apply. Flag the state that is easy to forget and would make a resumed run silently wrong.

description: The long-running task


title: Budget an Agent's Resources

description: Cap iterations, tokens, and cost so an agent can't run away.

content:
I want to bound the resource use of an agent doing: {{task}}

Set the budgets: max iterations, token and cost ceilings, wall-clock timeout, and tool-call limits. For each, the value that allows real work but stops a runaway loop, and what should happen at the limit (stop, summarize and hand off, or ask to extend). Decide whether limits are hard stops or negotiable. Flag the loop shape most likely to burn the budget without progress, and how to detect it early.

description: What the agent does