Using a Model to Score Landing Page Copy on Clarity

Five dimensions, each scored 1 to 5, weighted by where the risk sits for your offer. The anchors below matter more than the labels: a model grades consistently when each level is tied to visible evidence in the copy, not to adjectives like "good" or "excellent."

Message match deserves its weight because it is the dimension most often broken by neglect. Matching the landing page headline and copy to the ad reassures the visitor they made a good click, which is why practitioners treat message match as a precondition for conversion rather than a nice-to-have (Unbounce landing page best practices). An ad about retirement communities that lands on a page about luxury condos will drive visitors away even if both are well written (the importance of message match).

Proof is worth less on first impression but still earns a slot. Social proof reduces perceived risk by showing that people like the visitor already trust you, and testimonials tend to outperform bare logo rows because a specific person with a specific problem is easier to identify with (MailerLite on social proof). A controlled comparison cited by UserEvidence found a customer quote produced a 35 percent lift over company logos (social proof study). Keep in mind that proof works best as support near the claim, not as decoration (CXL on social proof).

Two scoring rules keep the output useful:

1. Score proof and next-step conservatively when the element sits below the fold. A five-second scanner will not see it, so it should not rescue an unclear hero.
2. Treat a score of 2 or below on offer clarity as a veto. A high total built on proof and message match cannot compensate for copy nobody can parse.

That veto rule is the decision rule most teams are missing. Averaging the five dimensions hides the failure that matters most, because a beautiful testimonial and a matched headline can push a total to 3.6 while the offer stays guessable.

The judge works when the prompt is fixed, the anchors are explicit, and the model must quote the evidence it used. Borrow the standard configuration from LLM-as-a-judge practice: give the model a description of what good looks like alongside the output being evaluated, and require reasoning so disagreements are diagnosable (LangChain on LLM-as-judge). Strong judges reach roughly 80 percent agreement with human evaluators, which is about the level humans reach with each other, but your own agreement rate depends entirely on how well the prompt captures your definition of good.

Here is a prompt skeleton you can paste and adapt. Keep the ad text, the audience definition, and the draft as separate labeled blocks so the model never confuses them.

You are a landing page clarity auditor. You score one draft at a time
against a fixed rubric. You never rewrite the copy. You never soften scores.

AD CONTEXT
Ad headline: {{ad_headline}}
Ad body: {{ad_body}}
Target audience: {{audience_definition}}

DRAFT (above-the-fold text only)
{{draft_text}}

RUBRIC: score each dimension 1-5 using only the anchors below.
- Offer clarity (weight 30): 5 = a stranger can restate the offer in one
  sentence; 3 = the category is clear but the specific offer is not;
  1 = offer cannot be inferred from the text.
- Audience fit (weight 20): 5 = a named segment or specific job appears;
  3 = audience implied by one word; 1 = no audience signal.
- Message match (weight 25): 5 = headline reuses the ad's promise and noun;
  3 = same category, different promise; 1 = no trace of the ad.
- Proof (weight 15): 5 = specific, checkable evidence next to the claim;
  3 = generic claim of popularity; 1 = none.
- Next step (weight 10): 5 = one visible action with verb and outcome;
  3 = visible but vague; 1 = competing or missing.

OUTPUT FORMAT (exact)
For each dimension: score, one quoted span from the draft as evidence,
one sentence of justification.
Then: weighted_total, lowest_dimension, veto_triggered (true if offer
clarity <= 2), and one_sentence_fix_priority.
Do not output anything else.

Three implementation details separate scores you can trust from scores that look plausible.

First, temperature zero and one draft per call. Pairwise comparison, where the judge sees two drafts and picks the better one, is the right tool for final ranking, but pointwise scoring is what gives you a numeric profile per draft and tells you which dimension failed (LangChain on judge types).

Second, put the ad and audience into every call. Without them the model scores message match against nothing and drifts toward rewarding generic clarity.

Third, force quoted evidence. A model that must paste the span it used is far less likely to hallucinate a strength, and when it disagrees with you, the quote tells you whether the prompt or the copy is at fault.

