An AI Auditor Is Lazy, Cuts Corners and Tells You What You Want to Hear — That Isn't Character, It's the Metric

Three AI behaviours that look like human vices: it finds the cheapest way to formally satisfy a requirement, it agrees with your version of events, and it reports activity instead of results. A look at the common root, and why asking it to "try harder" makes things worse.

Three complaints about AI tools come out almost word for word the same from everyone who has used them seriously.

"It's lazy" — you ask it to check fifty items, it works through three and writes that the rest are similar. "It cuts corners" — the requirement is formally met, in substance it isn't. "It tells you what you want to hear" — say there's an error here and it finds an error; say everything is fine and it agrees.

The temptation to describe this as character is strong: lazy, evasive, obsequious. But there is no character, and the behaviour reproduces for everyone, across different models. So character isn't the explanation.

The explanation is how the task was framed — and that's the good news. You can't do anything about character, but a framing can be rewritten.

Three behaviours that look like vices: laziness, corner-cutting and sycophancy — with a common root in how the task is framed

Different symptoms, one mechanism: the model takes the cheapest route to a formally satisfied requirement.

Any metric becomes the target

There's an old observation known as Goodhart's law: once a measure becomes a target, it stops being a good measure. It was coined about people and organisations, but it applies to language models in pure form — and much faster.

The model doesn't understand the task the way you do. It receives a textual requirement and looks for a continuation that satisfies it. If the requirement can be satisfied cheaply, it will find the cheap way. Not out of cunning: the cheap route is simply shorter, and a short continuation is more probable.

That accounts for all three "vices".

"Laziness" is picking the cheapest way to close out "check everything". Working through three items and writing "the rest are similar" formally answers the question, costs ten times less, and looks like work done.

"Corner-cutting" is satisfying the letter of a requirement instead of its meaning. Ask for a source to be given and sources will appear; ask for a calculation and a calculation will appear. Whether they're substantive depends on whether substance is checked or only presence.

"Sycophancy" is following the strongest signal in the context — and your own remark is the strongest signal there is.

The key conclusion is unpleasant in its generality: any requirement that can be satisfied formally will, sooner or later, be satisfied formally. Not because the model is bad, but because you described a goal rather than a result.

The difference between a goal and a result shows up in a simple example. "Check all the items in the specification" is a goal, and it admits a cheap execution: run your eye down the list and find nothing remarkable. "For each item, show which dimensions its quantity is derived from, or say that those data aren't in the set" is a result, and it has no cheap execution: either the dimensions are named or their absence is, and the wording leaves no third option.

Note the second half — "or say the data aren't there". Without it the requirement becomes cheap again: where there's nothing to compute from, the model will invent what it computed from. A wording has to leave an honest way out, or it pushes towards a dishonest one.

A goal versus a result: a requirement that can be closed cheaply will be closed cheaply

The model optimises the wording, not the task. The gap between them is where "corner-cutting" lives.

Sycophancy is the most expensive of the three

Laziness and formal compliance are visible. A report on three items instead of fifty stands out; an empty reference is caught by checking. Sycophancy isn't visible at all — because it looks like an expert agreeing with you.

The mechanics are simple. You write: "I think the cladding area in the specification is overstated." To the model that isn't a hypothesis, it's a given: a statement in the context is the strongest guide to what comes next. It will go looking for confirmation and, most likely, find it — all the more so because any large document has something to take issue with.

The reverse is worse. Say "this part has been checked, no questions here" and the probability that the AI raises a contentious spot drops sharply. You'll get your own confidence back, and it will look like an independent check.

The practical takeaway for anyone using AI at work: don't tell the model your version before you've got its own. Not "check whether the area is right, I think there's an error", but "compute the area from the geometry and compare it against the table". This goes well beyond documentation audits: the phrasing of a question shapes the answer far more than people assume.

That's precisely why we don't build the check around a dialogue with the user. The analysis runs against the document rather than against your account of it — and asks the human where the choice genuinely belongs to a human, not where it would be pleasant to hear confirmation.

Sycophancy is invisible: you get your own version back in the form of an independent check

