Interface Patterns for Uncertain Output

The pattern ladder

Patterns, ordered by how much they ask the user to trust the system. Choose by the cost of an error, not by how impressive the interaction looks.

📅 Timeline

SuggestThe system offers; the user decides. Lowest risk, lowest leverage. A proposed category, a suggested reply, an autocomplete.

DraftThe system produces something substantial the user edits before it takes effect. The highest-value pattern for most products.

Pre-fill with overrideThe system fills in a value already applied; the user changes it if wrong. Higher leverage than suggesting, because inaction accepts.

Act with undoThe system acts; the user can reverse it. Requires that reversal is genuinely complete and easy.

Act silentlyThe system acts and the user never sees it. Only where errors are cheap and caught elsewhere.

Most products should sit at draft or pre-fill. Teams reach for act silently because it demonstrates the technology most impressively, and it is the pattern with the least tolerance for the error rate the technology actually has.

Why drafts win

The draft pattern is the most consistently successful in AI products, and the reasons are worth understanding because they generalise.

It matches what the technology is good at. Producing a competent first attempt is exactly what these systems do well. Being reliably correct is not.

It keeps the human accountable, which resolves the legal and organisational question quietly.

It fails gracefully. A poor draft costs the user the time to rewrite it — annoying, not damaging. Compare with a poor autonomous action, which costs an incident.

It generates the data you need. Every edit is a labelled example of what the system produced against what a competent human actually wanted. That corpus is the most valuable asset an AI product accumulates, and it only exists if the interface captures edits rather than replacements.

Design the draft so editing is natural: inline, in place, without a mode switch. If the user's fastest path is to delete everything and start again, you have built a suggestion that looks like a draft, and you will capture no signal.

Make verification cheap

The single highest-leverage design move in an AI product: reduce the cost of checking an answer.

If verifying takes as long as doing the work, the product has no value even at high accuracy. If verification is nearly free, the product remains valuable even when the system is often wrong.

Concretely:

Cite the source. For anything retrieved, show where it came from and link to it. The user checks the one claim they doubt rather than the whole answer.
Show the extract, not just the conclusion. "Termination clause: 90 days' notice" beside the sentence it was taken from.
Highlight what changed. Where the system edits, show the diff.
Expose the input the system used. Users seeing that it read the wrong document diagnose instantly what would otherwise look like a nonsensical answer.
Order by confidence. Put the shaky items where attention naturally goes.

Citation deserves particular emphasis. It converts an unverifiable assertion into a checkable one, and it changes what the user does when they disagree: without a source they conclude the system is unreliable; with one they check and often find the source was ambiguous, which is a different and more productive conversation.

Confidence, carefully

Showing confidence is useful and easy to do badly.

Numeric confidence is usually a mistake. "87% confident" implies a precision that is not there, and users have no calibration for what 87 means. Worse, model confidence and correctness are related but not equivalent — a system can be confidently wrong, which is the entire hazard.

Banded confidence works better. High, medium, low — mapped to visible behaviour: high goes through, medium is flagged, low is routed to a person.

Behavioural confidence works best of all. Rather than telling the user how sure the system is, act differently. Auto-apply when confident, present as a draft when less so, ask a clarifying question when genuinely unsure. The user learns the system's reliability from how it behaves, which is more honest than a number.

The same underlying capability — flagging clauses that deviate from a standard position — presented two ways.

Interface A. A list of flagged clauses with a risk score against each. The user clicks to see the clause. Nothing indicates why it was flagged or what the standard position is.

What happens: reviewers cannot evaluate a flag without opening the contract, finding the clause, recalling the standard position and forming their own view — which is the entire original task. The tool has told them where to look, which is a modest saving, while asking them to trust a score they cannot interrogate. Adoption depends on whether the flags feel right, which is a weak foundation.

Interface B. Each flag shows three things side by side: the clause as written, the standard position it deviates from, and a one-line statement of the difference. A single control marks it accepted or escalated.

What happens: the reviewer forms a judgement in seconds without leaving the interface, because everything needed for the decision is present. Verification cost has collapsed. And crucially, when the tool is wrong the reviewer sees why immediately — the clause was unusual but acceptable in this context — which builds calibrated trust rather than eroding it.

The models could be identical. Interface B is a substantially better product, and the difference is not intelligence but whether the information required to check the answer is present at the moment of checking.

There is a second-order effect worth noting. In Interface B, the accept/escalate control produces a clean labelled signal on every flag. In Interface A, the reviewer's real decision happens outside the tool, so the product learns nothing from its own use. Verification design and data strategy are the same design.

❓ Knowledge Check

Why is the draft pattern more consistently successful than autonomous action in AI products?

📚 Flashcards1 / 6

Term

The pattern ladder

Click to flip

Definition

Suggest, draft, pre-fill with override, act with undo, act silently — ordered by how much trust each demands. Choose by the cost of an error, not by how impressive the interaction looks.

Click to flip back

💡Key Takeaway

Choose an interaction pattern by the cost of an error, not by how impressive it looks — most products belong at draft or pre-fill rather than autonomous action. Drafts win because they match what the technology does well, keep a human accountable, fail cheaply and capture every edit as training signal. Above all, make verification nearly free through citation, extracts and visible inputs, and express confidence through behaviour rather than a number that implies precision the system does not have.