>Promptwright
Prompt linter & rewriter

Your prompt is fine. It's just missing nine things.

Paste the prompt you're about to send. Promptwright scores it on the nine things models actually need, flags what's contradictory or dangling, tells you what's missing and why it matters, then rewrites it in the shape your target model was documented to prefer — XML sections for Claude, developer-message structure for GPT, few-shot-first for Gemini, lean and conversational for Grok.

Free, no signup, and your prompt never leaves your browser
Target model — changes the rewrite, not the score
18 wordsscores as you type
Try:
How the score works

Nine weighted channels, scored by looking for the linguistic markers of each in your text — a role statement, an imperative task verb, stated purpose, a named audience, a format, a length bound, exclusions, worked examples, and a definition of done. The weights shift with the task type. Hedge words like good and engaging count against specificity; concrete particulars like versions and measurements count for it.

Separately it flags four things that are present and wrong: contradictory instructions, references to content you didn't paste, four or more unrelated asks in one prompt, and unbounded lists.

14
PROMPT SCORE
Mostly guesswork for the model

Almost every decision has been left open. Expect an answer aimed at the average user, not you. Hedge words found: good, engaging.

Output formatw18.2
40
Task specificityw16
20
Context & purposew15
35
Audiencew13.5
0
Constraintsw12
0
Examplesw10.4
0
Role & expertisew10
0
Length & scopew9
0
Definition of donew7.2
0

Missing 9

Who is this blog post for?
Reading level and assumed knowledge change almost every sentence. Unsaid, the model aims at a general reader — which is usually nobody.
Replace the hedge words with measurable ones
Words like <code>good</code> and <code>engaging</code> make the model guess your taste. Name the observable property instead. You used: good, engaging.
Name what would make the blog post wrong
The two or three things you already know you don't want. Cheapest tokens in the prompt, and they prevent the most rework.
You asked for a blog post but not what it should look like
Name the structure: headings, numbered steps, a table, a word count. Without it you get whatever shape that model defaults to this month.
Show one worked example
Examples steer format and tone more reliably than any description of them. One good pair beats a paragraph of instructions.
Name the expertise you want
A single role sentence shifts vocabulary, depth and what gets assumed. Without one you get a generalist answer.
Say why you need this
Stated purpose is the highest-leverage addition in every vendor's guidance — it lets the model generalise to decisions you didn't anticipate.
No length on the blog post
“Blog post” means 200 words to one model and 2,000 to another. A number removes the guess entirely.
Define what a correct answer looks like
Without a definition of done, neither you nor the model can tell a good attempt from a bad one — and you can't A/B two prompts.

Revised prompt — Claude

────── SYSTEM PROMPT ──────
You are ⟦ seniority + discipline ⟧. ⟦ one line on the standard you hold yourself to ⟧

────── USER MESSAGE ──────
<context>
⟦ what you're working on and why this output matters ⟧
Audience: ⟦ who reads this and what they already know ⟧
</context>

<task>
write me a good blog post about AI for my company website, make it engaging and SEO friendly
</task>

<constraints>
- ⟦ the failure mode you most want to avoid ⟧
</constraints>

<examples>
<example>
Input: ⟦ a short, realistic input ⟧
Output: ⟦ the ideal output, written exactly as you want it ⟧
</example>
<!-- 3-5 diverse examples work best; add two more covering edge cases -->
</examples>

<output_format>
⟦ table / numbered list / JSON schema — and a length bound ⟧
</output_format>

<success_criteria>
⟦ the observable test that makes this answer correct ⟧
</success_criteria>

Go beyond the minimum the task strictly requires. If anything above is ambiguous, ask me before you start.
→Wrapped each part in its own XML tag — the structure Anthropic's guide recommends when a prompt mixes instructions, context and examples.
→Moved the role into a separate system prompt and left per-request detail in the user turn.
→Added an explicit 'go beyond the minimum', because Claude reads scope literally.
→Left a comment to grow the example set to 3–5 diverse cases.

The same instruction, five different shapes

Every vendor publishes its own prompting guidance, and the advice genuinely conflicts on structure. Promptwright keeps one profile per model family and reshapes your prompt to match it.

Claude

