title: Improve My Prompt

description: Critique and rewrite a prompt to get better results.

content:
Improve this prompt:

{{prompt}}

Diagnose what's weak: vague instructions, missing context, no output format, ambiguous success criteria, or conflicting asks. Then rewrite it to be specific, well-structured, and unambiguous. Explain the key changes so I learn the pattern. Keep my intent intact — sharpen it, don't replace it.

prompt

description: The prompt to improve


title: Turn a Vague Request into a Spec

description: Convert a fuzzy ask into a precise, answerable prompt.

content:
I want to ask an AI to: {{vague_request}}

Help me turn this into a precise prompt. Identify what's underspecified — the missing inputs, constraints, format, and success criteria — and ask me the 2-4 questions whose answers matter most. Then assemble a clear, complete prompt from my answers. Don't pad it with boilerplate the model doesn't need.

description: Your rough idea of what you want


title: Design a Role Prompt

description: Write an effective system/role prompt for a recurring task.

content:
I want an AI to reliably act as: {{role}}

For this kind of task: {{task_type}}

Write a system/role prompt that sets the right expertise, behavior, output style, and boundaries. Make it specific enough to change behavior but not so rigid it breaks on variation. Include what the role should refuse or escalate. Explain each instruction's purpose so I can tune it.

role

description: The role the AI should play

description: The kind of task it's for


title: Add Few-Shot Examples

description: Design examples that steer model output by demonstration.

content:
I want consistent output for this task: {{task}}

Help me design few-shot examples. Pick examples that cover the range of cases (including a tricky one and an edge case), show the exact input-to-output mapping I want, and demonstrate the format and tone implicitly. Tell me how many examples are worth including and why more wouldn't help. Warn me about any example that might bias the model the wrong way.

task

description: The task you want consistent output for


title: Specify an Output Format

description: Pin down a structured output the prompt should produce.

content:
I need this AI output in a reliable, structured format: {{what}}

Help me specify it precisely: the exact schema/shape, field types and which are required, how to handle missing or uncertain values, and what to do when the input doesn't fit. Give the format instruction to paste into my prompt, plus one filled example. Note the failure mode most likely to break downstream parsing and how to guard against it.

what

description: What output you need structured


title: Debug a Bad AI Response

description: Figure out why a prompt gave a poor answer and fix it.

content:
I gave this prompt:

{{prompt}}

And got this unsatisfactory response:

{{response}}

Diagnose why: was the instruction ambiguous, was context missing, did it ignore a constraint, or did I ask for too much at once? Pinpoint the cause and rewrite the prompt to fix it. Tell me which single change would most improve the result.

prompt

description: The prompt you used

response

description: The disappointing response


title: Decompose a Complex Prompt

description: Split an overloaded prompt into a reliable sequence of steps.

content:
This prompt tries to do too much at once: {{prompt}}

Help me decompose it into a sequence (or chain) of smaller prompts, each doing one thing well, where each step's output feeds the next. Show the steps and what flows between them. Tell me which steps genuinely need separate calls versus which can stay together. Aim for reliability over cleverness.

prompt

description: The overloaded prompt


title: Write Reusable Prompt Template

description: Generalize a one-off prompt into a parameterized template.

content:
I keep writing variations of this prompt: {{example}}

Help me turn it into a reusable template with clear {{double-brace}} placeholders for the parts that change. Identify which pieces should be variables, give each a short description and a sensible default where one exists, and keep the fixed scaffolding strong. Show the template and one filled-in example so I can confirm it generalizes correctly.

example

description: An example of the prompt you keep rewriting


title: Critique and Improve a Prompt

description: Diagnose why a prompt underperforms and fix it.

content:
Critique and improve this prompt:

{{prompt}}

Diagnose its weaknesses: ambiguity, missing context, conflicting instructions, no success criteria, or an unclear output format. Rewrite it to fix the biggest problems, and explain each change so I learn the principle, not just the patch. Keep it as short as it can be while still being unambiguous. If the prompt is asking for the wrong thing entirely, say so.

prompt

description: The prompt to improve


title: Reduce a Prompt's Token Cost

description: Cut a prompt's token footprint without losing quality.

content:
This prompt works but is expensive to run at scale:

{{prompt}}

Cut its token cost without degrading output quality. Find the redundant instructions, the verbose examples that could be trimmed or dropped, and the context that could be referenced instead of inlined. Distinguish words that actually steer the model from filler that just feels thorough. Show the leaner version, estimate the rough token saving, and flag any cut that's risky enough to A/B before trusting.

description: The prompt to slim down


title: Convert Instructions to a System Prompt

description: Turn ad-hoc guidance into a reusable system prompt.

content:
Turn these instructions into a clean system prompt:

{{instructions}}

Separate the durable role and rules (system) from the per-request input (user). Resolve contradictions, order the rules by priority, and state how to handle conflicts and unknowns. Define the output contract. Remove anything that belongs in the user turn instead. Make it general enough to reuse across requests but specific enough to actually constrain behavior.

instructions

description: The ad-hoc instructions


title: Make a Prompt Robust to Edge Cases

description: Harden a prompt against the inputs that break it.

content:
This prompt works on normal input but I worry about edge cases:

{{prompt}}

List the inputs likely to break it: empty, huge, malformed, adversarial, ambiguous, or out-of-scope. For each, define the desired behavior (handle, clarify, or refuse) and add the instruction that produces it. Make sure the hardening doesn't degrade the common case. End with the one input you'd test first to know it's robust.

prompt

description: The prompt to harden


title: Write a Chain-of-Thought Prompt

description: Get a model to reason step by step before answering.

content:
I want the model to reason carefully before answering: {{task}}

Write a prompt that elicits explicit step-by-step reasoning where it actually helps (multi-step logic, math, planning) — and tell me where it just wastes tokens. Specify the structure: think first, then give a clearly separated final answer the caller can extract. Avoid letting the reasoning leak into or contaminate the final output. Note how to keep the answer parseable when you also want the reasoning visible.

task

description: The task that needs reasoning


title: Design an Evaluation Rubric

description: Define how to judge whether an AI output is good.

content:
I need to judge outputs for this task: {{task}}

Design a rubric. List the dimensions that actually matter (correctness, completeness, format, tone, safety), each with concrete pass/fail or scored criteria a second person would apply the same way. Separate must-haves from nice-to-haves. Include an example of a passing and a failing output. Make it usable both for human review and as an LLM-as-judge prompt. Flag any criterion too vague to score consistently.

description: The task whose outputs you judge


title: Reduce Hallucination

description: Make a prompt ground its answers and admit uncertainty.

content:
This prompt sometimes makes things up:

{{prompt}}

Harden it against hallucination. Add instructions to ground answers in the provided context, to say I don't know rather than guess, and to cite or quote the source for factual claims where possible. Decide what the model should do when the context doesn't contain the answer. Distinguish tasks where invention is the bug from creative tasks where it is the point. Keep the prompt from becoming so cautious it refuses easy questions.

prompt

description: The prompt that hallucinates


title: Add a Self-Critique Step

description: Have the model check its own output before finishing.

content:
I want the model to catch its own mistakes on: {{task}}

Add a self-critique step: after a first answer, have it review against explicit criteria (correctness, missed requirements, edge cases) and revise if needed. Specify what to check for — vague self-review does nothing. Decide whether the critique is shown or internal, and cap the loop so it doesn't second-guess forever. Tell me when self-critique genuinely helps versus when an independent check would catch more.

task

description: The task to self-check