Inferensys

Prompt

Rubric Clarity and Judge Divergence Diagnostic Prompt Template

A practical prompt playbook for using Rubric Clarity and Judge Divergence Diagnostic Prompt Template in production AI workflows.
Operations team reviewing AI workflow automation on laptop, workflow builder visible, casual office setup.
PROMPT PLAYBOOK

When to Use This Prompt

Determine if your judge disagreement problem is a rubric problem before you spend weeks recalibrating judges.

This prompt is for evaluation infrastructure teams who observe high inter-rater disagreement and need to determine whether the scoring divergence originates from ambiguous rubric language rather than judge bias or model inconsistency. The core job-to-be-done is isolating the rubric as a root cause: you have a rubric, a set of scored items with multiple judge ratings, and you need to identify which specific rubric sections or phrases correlate with disagreement. Without this diagnostic, teams waste effort recalibrating judges or adjusting scoring thresholds when the real fix is rewriting unclear criteria. The ideal user is a rubric designer, evaluation lead, or ML engineer who already has disagreement data and is ready to act on rubric improvements, not just measure agreement metrics.

You should use this prompt when you have at least 20-30 scored items with ratings from two or more judges, and you've already computed basic agreement metrics that show problematic divergence. The prompt requires structured input: the full rubric text with labeled sections, a matrix of judge scores per item, and optionally judge rationales if available. It produces a diagnostic report with per-section clarity scores, divergence hotspots mapped to specific rubric phrases, and concrete rewording suggestions ranked by expected impact. The output is designed to be actionable—you should be able to take the top rewording suggestion and test whether it reduces disagreement in a follow-up scoring round.

Do not use this prompt when you have fewer than 10 scored items, when judges haven't been calibrated at all, or when the disagreement is clearly caused by model output quality variance rather than rubric interpretation. This prompt assumes the judges are reasonably competent and the primary variable is rubric clarity. If your judges are producing wildly different scores because they're different models with different capabilities, start with the Cross-Model Judge Agreement Comparison prompt instead. If you suspect individual judges are outliers, use the Outlier Judge Detection prompt first. This diagnostic is specifically for the case where agreement metrics are borderline—not catastrophically broken—and you need to decide whether to fix the rubric or the judges.

The prompt is designed for single-round diagnosis. After receiving the output, you should manually review the top divergence hotspots and rewording suggestions before applying them. Do not automatically rewrite your rubric based on the model's suggestions without human review—the model can identify ambiguous language but may propose rewordings that change the scoring intent. Run a small calibration round with the revised rubric and the same items to verify that disagreement decreases before rolling out the changes to your full evaluation pipeline. If disagreement persists after two rubric revision cycles, the root cause likely lies elsewhere and you should escalate to the Disagreement Root Cause Analysis prompt.

PRACTICAL GUARDRAILS

Use Case Fit

This prompt is a diagnostic tool for evaluation infrastructure, not a scoring prompt itself. It helps rubric designers understand why judges disagree before they fix the scoring pipeline.

01

Good Fit: Pre-Deployment Rubric Audit

Use when: you are designing a new evaluation rubric and want to catch ambiguous criteria before it goes live in a CI/CD pipeline. Guardrail: run this diagnostic on a calibration set with known-quality outputs to surface phrasing that causes judge confusion.

02

Good Fit: Judge Fleet Divergence Triage

Use when: inter-rater agreement metrics drop below your threshold and you need to isolate whether the rubric, the judges, or the items are the root cause. Guardrail: pair this prompt with the Disagreement Root Cause Analysis template to separate rubric ambiguity from judge bias.

03

Bad Fit: Real-Time Scoring Pipelines

Avoid when: you need a low-latency scoring decision in a production evaluation loop. This prompt is a heavyweight diagnostic that analyzes multiple judge-score pairs. Guardrail: use this offline during rubric development cycles, not in the hot path.

04

Bad Fit: Single-Judge Setups

Avoid when: you only have one judge model or one human rater. Divergence diagnostics require at least two scoring sources to compare. Guardrail: deploy the Judge Calibration Set Generation prompt first to build a multi-judge baseline before running this diagnostic.

05

Required Inputs

What you need: a rubric document with labeled sections, a set of scored items with per-judge scores and rationales, and the agreement metric that triggered the investigation. Guardrail: validate that judge rationales are included—without them, the prompt cannot link ambiguous phrases to scoring behavior.

06

Operational Risk: Over-Fitting to One Disagreement

What to watch: diagnosing divergence from a single high-disagreement item can lead to rubric changes that break agreement on previously stable items. Guardrail: require the prompt to analyze divergence patterns across multiple items and report whether a rewording suggestion improves or risks overall agreement.