Anthropic · documented
  • XML section tags. Wrapping instructions, context and examples in their own tags is the house style and reduces misreading on long prompts.
  • Say why, not just what. Giving the motivation behind a rule lets it generalise instead of following the rule literally.
  • 3–5 examples in <example> tags. Diverse ones, so it doesn't latch onto an accidental pattern.
  • Role in the system prompt. One sentence measurably shifts tone and focus.
  • Ask for more than the minimum. It follows scope literally, so 'go beyond the basics' has to be stated.
<role> · <context> · <task> · <constraints> · <examples> · <output_format> · <success_criteria>

GPT

OpenAI · documented
  • Developer message carries the rules. Instructions there outrank anything in the user turn.
  • Markdown headers for sections, XML for quoted material. The docs recommend both together, each for a different job.
  • Context goes last. It changes per request, so it sits at the end of the message.
  • Spell out the logic. Non-reasoning models need explicit steps; reasoning models do better with the goal and room to work.
  • JSON schema for anything machine-read. Structured outputs instead of 'return JSON'.
DEVELOPER: # Identity · # Instructions · # Output format · # Examples — USER: # Context (<reference>) · # Request

Gemini

Google · documented
  • Always include few-shot examples. The guidance treats them as standard, not optional, and says clear examples can replace written instructions.
  • Keep example formatting identical. The format is learned from the examples, so inconsistency between them leaks into the output.
  • Output prefixes work. Start the answer yourself and let it continue the pattern.
  • Constraints stated as do and don't. Including an explicit length bound.
  • Split complex asks. One instruction per prompt, chained, rather than one prompt doing five things.
TASK · CONTEXT · EXAMPLES (uniform) · CONSTRAINTS · OUTPUT FORMAT · output prefix

Grok

xAI · community
  • Conversational beats scaffolded. Community guidance is consistent that heavy XML scaffolding works against it.
  • Lean system prompt. Persona, mode and output format in a few lines; length is reported to cost more than it buys.
  • System instructions carry weight. Reported to outrank conflicting user text, so put the non-negotiables there.
  • Anchor anything time-sensitive. Live-data answers need an explicit date and scope.
  • Be blunt. Directness reportedly lands better than formal register.
One tight persona line, the ask in plain prose, then a short must-have list

Open weights

Llama · Mistral · Qwen · community
  • Rigid, repetitive structure. Fixed ### headers in the same order every time.
  • Restate the format at the end. Instruction drift over long prompts is the common failure.
  • Shorter is safer. Instruction-following degrades faster with prompt length than on frontier models.
  • Examples do the heavy lifting. One or two concrete pairs outperform a paragraph of description.
  • Forbid the preamble explicitly. Otherwise you get 'Sure! Here is…' in front of your JSON.
### Instruction · ### Input · ### Constraints · ### Output format (restated last)

Claude, GPT and Gemini guidance is drawn from the vendors' own prompt-engineering docs. The Grok and open-weights profiles come from community write-ups, because xAI publishes no equivalent guide — they're marked lower-confidence here for that reason.

Free where it's a tool. Paid where it's a workflow.

The linter above is free and stays free — it runs in your browser and costs nothing to serve, so there's no reason to put it behind a signup. What's coming is the part that needs a server: the rewrite written by a model, and proof that it actually beat your original.

Linter

$0 / forever
  • Unlimited scoring and rewrites
  • All five model profiles
  • No account, no limits
  • Nothing leaves your browser
In build

Pro

$16 / month
  • Rewrites written by a model, not a template
  • Side-by-side A/B on the real target model
  • Browser extension for ChatGPT, Claude & Gemini
  • Saved library with version history
Later

Team

$24 / seat / month
  • Shared prompt library with approvals
  • House style rules
  • SSO and audit log
  • Prompts never used for training

Get the first build

The linter works today. Accounts, the browser extension, and A/B against GPT and Gemini are what's next. Leave an address and you'll get it before anyone else.

Where this goes

Your address goes to the mailing list and nowhere else. No sharing, no reselling, and every email has an unsubscribe link. You'll hear from me when there's a build worth opening, not weekly.

The one question that matters

The optional box is the useful one. Knowing what would make you switch is worth more to me than the address.