Founders

How to Write a Second-Model Reviewer Prompt from the Same Rubric

Antonio Evans10 min read

A split scene: on the left, a reviewer at a desk facing a tall stack of unmarked documents; on the right, the same reviewer with a shorter stack where each page carries a small draft score and a highlighted quote.
Key points

Key points

  1. 1A second-model reviewer works best when each rubric line becomes its own yes/no question with a required quote from the text being judged.
  2. 2The reviewer should return a draft score, the quoted evidence and a confidence flag, never a final decision that overrides the human.
  3. 3Every check needs an explicit abstain condition, so the model declines when the evidence is missing, ambiguous or outside the rubric's scope.
  4. 4A fixed aggregation rule (how check results combine into a draft verdict) keeps the model's output comparable across reviewers and across batches of work.

Human-only review versus model-assisted review

Human-only review has one large virtue and one large cost. The virtue is that an experienced reviewer holds context that no prompt captures: prior history with the author, unwritten conventions of the team, and a sense of when the rubric itself is wrong. The cost is consistency. Rubrics judged by several raters need a norming process, and studies of inter-rater reliability show that even trained raters diverge, with the measured agreement changing substantially depending on which statistical method you use to compute it the FHSU inter-rater reliability paper. A clinical documentation rubric examined in pharmacy education showed that a rubric can be made to support reliable scoring, but only after explicit attention to how raters applied it the PMC rubric reliability study.

Model-assisted review changes the economics. A model applies the same criteria to every item in the same order, does not get tired at item 300, and can produce its reasoning on request the Splunk LLM-as-judge guide. But it introduces a new failure: the supervisor of AI output now spends cognitive effort checking rather than producing. Research on AI delegation describes this as a supervisory paradox, where delegating work to a model creates oversight demands that can exceed the cognitive cost of the original labor, especially through attention fragmentation when many outputs queue up at once the SSRN supervisory paradox paper.

The design consequence is straightforward. The model's job is not to replace the reviewer's judgment but to remove the mechanical part of it: locating the relevant span, checking whether a required element is present, and drafting a verdict the reviewer can accept or overturn in seconds. That is the human-in-the-loop pattern, where a human authorizes before the workflow proceeds, as opposed to human-on-the-loop, where the human monitors after the fact the Elementum HITL comparison.

DimensionHuman-only reviewModel-assisted review
Consistency across itemsVaries with fatigue and raterUniform criteria application per run
Speed per itemSlowFast, with reviewer confirming
Context and historyStrongAbsent unless supplied in the prompt
Handling of ambiguityJudgment call, undocumentedCan be forced to abstain and flag
Audit trailNotes, if writtenQuoted evidence per check
Main riskDrift and inconsistencyFalse confidence and oversight fatigue

A worked figure makes the trade-off concrete. Suppose a rubric has 12 checks and a reviewer spends 40 seconds per check on a human-only pass, about 8 minutes per item. If the model pre-fills 12 draft results with quotes and the reviewer needs 15 seconds per check to confirm or overturn, the review drops to about 3 minutes. The model's own runtime is negligible. The saving is real, but only if the evidence is short enough to scan; a model that quotes three paragraphs per check gives the saving back.

Step 1: Extract each rubric check as an atomic criterion

Start from the rubric as written and split it until each line tests one thing. A line like "the summary is accurate and complete" tests two properties and will produce murky results. The rubric design guidance from teams running LLM graders converges on the same rule: one criterion, one failure mode, so that a failure points at a single diagnosable issue the Hebbia hybrid evaluation framework. The same source recommends pass/fail scoring over multi-level scales, adding more criteria rather than more score levels when you need granularity.

A second rule from the same body of practice is distinct coverage. If two checks tend to pass or fail together, they are measuring one thing, and keeping both distorts the aggregate and wastes evaluation work the Hebbia hybrid evaluation framework. Merge them or narrow one.