PROMPT PLAYBOOK

Copy-Ready Prompt Template

Paste this prompt into your evaluation debugging workflow. Replace square-bracket placeholders with your rubric, disagreement data, and configuration parameters.

This prompt template is designed to be the core diagnostic tool for investigating why LLM judges diverge on specific evaluation items. It forces a structured analysis that links ambiguous rubric language directly to observed scoring disagreements, producing actionable rewording suggestions rather than vague commentary. The template expects you to provide the exact rubric text, a sample of items where judges disagreed, the scores they assigned, and any rationales they produced. It then isolates the specific rubric sections causing confusion and proposes concrete language fixes.

text
You are an evaluation rubric diagnostician. Your task is to analyze a scoring rubric and a set of disagreement cases to identify which rubric criteria are causing judge divergence.

## INPUTS

### RUBRIC
[RUBRIC_TEXT]

### DISAGREEMENT DATA
[DISAGREEMENT_ITEMS]
<!-- Format: For each item, include the item ID, the output being evaluated, the scores from each judge, and any judge rationales provided. -->

### CONFIGURATION
- Minimum divergence frequency to flag a rubric section: [MIN_FREQUENCY]
- Maximum number of rewording suggestions per section: [MAX_SUGGESTIONS]

## TASK

1. **Parse the Rubric**: Identify every distinct scoring criterion, dimension, or section in the rubric. Assign each a unique ID.

2. **Map Disagreements to Criteria**: For each disagreement case, determine which rubric criteria the judges are interpreting differently. Cite specific phrases from the rubric and specific excerpts from judge rationales as evidence.

3. **Score Clarity**: For each rubric criterion, assign a clarity score from 1 (highly ambiguous) to 5 (perfectly clear) based on the frequency and severity of linked disagreements.

4. **Identify Divergence Hotspots**: List the top [TOP_N] rubric sections most responsible for judge divergence, ranked by impact.

5. **Propose Rewordings**: For each hotspot, provide [MAX_SUGGESTIONS] alternative phrasings that would reduce ambiguity. Each suggestion must:
   - Preserve the original evaluation intent.
   - Replace vague terms (e.g., "good," "sufficient," "appropriate") with observable criteria.
   - Add examples or counterexamples where helpful.

## OUTPUT FORMAT

Return a JSON object with this exact schema:
{
  "rubric_sections": [
    {
      "section_id": "string",
      "original_text": "string",
      "clarity_score": number,
      "linked_disagreement_count": number,
      "ambiguity_phrases": ["string"],
      "rewordings": [
        {
          "suggested_text": "string",
          "rationale": "string"
        }
      ]
    }
  ],
  "divergence_hotspots": [
    {
      "section_id": "string",
      "impact_rank": number,
      "disagreement_examples": ["string"]
    }
  ],
  "global_recommendations": ["string"]
}

## CONSTRAINTS
- Do not invent disagreement cases. Only analyze the provided data.
- If a rubric section has zero linked disagreements, set clarity_score to 5 and provide no rewordings.
- If judge rationales are missing or insufficient, note this in global_recommendations and do not fabricate evidence.
- Preserve all original scoring scale values and labels in any rewording suggestions.

To adapt this template, start by populating [RUBRIC_TEXT] with the full, unedited text of the evaluation rubric you are debugging. The [DISAGREEMENT_ITEMS] placeholder requires structured data: for each item where judges disagreed, provide the item ID, the raw output being evaluated, the score from Judge A, the score from Judge B, and any free-text rationales the judges generated. If your evaluation pipeline does not capture judge rationales, you must first implement that logging; without rationales, the diagnostic power of this prompt drops significantly, and the model will be forced to speculate about the cause of divergence. Set [MIN_FREQUENCY] to a value that filters out noise—start with 2 or 3 if you have a large disagreement sample, or 1 if you are debugging a small set of critical failures. Set [MAX_SUGGESTIONS] to 3 for focused output. The [TOP_N] parameter in step 4 should be set to the number of hotspots you want to investigate first, typically 3 to 5.

Before relying on the output, validate that the model correctly parsed your rubric into its constituent sections. A common failure mode is the model merging distinct criteria or splitting a single criterion into artificial sub-parts. Compare the section_id list against your rubric's actual structure. If the model's rewording suggestions change the scoring scale or introduce new evaluation dimensions, reject them and re-run with tighter constraints. For high-stakes evaluation systems where rubric changes affect product decisions, always route the rewordings through a human rubric designer for approval before deploying them to production judges. The JSON output schema is designed to be machine-readable so you can programmatically diff the original and suggested rubric text, but the final decision to accept a rewording should remain a human judgment call.

