{"title":"Plan Before Acting","description":"Force an explicit plan before an agent touches anything.","tags":["planning","agent","safety"],"content":"Before you make any change for this task: {{task}}\n\nFirst 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.","variables":[{"name":"task","description":"The task to plan","required":true}]}
{"title":"Decompose into Subtasks","description":"Break a large task into independent, parallelizable units.","tags":["decomposition","parallel","orchestration"],"content":"Break this large task into subtasks: {{task}}\n\nFor 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.","variables":[{"name":"task","description":"The large task to decompose","required":true}]}
{"title":"Verify Your Own Work","description":"Make an agent adversarially check what it just produced.","tags":["verification","self-check","quality"],"content":"You just completed: {{work}}\n\nNow 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'.","variables":[{"name":"work","description":"What you just did","required":true}]}
{"title":"Explore Then Decide","description":"Gather evidence from the codebase before proposing a change.","tags":["exploration","grounding","agent"],"content":"For this task: {{task}}\n\nFirst 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.","variables":[{"name":"task","description":"The task to ground","required":true}]}
{"title":"Define Done and Stop","description":"Set explicit completion criteria so an agent doesn't over- or under-do it.","tags":["completion","scope","control"],"content":"Task: {{task}}\n\nBefore 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.","variables":[{"name":"task","description":"The task with a defined scope","required":true}]}
{"title":"Delegate to a Subagent","description":"Write a crisp brief for handing work to another agent.","tags":["delegation","multi-agent","handoff"],"content":"I want to delegate this to a subagent: {{task}}\n\nWrite 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.","variables":[{"name":"task","description":"What to delegate","required":true}]}
{"title":"Recover From a Stuck State","description":"Get an agent unstuck without thrashing.","tags":["recovery","debugging","agent"],"content":"I'm stuck on: {{situation}}\n\nI've already tried: {{attempts}}\n\nStop 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.","variables":[{"name":"situation","description":"What you're stuck on","required":true},{"name":"attempts","description":"What you've already tried","required":true}]}
{"title":"Summarize Progress and Next Steps","description":"Produce a handoff-ready status of an in-flight task.","tags":["status","handoff","continuity"],"content":"Summarize the current state of this work: {{work}}\n\nProduce 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.","variables":[{"name":"work","description":"The work in progress","required":true}]}
{"title":"Decompose a Goal into Agent Tasks","description":"Break a goal into tasks an agent fleet can execute.","tags":["decomposition","planning","multi-agent"],"content":"Decompose this goal into agent-executable tasks: {{goal}}\n\nProduce 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.","variables":[{"name":"goal","description":"The goal to decompose","required":true}]}
{"title":"Design a Verification Loop","description":"Make an agent check its own work before declaring done.","tags":["verification","self-check","reliability"],"content":"My agent does this task: {{task}}\n\nDesign 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.","variables":[{"name":"task","description":"What the agent does","required":true}]}
{"title":"Write a Tool-Use Policy","description":"Tell an agent which tool to reach for and when.","tags":["tool-use","policy"],"content":"My agent has these tools: {{tools}}\n\nWrite 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.","variables":[{"name":"tools","description":"The tools available","required":true}]}
{"title":"Plan a Multi-Agent Fan-out","description":"Decide how to split work across parallel agents.","tags":["multi-agent","parallelism","orchestration"],"content":"I want to parallelize this work across agents: {{work}}\n\nDesign 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.","variables":[{"name":"work","description":"The work to parallelize","required":true}]}
{"title":"Design a Retry and Backoff Policy","description":"Decide how an agent or system retries failures.","tags":["retry","backoff","resilience"],"content":"This step can fail transiently: {{operation}}\n\nDesign 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.","variables":[{"name":"operation","description":"The operation that can fail","required":true}]}
{"title":"Write a Guardrail Policy","description":"Tell an agent what it must never do, and when to stop.","tags":["guardrails","safety","policy"],"content":"My agent does: {{task}}\n\nWrite 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.","variables":[{"name":"task","description":"What the agent does","required":true}]}
{"title":"Plan Checkpointing and Resume","description":"Let a long agent task survive interruption.","tags":["checkpoint","resume","durability"],"content":"This long-running agent task needs to survive interruption: {{task}}\n\nDesign 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.","variables":[{"name":"task","description":"The long-running task","required":true}]}
{"title":"Budget an Agent's Resources","description":"Cap iterations, tokens, and cost so an agent can't run away.","tags":["budget","limits","cost"],"content":"I want to bound the resource use of an agent doing: {{task}}\n\nSet 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.","variables":[{"name":"task","description":"What the agent does","required":true}]}