Hierarchical rubrics help here. A complex task can be scored by broad dimensions, then sub-dimensions, then fine-grained items that a reader can answer from evidence alone; a published benchmark rubric in this style uses seven primary dimensions, 25 sub-dimensions and 130 fine-grained items the Splunk agent evaluation framework. You do not need that depth, but the shape is right: the leaf items are what the model answers.

For a typical content or support-response rubric, the extraction pass looks like this:

Rubric line as writtenAtomic checks extracted
Answer is accurate and completeClaims are supported by the provided source; every question in the prompt is addressed
Tone is appropriateNo blame language directed at the customer; no unexplained jargon
Follows escalation policyRefund over threshold is escalated; security issue is routed to the security queue
Well structuredLead sentence states the outcome; steps appear in execution order

Four lines became eight checks. That is normal, and it is the point: eight answerable questions beat four that require interpretation.

Step 2: Rewrite each check as a yes/no question with a quote requirement

Convert every atomic check into a single question whose answer is yes or no, and require the model to copy the exact span it judged. The quote requirement does two jobs. It makes the verdict auditable, and it suppresses the model's tendency to answer from general impressions rather than the text in front of it. Rubric-based scoring guidance is explicit that giving a model a structured rubric, rather than asking it to just score the output, is what produces consistent and interpretable results the rubric scoring agent design write-up.

Specificity matters more than eloquence. "Is the title good" cannot be applied consistently. "Is the title descriptive, specific, and free of units or scale information" can the Hebbia hybrid evaluation framework. Where the rubric implies a fixed mapping, state the mapping: line chart for continuous trends, bar chart for discrete comparisons, stacked bar for part-to-whole across periods.

A prompt block for one check can be short enough to read at a glance:

CHECK 3 of 12: escalation_threshold
Question: Does the response escalate any refund above the
stated threshold to a human approver?
Answer: YES | NO | ABSTAIN
Quote: copy the exact sentence(s) that decide this. Max 40 words.
Reason: one sentence, max 25 words.

Keep the quote cap. It forces the model to select the decisive span rather than dumping context, and it keeps the reviewer's confirmation step fast.

Step 3: Give every check an explicit abstain condition

Abstention is the part most prompt drafts skip, and it is where model-assisted review earns or loses trust. Write the abstain condition as part of the check, not as a general instruction at the top of the prompt. Good abstain conditions name the situation precisely:

  • The decisive information is not present in the text being judged.
  • The quote needed to answer would exceed the cap because the relevant content is scattered across more than one section.
  • The check depends on a policy, threshold or source document not supplied in this prompt.
  • Two passages support opposite answers and nothing in the rubric resolves which applies.
  • The output is truncated or malformed in a way that prevents judgment.

Set aggregation so that abstains are visible and never silently converted. A check that abstains should count as unresolved, and any item with one or more unresolved checks should route to a full human review rather than a quick confirm. This mirrors the routing logic used in enterprise human-in-the-loop systems, where outputs above a risk threshold or below a confidence threshold go to a reviewer rather than proceeding the Elementum HITL comparison. In a large-scale writing assessment deployment, a human-in-the-loop decision flow was used specifically to identify which cases most needed expert review, which is the same principle applied to essay scoring the arXiv human-in-the-loop scoring framework.

Step 4: Set the aggregation rule before you see results

Decide how check answers become a draft verdict, and write it into the prompt as a fixed rule. Three patterns cover most rubrics:

  1. All-required: every required check must be YES. Any NO or ABSTAIN blocks a pass. Use for compliance, safety and policy checks.
  2. Weighted score: required checks gate, additional checks add points. The Hebbia rubric design distinguishes required criteria, which represent the agent's service commitments, from additional criteria that mark advanced quality without causing failure the Hebbia hybrid evaluation framework.
  3. Count threshold: a pass needs at least N of M checks. Simple, but it lets one serious failure hide behind several trivial passes, so pair it with a gating list.

