The Single Quality Number That Doesn't Exist
Somewhere in your company there is a slide with one number on it. "AI quality: 87." Last quarter it said 85, so the slide is green. Meanwhile, your on-call channel is full of screenshots of the assistant confidently inventing refund policies for your largest enterprise customer. Both things are true at once, and the slide is the one lying.
The executive request behind that slide is completely reasonable: give me one score I can track, so I know whether the thing is getting better or worse. It works for revenue. It works for uptime. It does not work for an AI feature, because an AI feature's quality is not a scalar — it is a distribution over inputs, users, and time. Averaging that distribution into a single number doesn't summarize it; it destroys precisely the information a decision-maker needs.
This post is about the gap between those two facts: why the mean of your eval suite hides the regressions that actually hurt you, what to report instead, and how to present a legitimately noisy metric to a board-deck audience without torching your credibility the first week it moves down.
The Average Is Where Regressions Go to Hide
Start with the arithmetic. Suppose your eval suite has 1,000 cases and your overall pass rate is 87%. You ship a new prompt, rerun the suite, and get 88%. Ship it, right?
Here is one way to get that result: the new prompt improves easy, high-frequency cases by three points and drops your "multi-step refund with a partial chargeback" segment — 40 cases — from 75% to 40%. The suite-level average goes up. The segment your support team escalates most goes off a cliff. The single number didn't just fail to catch the regression; it actively reported it as an improvement.
This is not a contrived edge case — it's the default behavior of averages over heterogeneous data. A 7.5/10 mean score is perfectly compatible with 20% of cases scoring 2/10, and those bottom-quintile cases are your production incidents. Practitioners who study model failures keep finding the same thing: failures cluster around specific input patterns, and one identified pattern in the failures is worth more than a percentage-point improvement in the mean.
Statisticians have named this trap several times over. Simpson's paradox — a trend that appears in aggregate data and reverses within every subgroup — shows up in real deep learning systems, not just textbooks; a post-mortem of a deep learning contest found the aggregate ranking of models inverted once results were disaggregated. Anscombe's quartet makes the same point visually: four datasets with identical means, variances, and correlations that look nothing alike when plotted. The monitoring community absorbed this lesson a decade ago. The AI-product community is re-learning it now.
The structural reason is worth stating plainly, because it tells you the fix. An average weights every eval case equally. Your business does not. A regression on the 4% of traffic that comes from your top-tier customers matters more than an improvement on the 40% of traffic that is casual tire-kicking. Any single number that doesn't encode those weights will be wrong exactly when the stakes are highest — and any single number that does encode them is no longer a quality metric, it's a business-priority negotiation frozen into a formula.
Your Infra Team Already Solved This Problem
If this sounds familiar, it's because site reliability engineers fought this exact war over latency and won it years ago. Nobody credible reports average latency anymore. The mean of a right-skewed latency distribution gets dragged toward the fast bulk of requests and hides the tail entirely — your average might be 50ms while one in a hundred users waits three seconds and bounces. So the discipline standardized on percentiles: p50 for the typical experience, p95 for the slow-but-common tail, p99 for the painful edge.
The load-bearing insight was cultural, not mathematical: executives learned to read percentiles. "p99 latency" appears in board decks at every serious infrastructure company, and nobody's eyes glaze over. That happened because engineers stopped presenting percentiles as statistics and started presenting them as populations of users: p99 is "one in a hundred requests," and at your traffic volume, that's eleven thousand angry sessions a day.
AI quality reporting should steal this playbook wholesale:
- Report the floor, not the middle. The eval equivalent of p99 is your worst-segment score or bottom-decile case score. "Our weakest segment scores 61%" is more decision-relevant than "our average is 87%."
- Never average away structure. SREs learned you cannot average percentiles from different servers — you have to aggregate the underlying histograms. The eval version: never merge segment scores into a blended number across releases; compare segment-to-segment.
- Name the tail in units of customers. "The bottom 5% of interactions" lands harder as "roughly 400 conversations a day, concentrated in billing disputes."
The latency analogy also sets expectations correctly for how the metric behaves: p99 is noisy week to week, everyone knows it, and nobody panics over a single wiggle. That's exactly the relationship you want executives to have with eval scores.
The Number Moves Even When Nothing Changed
There's a second, nastier problem with the single quality score: it moves when you didn't touch anything. LLM outputs are stochastic, and LLM-as-judge evaluation stacks the judge's nondeterminism on top of the product's. Teams have documented the same eval suite scoring 77% one day and 63% the next with zero code changes — provider-side variance, judge drift, and sampling noise compounding into a fourteen-point swing.
If you've been reporting a single number, this is where trust dies. The score drops four points, an executive asks what broke, the honest answer is "nothing, that's within noise," and now every future movement of the metric — including real regressions — gets discounted as noise. You've built a smoke alarm that goes off randomly, and everyone has learned to ignore it.
The remedies are standard statistics, unevenly applied:
- https://www.braintrust.dev/articles/llm-evaluation-metrics-guide
- https://scale.com/blog/smoothing-out-llm-variance
- https://www.sunnybak.net/blog/precision-based-sampling
- https://one2n.io/blog/sre-math-percentiles-in-sre-why-averages-lie-about-latency
- https://www.magnusson.io/post/ansombe-monitoring/
- https://arxiv.org/abs/2106.00734
- https://arxiv.org/abs/2306.08167
- https://arxiv.org/abs/2203.14960
- https://github.com/HazyResearch/data-centric-ai/blob/main/evaluation.md
- https://agility-at-scale.com/ai/strategy/performance-metrics-and-kpis/