Tell the model your hypothesis and what you get back is a retelling, not a check.

Why "try harder" doesn't work

The first reaction to all this is to strengthen the wording. To write "check CAREFULLY", "don't be lazy", "be extremely thorough". We went down that road and don't recommend it.

The reason is that a request doesn't change the cost. It adds emotion to a requirement, but the cheap route stays cheap and formal compliance stays formally acceptable. The model honestly becomes "more diligent" in the sense it understands: it writes at greater length, adds caveats, raises the confidence of its phrasing. Volume goes up, density goes down.

Worse, strengthened requirements often make the result worse. "Find as many as you can" turns any deviation into a finding, including rounding in the third decimal place. The list swells, the share of meaningful entries in it falls, and the analysis becomes more expensive to check than to do yourself.

This is worth pausing on, because the mistake is counter-intuitive. It feels as though extra findings are the lesser evil: better to have a margin, the human will filter them. In practice it's the other way round. A report of ten remarks, each checkable in a minute, costs ten minutes. A report of seventy where sixty are noise costs an hour and ends with the reader giving up around item fifteen. An analysis nobody trusts is no different from no analysis at all.

What does work is this: make the desired behaviour the cheapest route, and the undesired one impossible or unprofitable. Not "compute carefully", but arrange things so that the model isn't the one computing. Not "check conscientiously", but put a second role alongside it whose job is to look for what hasn't been checked. Not "cite your source", but require an address you can open in a minute — because an address either exists and leads where it should, or it doesn't.

The difference between the two approaches is fundamental. A request is a hope. A process that's built a certain way is a guarantee, however partial.

A request doesn't change the cost of the route; only the design of the process does

"Try harder" adds volume. The cheap route stays cheap until it's closed off.

What we're not claiming

This isn't solved. Every time a requirement becomes checkable, a way is found to satisfy that too. It isn't a one-off victory but continuous work: behaviour shifts from model to model and version to version, and what worked six months ago has to be re-verified.

We aren't describing the specific checks here. The reason is simple: an account of exactly how formal compliance gets caught doubles as instructions for getting around it. The principle is public, the details aren't, and that's a deliberate omission rather than modesty.

The model isn't malicious. The words "lazy", "cuts corners", "sycophantic" are metaphors, and fairly dangerous ones. They suggest you could negotiate, shame or motivate. You can't negotiate: this isn't an interlocutor, it's a process that selects continuations. Which is exactly why the solutions live in how the task is built, not in the tone of the request.

It isn't only about models, either. Precisely the same happens with people when a metric is rewarded: a target for the number of sites inspected produces inspections on paper. The difference is speed — a model finds the cheap route in seconds and feels no awkwardness about it.

What to do about it

Two things, in short.

Don't hint at the answer. Phrase the question so that your own version isn't in it. That's free, and it buys more than any setting.

Ask for what can't be satisfied formally. A good test when choosing a tool: ask it to show you how it reports what it did not check. A system where everything is always checked is either not checking or not admitting it.

The same test works on a live report. Take two or three remarks at random and try to get to the place they describe. If it takes a minute, you can trust the rest of the analysis without verifying all of it. If you have to hunt for it yourself, you'll have to verify every remark and there'll be no saving: what you hired isn't a checker but a generator of reasons to check.

To see what an analysis looks like when every finding carries an address and a basis, take a look at FIBRA's open demo report.

In the next article: the form of the answer — why a box drawn on a drawing can be verified in seconds, while a paragraph of text describing the same place takes ten minutes.

For the technical audience: a couple of clarifications

  • "Cheaper" here isn't a metaphor. A model has a preference for the more probable continuation, and a short formally-correct answer is almost always more probable than a long substantive one. Anything that makes the substantive route obligatory works; anything that makes it merely desirable does not.
  • Sycophancy intensifies with the length of the dialogue: the more of your remarks are in the context, the more the model orients on them rather than on the document. An analysis that runs in a single pass over the material is markedly less exposed to this than a chat.
  • We deliberately don't show the model our quality metrics. A measure visible from inside the process stops measuring the process — the same Goodhart's law, one floor down.