The Verification Cost Problem

An assistant that produces output a user must fully verify has saved nothing, and may have cost something, since verifying someone else's work is often slower than doing it yourself. The entire value proposition rests on an asymmetry: checking must be substantially cheaper than producing. Whether it is depends on the task, and where it does not hold, no amount of model improvement fixes it.

Where the asymmetry holds

Verifiable by construction. Code that compiles and passes tests, a query that returns the expected shape, a calculation that can be checked. The verification is mechanical and cheap, which is why programming assistance has been the most successful application category.

Recognition beats generation. Reviewing a written paragraph is faster than writing it, and choosing between three designs is faster than producing one. Where the hard part is production and the easy part is judgement, an assistant helps.

Search with citations. Checking whether a claim appears in a linked source is far cheaper than finding the source, so retrieval with verifiable pointers preserves the asymmetry that pure generation destroys.

Where it inverts

Claims requiring independent research. A confident factual assertion with no source costs more to verify than to look up directly, so the assistant has added a step.

Long outputs with sparse errors. Reading two thousand words to find one wrong sentence is expensive, and the expense is paid even when there is no wrong sentence. Users respond by not reading carefully, which is over-reliance produced by the output format.

Subtle errors in plausible output. A code change that looks right and has an off-by-one, a summary that omits a crucial qualification. These are cheap to produce and expensive to catch, which is the worst quadrant.

Aggregation over many sources. Checking a synthesis requires re-reading the sources, which is the work the assistant was supposed to do.

Designing the asymmetry in

The design goal is to make verification cheap rather than to make errors rare, because the first is achievable and the second is not.

Link every claim to its source at the sentence level. Show a diff rather than a rewritten document. Highlight the low-confidence spans so attention goes where it is needed. Produce structured output that can be validated mechanically. Break long outputs into independently checkable units. Surface what was not found as prominently as what was.

Each of these converts a full read into a targeted check, and each is an architectural decision rather than a presentational one.

When it breaks

Verification cost is invisible in productivity measurement. Time to produce a draft falls, time to verify rises, and only the first is measured. Studies that find no net productivity gain frequently find exactly this pattern, and the metric that matters is time to a trusted result rather than time to an output.

Users stop verifying when it is expensive. The rational response to costly verification is to skip it, so an expensive-to-check output produces over-reliance regardless of how the interface is worded. The behaviour follows the cost, not the warning.

Verification requires expertise the user may lack. A non-expert cannot check an expert output, so an assistant that extends someone beyond their competence has produced output nobody in the loop can evaluate. This is the case where the asymmetry argument fails completely, and it is the one where assistants are most enthusiastically deployed.