Classic software tests have a pleasant property: they know the right answer. A price is correct or it is not, a form validates or it does not, an HTTP status is 200 or 500. This very unambiguity is missing as soon as a language model is at work in an application – that is, an AI model that generates texts. Whether a chat response is helpful, polite and factually correct cannot be checked with a simple comparison.

Out of this problem an approach has emerged that is currently being discussed in the testing community: LLM-as-a-Judge. The idea behind it is to have a language model evaluate the outputs of another model – so the test subject is assessed by a second AI instead of by humans alone.

Why an AI as an examining instance at all?

The practical trigger is scaling. Anyone who builds an AI function into a website or a portal is not dealing with a handful of test cases, but with an open set of possible inputs. Users formulate freely, ask follow-up questions, make typos, switch languages.

Assessing such responses manually is time-consuming. A professionally sound review of a few hundred dialogues ties up specialist departments for days. This is exactly where the approach comes in: an evaluating model works through the cases according to predefined criteria and delivers an assessment together with a justification. People then no longer check everything, but rather on a sample basis and where the assessment is uncertain or negative.

What is actually assessed here

What is decisive is not the model, but the question one puts to it. A judgement such as "is the answer good?" produces little of use. The approach only becomes useful once criteria are formulated so precisely that a human would also arrive at a comprehensible result with them. Typical review dimensions in web projects are:

  • Factual fidelity to the source: Does the answer match the content stored in the editorial system or in the knowledge database?
  • Completeness: Have all parts of a multi-part question been answered?
  • Tone and address: Does the answer match the company's language policy?
  • Boundaries: Does the system reliably refuse information that it should not give – such as legal advice or binding price statements?

These criteria are not a technical detail, but a professional determination. They belong in the same discussion as acceptance criteria in a requirements specification – and they should come from the people responsible for the content, not from development alone.

The obvious weak point

An evaluating language model is itself a language model. It can err, it can judge inconsistently, and it can carry its own preferences into the assessment. A judgement delivered with a plausibly sounding justification appears more robust than it is – that is the real risk in day-to-day project work.

From this follows a basic rule: LLM-as-a-Judge does not replace verification, but prioritises human attention. The approach makes sense as a filter and as an early warning system, not as the final instance before go-live.

In practice, it has proven worthwhile to calibrate the automatic assessment itself: a manageable set of cases is assessed by experts, the same cases run through the review model, and the agreement is compared. If it deviates strongly, the problem is usually not the model but the criteria.

Where the approach fits into the development process

LLM-as-a-Judge becomes interesting in connection with the continuous integration pipeline – that is, the automated chain of build, test and deployment. Just as unit tests run on every commit, an evaluation run can be executed over a fixed set of sample dialogues.

The benefit lies less in the absolute score than in the change. After a model change, an adjusted prompt or a change to the knowledge base, the comparison shows whether the quality has remained stable. This is the point at which the approach becomes attractive for projects with frequent releases: it makes regressions visible that would otherwise only be noticed through customer complaints.

What is important here is a test dataset that does not consist only of sample cases. Edge cases, ambiguous questions and deliberately provocative inputs belong in it, otherwise the test only confirms what works anyway.

What decision-makers should clarify

Anyone commissioning an AI function should commission quality assurance from the outset. Three questions help with this:

  1. By what do we measure quality? Without documented criteria there is no robust acceptance – neither manual nor automated.
  2. Who decides in case of doubt? A named professional instance is needed that has the final say on negative or unclear assessments.
  3. What happens to the data? Evaluation runs process sample dialogues. Whether real user data may flow into them and which model processes it is a data protection question, not just a technical one.

The cost aspect is equally relevant: every automated assessment is an additional model call. With large test sets this adds up, which is why it is worth deliberately defining the scope and frequency of the runs instead of checking everything on every commit.

Classification

For web and software projects, the approach means above all one thing: quality assurance shifts from checking unambiguous results to checking criteria. The effort moves forward – into the definition of what a good answer is.

Those who do this work can ship AI features faster and with less guesswork; those who skip it merely automate a judgement that nobody on the project really trusts.

Sources