IMPLEMENTATION TABLE

Prompt Variables

Required inputs for the Rubric Clarity and Judge Divergence Diagnostic Prompt. Each placeholder must be populated before execution to ensure reliable divergence hotspot detection and rewording suggestions.

PlaceholderPurposeExampleValidation Notes

[RUBRIC_TEXT]

Full text of the evaluation rubric being diagnosed, including all criteria, scoring levels, and descriptors

Criterion 1: Factual Accuracy (1-5)\n1: Major factual errors\n5: No factual errors\nCriterion 2: Completeness (1-5)\n1: Missing key elements\n5: All required elements present

Parse check: must contain at least 2 distinct criteria with scoring scales. Null not allowed. Truncation risk: if rubric exceeds 4000 tokens, split into sections and run diagnostic per section

[JUDGE_SCORES_MATRIX]

Matrix of scores assigned by multiple judges to the same set of items, with judge IDs and item IDs

{"judges": ["judge-a", "judge-b", "judge-c"], "items": ["item-1", "item-2", "item-3"], "scores": {"judge-a": {"item-1": 4, "item-2": 2, "item-3": 5}, "judge-b": {"item-1": 3, "item-2": 4, "item-3": 5}, "judge-c": {"item-1": 4, "item-2": 3, "item-3": 4}}}

Schema check: must include judges array, items array, and scores object with judge-item mappings. Minimum 2 judges and 5 items for statistical validity. Null scores allowed only if judge abstained with documented reason. Validate score ranges match rubric scales

[DIVERGENCE_THRESHOLD]

Minimum score difference between judges on the same item to flag as a divergence hotspot

2.0

Type check: float or integer. Must be positive. Default: 1.5 if not specified. Set higher for coarse rubrics, lower for fine-grained rubrics. Invalid if threshold exceeds rubric scale range

[JUDGE_RATIONALES]

Optional explanations or reasoning traces provided by judges alongside their scores, used to link divergence to specific rubric phrases

{"judge-a": {"item-2": "Scored 2 because response omitted the required safety disclaimer specified in Criterion 3"}, "judge-b": {"item-2": "Scored 4 because Criterion 3 is ambiguous about whether implied safety coverage counts"}}

Null allowed: diagnostic runs without rationale analysis if absent. If provided, must map judge-item pairs to rationale strings. Parse check: rationales must be non-empty strings. Citation check: flag rationales that reference rubric criteria not present in [RUBRIC_TEXT]

[CONFIDENCE_THRESHOLD]

Minimum confidence score required for the diagnostic output to be accepted without human review

0.85

Type check: float between 0.0 and 1.0. Default: 0.80. If diagnostic confidence falls below threshold, escalate to human rubric designer. Retry condition: if confidence below threshold, rerun with [JUDGE_RATIONALES] included if previously absent

[OUTPUT_FORMAT]

Desired structure for the diagnostic report, specifying which sections to include

{"include_clarity_scores": true, "include_divergence_hotspots": true, "include_rewording_suggestions": true, "include_phrase_attribution": true, "max_suggestions_per_criterion": 3}

Schema check: must be valid JSON with boolean fields for each section. Default: all sections enabled. Validation: if include_phrase_attribution is true, [JUDGE_RATIONALES] must not be null. Max suggestions per criterion must be integer between 1 and 5

[RUBRIC_VERSION]

Identifier for the rubric version being diagnosed, used for tracking divergence patterns over time

"v2.3-safety-revision"

Null allowed: diagnostic proceeds without version tracking. If provided, must be non-empty string. Used in output metadata for comparison with historical divergence reports. Approval required: if version change detected and divergence increases, flag for regression review

PROMPT PLAYBOOK

Implementation Harness Notes

How to wire the rubric clarity diagnostic prompt into an evaluation and debugging workflow.

This prompt is not a one-off debugging tool; it is a diagnostic step inside a larger judge reliability pipeline. The implementation harness should treat the prompt as a function that accepts a rubric, a set of scored items with judge rationales, and a divergence threshold. The output is a structured diagnostic report that can be logged, versioned, and fed into downstream repair workflows. Because the prompt analyzes judge behavior, the harness must ensure that the input data is complete and representative before invocation—running the diagnostic on a single divergent item will produce anecdotal results, not actionable patterns.