Whatever you choose, have the model return a structured object rather than prose. A JSON shape keeps the output parseable and makes reviewer acceptance a one-click action:

{
  "item_id": "resp-1042",
  "checks": [
    {"id": "escalation_threshold", "answer": "YES",
     "quote": "Refunds above $250 require approver sign-off.",
     "confidence": "high"},
    {"id": "security_routing", "answer": "ABSTAIN",
     "quote": "", "confidence": "low",
     "abstain_reason": "No security issue appears in the response."}
  ],
  "draft_verdict": "REVIEW",
  "unresolved_checks": ["security_routing"]
}

Note the draft verdict is REVIEW, not PASS or FAIL. The aggregation rule sees an abstain and routes accordingly. Before you trust any of this, run the same sample several times and measure how often each check flips between runs; rubric stability across independent runs is the minimum bar before automating decisions, and a criterion that flips frequently needs rewriting rather than averaging the Splunk agent evaluation framework. Multiple grading passes per item, aggregated, reduce noise from grader non-determinism and expose ambiguous criteria the Hebbia hybrid evaluation framework.

Expect a calibration gap. Strong general-purpose judges reach agreement with human evaluators at roughly the rate humans agree with each other on general tasks, but off-the-shelf judges agree with domain experts only about two-thirds of the time on expert-knowledge tasks, because they lack the domain context the Splunk LLM-as-judge guide. The same guide reports that prompt wording alone moves accuracy widely on the same underlying model, which is why the check wording, not the model choice, is the main lever you control.

Step 5: Design the reviewer's screen around accept, change and abstain

The prompt is only half the system. The reviewer needs to see, for each check, the question, the model's answer, the quoted span and the confidence flag, and must be able to accept, overturn or abstain with one action. Three design rules keep this from becoming a new bottleneck:

  • Never show a single overall score first. Show the check table, so the reviewer forms a view from evidence rather than anchoring on the draft.
  • Sort by confidence, ascending. Low-confidence checks go to the top. This is the same prioritization logic used in supervisory dashboards for AI voice agents, where alert prioritization by escalation potential reduces cognitive load and improves response times the emergingpub cognitive load study.
  • Log every overturn. A check the reviewer overturns repeatedly is a badly written check. If graders frequently disagree on a criterion, that criterion needs refinement, not more grading passes the Hebbia hybrid evaluation framework.

The cognitive-load literature supports this restraint. Supervisors monitoring many AI interactions face information overload that leads to alert fatigue and missed escalations, and the proposed remedies are adaptive presentation and contextual alerting rather than more raw signal the emergingpub cognitive load study. Treat each check result as an alert with a priority, not as a data field.

Common failure modes and how to check for them

Most weak second-model reviewers fail in one of five ways. The table below maps each failure to its fix and to the evidence you can inspect.

FailureSymptom in outputFix
Compound criteriaVague quote spanning unrelated textSplit into atomic checks
No quote requirementConfident verdict with no evidenceRequire exact span, cap length
Missing abstain conditionGuesses on absent informationPer-check abstain rule, route to review
Prose outputReviewer cannot scanJSON schema with fixed fields
Verdict treated as finalReviewer rubber-stampsLabel as draft, log overturns

The bias problem deserves its own line. LLM judges are documented to favor irrelevant heuristics such as answer length and the order in which candidates are presented the arXiv dynamic rubric paper. In rubric-based evaluation at scale, teams are advised to actively mitigate verbosity, position bias and self-preference the Medium rubric-based evaluation overview. Practical countermeasures: cap the quote, randomize order when you compare two outputs, and keep the source document short enough that length cannot stand in for quality.

There is also a governance reason to keep humans authorizing. Analyst forecasts cited in evaluation guidance predict that a substantial share of enterprises will demote or decommission autonomous agents where governance gaps surface after production incidents the Splunk agent evaluation framework. A reviewer prompt that never lets the model make the final call sidesteps that risk entirely.

When not to use a model reviewer at all

