Optimize any prompt into a reliable one
FreePaste any draft prompt and get a short diagnosis of what's weak plus a rewritten, copy-ready version with a clear contract, single-owner rules, and an explicit output format.
A cleaned-up, copy-ready version of your prompt that produces consistent output every run, plus a short list of exactly what was wrong and the single biggest fix.
This prompt
You are a prompt engineer who rewrites weak prompts into precise, reliable ones.
Rewrite the prompt below so it reliably produces its intended result. Success = a reader (human or model) could follow it with no guesswork — the goal, inputs, output shape, and limits are all explicit, every line changes the output, and no two lines fight each other.
The prompt to optimize:
<draft>
{{draft_prompt}}
</draft>
What this prompt is meant to achieve (may be blank):
<goal>
{{goal}}
</goal>
Do this:
1. Recover the contract. From the draft (and the goal, if given) pull out five things: the objective, the inputs it receives, the exact output shape it must return, what "good" looks like, and any hard limits. Where one is missing or only implied, choose the most reasonable version and note it as an assumption.
2. Diagnose. List the concrete problems you find, such as: filler that never changes the output, a rule stated in two places or two rules that conflict, no stated output format, instructions blended into the data, long lists of "don't" in place of a clear "do", or a request for hidden step-by-step reasoning.
3. Rewrite in this order — role, then the task as an action verb plus a success criterion, then the context, then the working steps as a numbered list, then the exact output format, then the constraints last. Keep every line causal: if deleting it changes nothing, cut it. Give each rule one owner and state it once. Phrase rules as what to do. Fence any pasted data or examples inside delimiters. Add a short worked example only when the output shape can't be conveyed in words. Where a wrong answer could be invented, allow "I don't know" as a valid response.
Return exactly this:
**Diagnosis** — 2-6 bullets naming the issues you found (if the draft is already strong, say so and name why).
**Optimized prompt** — the full rewrite inside a fenced code block, ready to copy.
**What changed** — one sentence naming the biggest fix.
Constraints:
- Preserve the author's intent, domain terms, and any real requirement — sharpen the wording, do not invent new requirements.
- Keep the rewrite model-agnostic: no vendor-specific tricks, no "you must" shouting, and do not hard-require "think step by step".
- If the goal is unclear and none was supplied, ask one clarifying question instead of guessing.2 fields still empty — the {{like_this}} slots fill in as you type.
See it in action
What this prompt produces with example details filled in:
**Diagnosis**
- No output format or length target: "not too long" and "make it good" are unmeasurable, so results drift run to run.
- The review is pasted inline as `[review here]`, mixed into the instructions, so the model can't cleanly tell the task from the content.
- Vague, competing style rules ("professional but also friendly", "don't be boring") have no owner and pull in different directions.
- Sentiment is requested but its allowed values aren't defined — "happy or not" is binary, yet real reviews are often mixed.
- Several "don't" rules collapse into one positive instruction ("summarize only what the review states").
**Optimized prompt**
```
You are a support-triage assistant.
Summarize one customer review and label its sentiment so a support agent can triage it in under 10 seconds. Success = the summary captures the review's main point and any specific issue, and the label matches the reviewer's actual tone.
The review:
"""
{{review}}
"""
Steps:
1. Write a 1-2 sentence summary using only facts stated in the review — the product or feature involved and the specific problem or praise.
2. Assign one sentiment label: Positive, Negative, or Mixed.
3. If the review names a concrete issue to act on, capture it in a few words; otherwise write "none".
Return JSON only:
{
"summary": "...",
"sentiment": "Positive | Negative | Mixed",
"action_item": "..."
}
Constraints:
- Include nothing that isn't in the review; if it's too vague to summarize, set "summary" to "unclear".
- Keep the summary under 40 words.
```
**What changed** — Replaced the "make it good / not too long" guesswork with a measurable contract: a fixed JSON output, a defined 3-value sentiment label, delimited input, and a hard length cap.Tips
- Paste the whole prompt — include the system message and any examples — so nothing that shapes the output stays hidden from the optimizer.
- Fill in the goal slot whenever your prompt's purpose isn't obvious from its text; it stops the optimizer from guessing what 'good' means.
- Run the optimized version and your original on the same input, compare side by side, and keep whichever wins.
- Re-run this on the rewrite once more — a second pass often catches a leftover vague rule or missing output detail.
Built by Web Innoventix
Want the work done, not just prompted? We design, build and rank websites that get found on Google and cited by AI.
Get a free quoteMore prompts
Browse all →Red-team your prompt for safety, bias & security before you ship it
Paste any prompt and get a dimension-by-dimension safety, bias, privacy, and injection review, plus a safer rewrite and three validation tests you can run before it goes live.
Interview me, then write a production system prompt for my AI agent
A paste-and-go ChatGPT prompt that interviews you about your AI agent, then writes a complete, production-ready system prompt for it — with the design rationale and test cases to prove it works.
Design my RAG pipeline: chunking, embeddings, and retrieval plan
An interview-style AI prompt that questions you about your documents, your users, and your constraints, then delivers a complete, buildable RAG pipeline plan — chunking strategy, embedding model, retrieval, reranking, and evaluation.
Turn my plain-English question into a runnable SQL query
A paste-and-go ChatGPT prompt that turns any plain-English question into a correct, read-only SQL query for your exact database: it learns your schema and dialect, clears up ambiguous wording, then hands you a runnable query with every assumption spelled out.
Give me a data-analysis plan from my dataset and business question
A paste-and-go prompt that interviews you about your dataset and business question, then writes an execution-ready data-analysis plan — with the right method, the data-quality checks to run first, and the traps to avoid.
Build a few-shot example set that teaches the model my task
A paste-and-go prompt that interviews you about your task, then creates a curated set of few-shot examples — balanced, edge-case-covered, and ready to paste above your real inputs — that teaches a model to do the task reliably.