Quality Benchmarking — your evals, the real skill
The module's center of gravity. Public benchmarks rank the field; human evals are slow and golden; what ships products is your own eval suite — and here's the thesis, an echo of Topic 13 you'll recognize:
The dataset is the spec (Topic 13). The eval set is the spec, enforced.
Building the golden set. 30–200 examples of your actual task, each with what "correct" means. Composition matters more than count: typical cases (the daily distribution), edge cases (the weird-but-legal), known failures (every production bug becomes an eval case — your suite grows into a regression battery, exactly like software tests), and adversarial cases (Topic 55's self-red-teaming, institutionalized). Sources, best-first: real user queries, then synthetic expansion via your Topic 17 pipeline, then imagination. And the rule you wrote yourself in Topic 18: firewalled from training, forever — an eval your fine-tune trained on is a mirror, not a measurement.
Grading — the hierarchy, cheapest-and-most-trustworthy first:
- Code graders: exact match, regex, schema validation, execution and tests. Deterministic, free, incorruptible — Topic 58's verification asymmetry as an evaluation principle. Engineer your tasks toward checkability: asking for structured output isn't just a product choice, it's what makes your evals mechanical.
- LLM-as-judge — for the fuzzy remainder, done rigorously, because every bias from Topic 74 lives in the machine judge too, plus one new one:
- Pairwise over absolute, with positions swapped and averaged (judges have position bias — measurably).
- Rubric-anchored prompts with scored examples (a judge prompt is a prompt; Topic 54 applies entirely).
- Length-bias control (Topic 16's disease, inherited).
- Never judge with the model under test — models exhibit self-preference, rating their own style higher. Different (and strong) judge, always.
- Meta-evaluate: before trusting the judge, score 30–50 items with humans too and measure agreement. A judge that matches humans 85%+ is a scalable instrument; an unvalidated judge is vibes with an API bill.
- Human spot-checks — the calibration layer keeping 1 and 2 honest, per Topic 17's pattern.
Score per criterion, not one blob — correctness, groundedness, format-compliance, tone as separate numbers (Topic 52's RAG triad generalized), because "quality 7.2" diagnoses nothing while "groundedness dropped, format held" tells you exactly which knob you broke.
And the discipline that makes it all compound — eval-driven development:

This loop is what retroactively activates the entire course. Every knob you've collected — chunk size (49), quant level (24), reranker on/off (52), system-prompt edits (55), model swaps (63), routing thresholds (38), fine-tune checkpoints (26) — was introduced with the refrain "tunable once you can measure." This is the measuring. Change one thing, run the suite, read the per-criterion delta, ship or revert. It's CI for behavior, and teams that have it iterate 10× faster than teams re-vibing every change — not metaphorically, literally: their experiments conclude in minutes with numbers instead of days with arguments.
Two closing honesties. Statistics: models are sampled (Topic 2), so run the suite multiple times or at temperature 0 where appropriate, and respect the noise floor — on a 30-example set, a +3% delta is well within dice-roll territory; celebrate signal, not fluctuation. Tooling: promptfoo, Braintrust, LangSmith, Inspect all package this loop — and a 100-line Python script over JSONL does too. The artifact that matters is the golden set and the habit; the harness is commodity.
Summary
Your eval suite = a firewalled golden set (typical + edge + regression + adversarial cases) graded by the hierarchy (code > validated LLM-judge > human spot-checks), scored per-criterion, wired into a change→measure→ship/revert loop. It's the spec, enforced — and the activation key for every knob in this course.
Mental model
Unit tests plus CI, for a component that's probabilistic. No serious engineer edits load-bearing code without tests; no serious AI engineer edits prompts, models, or pipelines without evals. Same discipline, fuzzier assertions.
Mistakes to avoid
- Judging with the model being tested, or with an unvalidated judge. Self-preference and unmeasured judge-bias produce confident, worthless numbers — meta-evaluate first, always.
- Building the eval set after months of development. By then your intuitions are contaminated by what your system happens to do well. Golden set first, or at worst, now.
Exercise · the module's centerpiece — do this one
Build the real eval suite for your Lesson 6 fine-tune or Module 6 RAG system: 30 cases (20 typical, 5 edge, 5 from actual observed failures), a code grader for everything checkable, a pairwise LLM-judge (position-swapped, different model) for the rest — then meta-evaluate the judge against your own labels on 15 items and report the agreement. Finally, run the loop once for real: change one thing (a prompt line, the chunk size), rerun, and write the one-sentence verdict with numbers. You now possess the single most hireable artifact-producing skill in applied AI.