Some checks should stay human, and knowing which ones saves you from building the wrong thing. Skip the model, or route straight to expert review, when:

  • The check requires knowledge outside the supplied text, such as the author's history or an unwritten team convention.
  • The check is high-stakes and irreversible, and a false YES is expensive to reverse.
  • The rubric line is itself disputed and has no agreed operational definition yet. Fix the rubric first.
  • The item is so short that a reviewer reads it faster than the model output.

For the checks where the model does help, one API key covering many model families keeps the reviewer prompt portable: you can test the same prompt across several judges and compare flip rates without rewiring anything. Quanta Inference provides that single key with OpenAI-compatible access.

Finally, validate against humans, not against your own taste. Score a sample of items both ways, compute agreement per check rather than overall, and rewrite the checks with the lowest agreement. Rubric quality in multi-rater settings has been studied for decades, and the lesson transfers: validity and reliability are separate questions, and a rubric can be valid in principle while unreliable in application the FHSU inter-rater reliability paper. The same caution applies when the second rater is a model.

FAQ

FAQ

How many checks should one reviewer prompt contain?

Keep the whole rubric in one prompt where it fits in a page or two, since splitting across calls adds coordination work for the reviewer. If a rubric runs past roughly 20 atomic checks, group them into two or three themed prompts and run them in parallel. Beyond that point, reviewers cannot scan the table quickly and the confirmation step stops being fast.

Should the model see examples of good and bad outputs?

Yes, for the checks your team has argued about. Few-shot examples of borderline cases are one of the three ingredients recommended when starting an LLM judge, alongside one failure mode and explicit criteria the Splunk LLM-as-judge guide. Keep examples short and attach them to the specific check they illustrate, not to the prompt as a whole.

What confidence flag should the model return?

Use a small set: high, medium and low, with a definition written into the prompt. High means the quote alone settles the question; medium means the quote supports the answer but a reviewer might read it differently; low means the answer is a best guess and should be treated as an abstain. Sorting the reviewer's queue by this flag is what makes the draft useful.

How do I know the prompt is stable enough to deploy?

Run the same sample through the prompt at least three times and count how often each check's answer changes. Checks that flip often are ambiguous and need rewording. Multiple grading passes per item, aggregated, are the standard way to reduce noise and surface rubric ambiguity the Hebbia hybrid evaluation framework.

Does the reviewer's own judgment drift once a draft score is shown?

It can, which is why the order of the screen matters. Show the check table and the quotes first, and place the draft verdict after them, so the reviewer builds an independent view before seeing the model's conclusion. Track how often reviewers overturn the draft; a falling overturn rate on low-confidence checks is worth investigating.

Sources

Sources

  1. Is it actually reliable? Examining Statistical Methods for Inter ...
  2. Inter-rater Reliability of a Clinical Documentation Rubric ...
  3. How to Set Up Evals with LLM-as-Judge
  4. The Supervisory Paradox: How AI Delegation Transforms ...
  5. Human-in-the-Loop vs Human-on-the-Loop: Enterprise ...
  6. Evaluating AI Agents: A Hybrid Deterministic and Rubric ...
  7. How to Build an Agent Evaluation Framework for ...
  8. Designing Scoring Agents with Rubric-Based Evaluation
  9. A Human-in-the-Loop Framework for AI-Assisted Scoring ...
  10. Mitigating Cognitive Load in Supervisory Control of AI ...
  11. Generating and Refining Dynamic Evaluation Rubrics for ...
  12. Rubric-Based Evaluations & LLM-as-a-Judge
About the author

About the author

Antonio Evans
Antonio Evans

Antonio Evans is the founder of Quanta Intelligence and a fractional CTO who builds HIPAA-ready AI systems for health and life-science companies. Before that he was technical co-founder of FriendsEAT for twenty years, CEO of Socialdraft, and a data engineer at IBM. Antonio lives with his dog Santino in Lisbon, Portugal.

All articles