A good prompt has 4 dimensions: clarity (unambiguous intent), specificity (concrete, verifiable instructions), structure (the critical instruction where the model weights it), and robustness (holds up under messy input and variation). Together they form the CSER framework. Most people only optimize clarity. Ignoring the other three is why prompts that sound good still fail in production. Across 1,018 scored prompts, robustness is the most-skipped: average 31.5 out of 100.
Most prompt engineering advice focuses on one thing: the right words. "Be specific." "Use clear language." "Add examples." The advice isn't wrong, it's incomplete. Wording is just one part of a prompt.
Looking at what actually breaks prompts in production, four dimensions decide whether a prompt works reliably. And the numbers back it up: in the State of Prompt Quality report, a sample of 1,018 real prompts averaged 54 out of 100, and only 10.5% reached the production-ready band (75+). It isn't for lack of effort. It's optimizing one dimension and leaving the other three in the dark.
The four dimensions, and the real average for each
Before breaking each one down, the full map. This is the average of each dimension across the 1,018-prompt base, plus the question that exposes whether yours is weak:
| Dimension | What it measures | Average (n=1,018) | Test question |
|---|---|---|---|
| Clarity | Is there only one reasonable reading? | 63/100 | Would two people read this the same way? |
| Specificity | Are the instructions concrete and checkable? | 57.6/100 | Can you verify the answer met the ask? |
| Structure | Is the critical instruction in the right place? | 64.6/100 | Is the main instruction positioned well? |
| Robustness | Does it hold up under odd input and variation? | 31.5/100 | What if the input arrives half-formed? |
Notice the drop. Clarity, specificity, and structure all sit in the 60s. Robustness falls to 31.5. That's the dimension almost nobody handles, and the one we'll come back to with the most time. These four are exactly what the PromptEval score reports when you paste a prompt: each dimension comes back separately, so you see at a glance which one is dragging the total down. In the evaluation guide it's named the CSER framework, after the initials of the four dimensions in scoring order.
Clarity: one reading, not two
Clarity is the dimension everyone cites and most people get wrong. It isn't about being pleasant to read. It's about leaving no gap to interpret. A prompt is clear when there's exactly one reasonable interpretation of what you asked. If a competent person reads it and can picture two different correct outputs, clarity is missing.
The most common failures:
- Relative terms with no anchor: "be concise" instead of "under 80 words."
- Implicit assumptions: "write a summary", of what length, for whom, in what format?
- Ambiguous scope: "analyze this data", which aspects, what output?
Quick test: read the prompt as if you'd never seen the source material. Would you know exactly what to produce? If the answer is "it depends," clarity is leaking. When this is your weakest dimension, the guide on writing clear AI prompts goes straight to the fixes.
Specificity: what you can check afterward
Specificity is what separates "write something professional" from an instruction you can verify. Adjectives aren't specificity. "Professional," "detailed," and "engaging" sound concrete, but every reader (and every model run) fills them in differently. Specificity means trading the adjective for a measurable criterion: a number, a format, a constraint.
This is where the dataset gave the most actionable result. These are the habits that move the score most, with the average lift and how many prompts actually use each one:
| Habit in the prompt | Average score lift | How many use it |
|---|---|---|
| Declare the output format | +29 points | 79% |
| Add explicit constraints | +24 points | 55% |
| Define a persona or role | +17 points | 70% |
| Include examples (few-shot) | +10 points | 5.2% |
Declaring the output format alone is worth +29. And it isn't only our data: He et al. (2024) measured that format choice changes response quality in a measurable way, with JSON among the most consistent formats. Persona has support in the literature too. Kong et al. (2024) showed capability gains across several tasks when a role is assigned to the model, which lines up with the +17 we see in practice.
The line that jumps out is the last one. Few-shot examples return +10 points and only 5.2% of prompts use them. It's the best effort-to-payoff habit almost nobody applies. If specificity is your gap, the guide on writing specific AI prompts shows how to trade adjective for criterion in each case.
Structure: the order the model weights
Structure is how the prompt is organized, and it carries more weight than it looks. LLMs process the text in sequence and weight passages by position. A poorly structured prompt makes the model deprioritize the constraint you thought was most important, because it got buried in the middle of a paragraph.
Good structure, in order:
- Role and context first, to calibrate the rest of the read.
- The core task stated clearly, before edge cases.
- The output format at the end, close to where the model starts generating.
- System-level instructions separated from each request's input.
Structure was the highest-scoring dimension in the base (64.6), which makes sense: almost everyone writes in "role, task, format" order by instinct. The mistake that sinks the score is always the same, burying the critical instruction. For the step-by-step, see how to structure AI prompts.
Robustness: the dimension almost nobody handles
Robustness is how much the prompt survives the real world: input that's half-formed, off-format, in another language, or a model variation you never tested. It's the weakest dimension in the base by a wide margin. Average 31.5, against clarity's 63. And it was the lowest dimension in 95.7% of prompts scored. Practically every prompt that runs through PromptEval has robustness as its weakest link.
The two sub-scores that sink lowest are bad-input resilience (average 30.3) and edge-case coverage (32). The cause is familiar: we write the prompt for the clean case, the tidy example in our head. The real user sends something else.
A robust prompt answers, up front, the questions the messy input will raise:
- What if a field is missing? ("If the value isn't in the text, write null instead of guessing.")
- What if more than one request arrives at once? ("Answer only the first request and ignore the rest.")
- What if the input is in another language or format? Say what to do, don't let the model decide alone.
Handling robustness is what moves a prompt out of the test bench and into production. If this is your gap (and statistically it is), the guide on making AI prompts robust covers the tests that expose each hole.
A real before and after, with scores
Theory goes only so far without watching the score move. I took a mundane task, extracting fields from a customer email, and wrote both versions.
Weak prompt: "Read the customer email and tell me the important details."
Strong prompt: "You are a support triage assistant. From the email below, extract, as JSON, the fields: name, order_id, issue_category (one of: delivery, billing, product, other) and urgency (low, medium, high). If any field isn't in the text, use null, don't infer. If the email contains more than one order, return a list of objects. Include no text outside the JSON."
Same task, same model. The per-dimension scores:
| Dimension | Weak prompt | Strong prompt |
|---|---|---|
| Clarity | 45 | 88 |
| Specificity | 30 | 86 |
| Structure | 52 | 84 |
| Robustness | 25 | 80 |
| Total | 38 | 85 |
The jump from 38 to 85 didn't come from "writing better." It came from closing the four gaps at once: a category criterion (clarity), the JSON format and the field list (specificity), the role-task-format order (structure), and two rules for imperfect input, missing field and multi-order email (robustness). The weak prompt produces a prose paragraph nothing downstream can parse. The strong one returns JSON a system can consume.
Why one weak dimension drags the other three
This is the root of most prompt inconsistency. When one dimension is weak, the model fills that gap differently on every run. If your outputs have been unpredictable, this breakdown shows why.
A prompt can do well on three dimensions and still fail because of the fourth. Beautiful structure and rich context, with vague specificity, still produces results that vary. Crystal-clear intent and a defined format, without robustness, works in the test and slips on the first crooked input. The four pull on each other: improving one usually exposes the gap in another. That's why evaluating the whole prompt, instead of feeling that it "sounds good," is the only reliable way to know it's production-ready. It's the same principle behind how to evaluate AI prompt quality.
How to measure all four in seconds
Reading your own prompt almost never points to the gap, because it looks obvious to whoever wrote it. The objective way is to score the four dimensions separately and attack the lowest one first. Paste the prompt into PromptEval's checker and each dimension score comes back on the spot, no signup. The free plan gives three full evaluations a month, enough to catch the pattern in how you write.
If the goal is to build intuition for the four dimensions without evaluating one prompt at a time, Daily Training sets up a work scenario each day with a named technique and a judge that scores what you wrote. It's the fastest way to turn "fix the robustness" into a reflex instead of a checklist.
The checklist
Before shipping any prompt, four questions:
- Clarity: is there only one reasonable interpretation?
- Specificity: can you verify, afterward, whether the answer met the ask?
- Structure: is the most important instruction in the position the model weights?
- Robustness: does the prompt say what to do when the input comes in odd?
Four questions. That's the whole framework, and the fourth is the one most people forget.
Frequently asked questions
What are the 4 dimensions of a good prompt?
Clarity (one reading only), specificity (concrete, verifiable instructions), structure (the critical instruction where the model weights it, output format declared), and robustness (holds up under odd input and variation). Together they're the CSER framework, the same four PromptEval scores from 0 to 100.
Which dimension is usually the weakest?
Robustness. Across 1,018 prompts it averaged 31.5 and was the lowest in 95.7% of cases. Almost every prompt is written for the clean input and never says what to do when the input comes in half-formed or off-format.
What raises a prompt score the most?
Declaring the output format, worth +29 points on average. Then explicit constraints (+24), defining a persona (+17), and few-shot examples (+10). The first three are cheap, and the typical weak prompt skips at least one.
How do I know which of the four dimensions is dragging my prompt down?
Reading it rarely tells you. Score the four separately and look at the lowest. PromptEval's checker shows each dimension score in seconds, in the browser, no signup.
Do I always need to optimize all four?
Yes, but in the right order. Measure first, fix the weakest dimension (almost always robustness), measure again. Polishing the one that was already fine returns little. It's surgical work, not a full rewrite.