Wire the prompt into a scheduled or trigger-based evaluation job. When inter-rater agreement drops below a configured threshold (e.g., Cohen's Kappa < 0.6), the harness should automatically collect the last N scored items, group them by rubric section, and invoke this prompt with the full rubric text, the score matrix, and the divergence threshold. Validate the output against a strict JSON schema that requires rubric_sections (array of objects with section_id, clarity_score, divergence_hotspot, and rewording_suggestions) and diagnostic_summary (object with primary_cause, confidence, and recommended_actions). If the output fails schema validation, retry once with a more explicit [OUTPUT_SCHEMA] constraint injected into the prompt. Log every invocation—input parameters, raw output, validation result, and retry count—so that the diagnostic trail is auditable. For high-stakes evaluation pipelines (e.g., safety scoring, regulatory compliance checks), route recommended_actions that suggest rubric changes to a human review queue before any automated rubric update is applied.

Avoid running this diagnostic on every evaluation batch. The prompt is designed for investigation, not continuous monitoring. Overuse will generate noise and erode trust in the diagnostic signal. Instead, gate invocation on a statistical process control rule: trigger only when agreement metrics breach a control limit for two consecutive evaluation windows. Pair this prompt with the Inter-Rater Agreement Score Calculation Prompt Template to produce the input score matrix and the Disagreement Root Cause Analysis Prompt Template to drill into specific items flagged as divergence hotspots. The output of this diagnostic should feed into a rubric versioning system—each clarity report becomes evidence for a rubric change proposal, linking specific phrases to measured judge disagreement.

IMPLEMENTATION TABLE

Expected Output Contract

Fields, format, and validation rules for the rubric clarity and judge divergence diagnostic report. Use this contract to parse, validate, and store the model's output before downstream analysis.

Field or ElementType or FormatRequiredValidation Rule

diagnostic_report_id

string (UUID v4)

Must match regex ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$

rubric_sections

array of objects

Array length must equal the number of sections in [RUBRIC_TEXT]. Each object must contain the keys: section_id, section_text, clarity_score, divergence_hotspot, rewording_suggestions

rubric_sections[].section_id

string

Must match a section identifier extracted from [RUBRIC_TEXT] delimiters or numbered headings

rubric_sections[].clarity_score

number (float)

Must be between 0.0 and 1.0 inclusive. Check: 0.0 <= score <= 1.0

rubric_sections[].divergence_hotspot

boolean

Must be true or false. If true, the rewording_suggestions array must contain at least one item

rubric_sections[].rewording_suggestions

array of strings

If divergence_hotspot is false, array must be empty. If true, array must contain 1-3 non-empty strings

judge_disagreement_patterns

array of objects

Each object must contain: pattern_label, affected_section_ids, severity, evidence_excerpts. severity must be one of: low, medium, high, critical

overall_clarity_assessment

string

Must be one of: poor, fair, good, excellent. Must align with the mean of all clarity_scores: poor < 0.4, fair 0.4-0.6, good 0.6-0.8, excellent > 0.8

PRACTICAL GUARDRAILS

Common Failure Modes

When diagnosing why LLM judges diverge, ambiguous rubrics are the most common root cause. These cards identify the specific ways rubric clarity breaks down and how to guard against each failure mode before it contaminates your evaluation pipeline.

01

Vague Adjectives Cause Score Collapse

What to watch: Rubric criteria using words like 'good,' 'clear,' or 'accurate' without operational definitions cause judges to default to mid-scale scores. Two judges reading 'the response should be clear' will apply completely different thresholds. Guardrail: Replace every subjective adjective with a behavioral test. Instead of 'clear,' specify 'the response states the conclusion in the first sentence and defines all acronyms on first use.'

02

Overlapping Score Bands Create Boundary Disputes

What to watch: When adjacent score levels share descriptors (e.g., Score 3: 'mostly complete,' Score 4: 'complete'), judges split on borderline cases and agreement drops sharply at boundaries. Guardrail: Make each score level mutually exclusive with a single distinguishing condition. Use 'Score 3: addresses all required fields but omits one optional field. Score 4: addresses all required and optional fields.'

03

Missing Negative Examples Enable Leniency Drift

What to watch: Rubrics that only describe what good looks like leave judges without anchors for failure. Over time, judges drift toward leniency because they lack concrete counterexamples. Guardrail: Include at least one annotated negative example per score level showing what disqualifies an output from reaching that level. Pair each positive criterion with an explicit violation condition.

04

Implicit Context Assumptions Produce Systematic Bias

What to watch: Rubric writers embed assumptions about domain knowledge, user intent, or output format that judges don't share. A criterion like 'the response should be professional' means different things in legal, medical, and casual support contexts. Guardrail: Explicitly define the evaluation context in the rubric preamble. State the audience, use case, and format expectations before any scoring criteria. Test the rubric with judges from different base models to surface hidden assumptions.

05

Compound Criteria Mask Individual Failures

What to watch: Rubric items that bundle multiple requirements into one score (e.g., 'response is accurate, concise, and well-formatted') force judges to average incompatible dimensions. One judge weights accuracy higher while another weights formatting, producing divergence with no clear root cause. Guardrail: Decompose every compound criterion into independently scored atomic checks. If you can't score it with a single yes/no question, split it further.

06

Unscored Examples Leak Into Judge Reasoning

What to watch: Few-shot examples in the judge prompt that aren't explicitly tied to rubric criteria cause judges to pattern-match on surface features rather than apply the scoring rules. A well-formatted example can inflate scores for poorly reasoned outputs that happen to look similar. Guardrail: Audit every few-shot example for criterion coverage. Label each example with the specific rubric criteria it demonstrates. Remove examples that don't directly illustrate a scoring distinction.

IMPLEMENTATION TABLE

Evaluation Rubric

Criteria for testing whether the Rubric Clarity and Judge Divergence Diagnostic Prompt produces actionable, trustworthy output before integrating it into your evaluation pipeline.

CriterionPass StandardFailure SignalTest Method

Rubric Section Extraction

All rubric sections from [RUBRIC_TEXT] are identified and listed with unique IDs

Missing sections or duplicate IDs in the output

Parse check: count of sections in output matches manual count of sections in [RUBRIC_TEXT]

Clarity Score Assignment

Each section receives a clarity score on the defined [CLARITY_SCALE] with a justification grounded in the rubric text

Scores are missing, outside the defined scale, or justifications are generic and not linked to specific phrases

Schema validation: score field is present, within [CLARITY_SCALE] range, and justification field is non-empty and contains a quoted phrase from [RUBRIC_TEXT]

Divergence Hotspot Flagging

Sections with clarity scores below [DIVERGENCE_THRESHOLD] are flagged as divergence hotspots

A section with a low clarity score is not flagged, or a high-clarity section is incorrectly flagged

Logic check: for each section, if clarity_score < [DIVERGENCE_THRESHOLD], hotspot_flag must be true

Judge Disagreement Linking

Each flagged hotspot includes a hypothesis linking ambiguous rubric language to specific judge disagreement patterns from [JUDGE_SCORE_MATRIX]

Hotspot lacks a hypothesis, or the hypothesis does not reference a specific disagreement pattern from the input data

Content check: LLM-as-judge eval verifies that the hypothesis field for each hotspot references a specific judge pair and score delta from [JUDGE_SCORE_MATRIX]

Rewording Suggestion Quality

Each flagged hotspot includes at least one concrete rewording suggestion that reduces ambiguity without changing the scoring intent

Suggestion is empty, is a trivial synonym swap, or fundamentally alters the scoring standard

Human review: domain expert confirms that the rewording reduces ambiguity and preserves the original scoring intent for a random sample of 3 hotspots

Output Schema Compliance

Output is valid JSON matching the [OUTPUT_SCHEMA] with all required fields present

JSON is malformed, or required fields like section_id, clarity_score, or hotspot_flag are missing

Schema validation: parse the output and validate against the [OUTPUT_SCHEMA] using a JSON Schema validator

No Hallucinated Sections

All section IDs and quoted text in the output can be traced back to the provided [RUBRIC_TEXT]

Output contains a section ID or quoted phrase that does not exist in the input rubric

Groundedness check: for each section_id and quoted phrase in the output, verify an exact match exists in [RUBRIC_TEXT]

Actionable Summary

The top-level summary prioritizes the top 3 hotspots by severity and suggests a remediation order

Summary is a generic restatement of findings without prioritization or actionable next steps

Eval check: LLM judge verifies that the summary contains a ranked list of at least 3 hotspots with a specific remediation action for each

ADAPTATION OPTIONS

Adapt This Prompt

How to adapt

Start with the base prompt and a small sample of 10-20 scored outputs where judges disagree. Remove the statistical rigor checks and focus on the core diagnostic loop: feed rubric sections + disagreement samples, ask for clarity scores and rewording suggestions. Use a single frontier model as the diagnostic judge.

Watch for

  • The diagnostic judge hallucinating disagreement patterns that aren't in the data
  • Overconfidence in clarity scores without human verification
  • Skipping the rewording suggestions and only producing scores
Prasad Kumkar

About the author

Prasad Kumkar

CEO & MD, Inference Systems

Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.

His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.