The LLM-as-Judge Pattern

Why Automated Evaluation Is Necessary

The Core Idea: One LLM Evaluates Another

JUDGE_SYSTEM_PROMPT = '''
You are an expert evaluator of AI-generated responses.
Given a question and an AI-generated answer, score the answer on:
- Correctness (0-5): Is the information factually accurate?
- Completeness (0-5): Does it fully address the question?
- Clarity (0-5): Is it easy to understand?
Return a JSON object with scores and a brief rationale.
'''

Writing a Judge Prompt

def build_judge_prompt(question: str, answer: str, reference: str = None) -> str:
    ref_section = f'Reference answer:\n{reference}\n\n' if reference else ''
    return f'''
Question: {question}

{ref_section}Answer to evaluate:
{answer}

Score this answer on correctness (1-5) where:
5 = Completely accurate, no factual errors
3 = Mostly accurate with minor errors
1 = Contains significant factual errors

First explain your reasoning, then provide the score as JSON:
{{"correctness": <1-5>, "rationale": "..."}}
'''

Calling the Judge Model

from pydantic import BaseModel
import instructor
from openai import OpenAI

class JudgeScore(BaseModel):
    correctness: int
    completeness: int
    clarity: int
    rationale: str

judge_client = instructor.from_openai(OpenAI())

def judge(question: str, answer: str) -> JudgeScore:
    return judge_client.chat.completions.create(
        model='gpt-4o',  # Use stronger judge than the model being tested
        response_model=JudgeScore,
        messages=[
            {'role': 'system', 'content': JUDGE_SYSTEM_PROMPT},
            {'role': 'user', 'content': build_judge_prompt(question, answer)}
        ]
    )

Reference-Free vs Reference-Based Judging

# Reference-free: good for open-ended generation
judge_result = judge(question='What is machine learning?', answer=model_answer)

# Reference-based: better for factual QA
judge_result = judge(
    question='What year was Python created?',
    answer=model_answer,
    reference='Python was created by Guido van Rossum and released in 1991.'
)

Controlling Judge Bias

# Anti-verbosity note in rubric:
ANTI_VERBOSITY_CLAUSE = '''
Note: A concise, accurate answer should score higher than a long,
rambling answer that happens to contain the correct information.
Do not reward length for its own sake.
'''

# Position-debiasing for pairwise comparison:
async def debiased_pairwise(q, a, b):
    score_ab = await compare(q, answer_a=a, answer_b=b)
    score_ba = await compare(q, answer_a=b, answer_b=a)
    # A wins if it wins in both orderings
    a_wins = (score_ab == 'A' and score_ba == 'B')
    return 'A' if a_wins else 'B' if (score_ab == 'B' and score_ba == 'A') else 'tie'

Batching Evaluations for Speed

import asyncio

async def batch_judge(qa_pairs: list, concurrency: int = 20) -> list:
    sem = asyncio.Semaphore(concurrency)

    async def judge_one(item):
        async with sem:
            return await async_judge(item['question'], item['answer'])

    return await asyncio.gather(
        *[judge_one(item) for item in qa_pairs],
        return_exceptions=True
    )

Aggregating Judge Scores

import statistics

def summarize_judge_results(scores: list) -> dict:
    correctness = [s.correctness for s in scores if isinstance(s, JudgeScore)]
    return {
        'n': len(correctness),
        'mean_correctness': round(statistics.mean(correctness), 2),
        'median_correctness': statistics.median(correctness),
        'pct_above_4': round(100 * sum(1 for s in correctness if s >= 4) / len(correctness), 1)
    }

Comparing LLM Versions with Judge

async def ab_compare(test_questions: list, version_a, version_b) -> dict:
    a_wins = b_wins = ties = 0
    for q in test_questions:
        answer_a = await version_a.answer(q)
        answer_b = await version_b.answer(q)
        winner = await debiased_pairwise(q, answer_a, answer_b)
        if winner == 'A': a_wins += 1
        elif winner == 'B': b_wins += 1
        else: ties += 1
    total = len(test_questions)
    return {'a_win_rate': a_wins/total, 'b_win_rate': b_wins/total, 'tie_rate': ties/total}

Calibrating Judge Scores Against Humans

from scipy.stats import pearsonr

def calibrate_judge(human_scores: list, judge_scores: list) -> dict:
    corr, p_value = pearsonr(human_scores, judge_scores)
    mean_abs_error = sum(abs(h - j) for h, j in zip(human_scores, judge_scores)) / len(human_scores)
    return {
        'pearson_r': round(corr, 3),
        'p_value': round(p_value, 4),
        'mean_abs_error': round(mean_abs_error, 2),
        'reliable': corr >= 0.7
    }

When Not to Use LLM-as-Judge

# Appropriate uses of LLM-as-judge:
# YES: General helpfulness, clarity, tone, factual accuracy (general knowledge)
# YES: Code correctness for common languages
# YES: Translation quality comparison
# YES: Content safety classification
#
# NOT appropriate:
# NO: Medical/legal/financial accuracy (needs domain expert)
# NO: Evaluating GPT-4o with GPT-4o (same capability ceiling)
# NO: Formal compliance audits (non-deterministic judge)
# NO: Streaming quality at individual token level

Quick Check

Lesson Recap