If you are scoring dozens of drafts across clients or product lines, running them through a single endpoint that handles text and image inputs saves you from maintaining separate integrations; Quanta Inference exposes text, image, video, audio, and embedding models through one OpenAI-compatible API key (https://quantaintelligence.ai/inference).

A judge that always returns 5 is perfectly repeatable and useless. Calibration is the step that makes model scores decision-grade, and it has two halves: stability (does the same draft score the same way twice?) and alignment (do the scores match what real people recall?).

Stability first. Re-run each draft three times at temperature zero. If a draft returns 3, 4, 2 on the same dimension, that boundary is ambiguous, and the fix is usually a sharper anchor rather than a different model. This is a known failure mode: a rubric built on adjectives like "good" and "adequate" forces the judge to invent boundaries on every call, and variance concentrates in the uncertain middle of the scale (testing rubric score consistency). Research on rubric generation reaches the same conclusion from the other direction: fine-grained, decomposed criteria outperform holistic judgments and are competitive with human-crafted rubrics (dynamic evaluation rubrics).

Alignment next. Run a real five-second test on the same drafts. Sample size guidance varies: one practitioner suggests 20 to 50 participants is enough to eliminate clearly failing versions before an A/B test (the five-second test method), while agency guidance puts the ideal at 50 to 100 per test, and at least 50 per segment when you split mobile and desktop (Speero's method page). For calibration, start with 15 to 20 participants per draft and accept directional signal, not statistical proof (CleverX).

Then build the comparison table. Code the free-text answers against the same five dimensions: did the participant correctly name the offer, name the audience, echo the ad, mention proof, and name the next action? Here is a worked example with six drafts and 20 participants each.

The agreement between model totals and participant recall is what you are buying. In this example the ordering matches on the top four and the bottom two, and drafts E and F were vetoed on offer clarity by the model alone, which the participant data confirms at 15 to 20 percent. Where the model and the participants disagree, you have a prompt bug, and it is usually one of three: the model rewarding cleverness the participants cannot parse, the model ignoring the ad context so message match is scored generously, or an anchor that is too loose on next step. Add a labeled example of the disagreement to the prompt and re-run. That loop is the same one described for production evaluators, where human corrections become few-shot examples and you track agreement over time (LangChain).

Set a stopping rule before you start: if the model's ranking of the top three disagrees with the participant ranking on the offer dimension, do not send traffic yet. Fix the rubric and repeat with the same drafts. Two calibration rounds is normal.

A/B testing takes time, engineering effort, and enough traffic for significance, and small and mid-size sites often wait weeks for a result (the five-second test method). Running three or more variants in parallel makes the wait longer still. The purpose of the scoring loop is to arrive at the test with two strong variants instead of five speculative ones.

The decision rule, in order:

1. Drop any draft with a veto on offer clarity, regardless of total.
2. Drop any draft whose participant data shows header recall below 50 percent on the offer question.
3. Rank the survivors by weighted total, and prefer the higher of the two on message match when the totals are within 0.3, because message match is your paid traffic's own measure of fit.
4. Send traffic to the top two only.

The split matters less than the discipline. Standard testing practice applies once you get there: change one thing at a time, set a single conversion goal, and keep the page's call to action visible above the fold so the test measures the message rather than the hunt for a button (landing page best practices). Because your two finalists differ in copy rather than layout, and both cleared the clarity gate, the test result will tell you something about the audience rather than about whether the page was legible at all.

Keep the losers. Their per-dimension scores are the most valuable output of the exercise: if four of six drafts failed offer clarity, the problem is upstream in how the product is described, not in the headlines. Fix the positioning before writing a seventh draft.

The scoring loop is cheap enough to run every time a campaign ships. A repeatable cadence:

Day 1, write. Produce five to ten draft headlines and hero copy variants against one ad. Vary the dimension, not everything: some drafts should hedge the offer, some should shift the audience, some should drop proof. That design tells you later which dimension drives recall.

Day 1, score. Run every draft through the fixed prompt three times, one draft per call, capture the evidence quotes and the lowest dimension.

Day 2, test. Run a five-second test on the top four drafts plus one control, using the four standard questions: what is this page about, what do you remember, who is it for, what would you do next (five-second test template). Tools will run this without a moderator and without code (five second test tools).

Day 3, reconcile. Compare model and participant rankings, patch the prompt with one labeled counterexample, re-score, and freeze the prompt for the campaign.

Day 4, ship. Promote two drafts, split traffic, keep one as control for the next campaign's baseline.

Two governance notes keep this honest. First, never let the model be the only evaluator of a go or no-go decision on a dimension with a veto; the veto exists so the model flags a problem, not so it settles one. Second, never tune the prompt and the copy in the same cycle. If the model and the humans disagree, the prompt is the variable, and changing both at once destroys your ability to learn which one moved the score. The same separation between generation and evaluation is what makes judge pipelines workable in production: the judge applies criteria rather than producing content, so disagreements can be traced to a specific criterion (LangChain).

If you would rather have someone build this loop around your own product, including the rubric, the prompt, and the five-second test harness, Quanta Experts pairs you with a specialist who reads your context and hands back finished deliverables (https://quantaintelligence.ai/agents). The rubric is the hard part, and it is the part worth getting right before any score is trusted.