Why UX Still Matters in the Age of Strong Models

while (world) { observe(); infer(); hallucinate?(); self-correct(); } while (world) { observe(); infer(); hallucinate?(); self-correct(); } while (world) { observe(); infer(); hallucinate?(); self-correct(); }

001101 010011 sigil::bagua seed::entropy trace::mechanical awe::human 001101 010011 sigil::bagua seed::entropy trace::mechanical awe::human 001101 010011 sigil::bagua seed::entropy trace::mechanical awe::human

temperature=0.92 top_p=0.95 sampler=stochastic runtime=deterministic user=astonished temperature=0.92 top_p=0.95 sampler=stochastic runtime=deterministic user=astonished temperature=0.92 top_p=0.95 sampler=stochastic runtime=deterministic user=astonished

☰☱☲☳☴☵☶☷ oracle != truth ritual == interface meaning <- interpretation ☰☱☲☳☴☵☶☷ oracle != truth ritual == interface meaning <- interpretation ☰☱☲☳☴☵☶☷ oracle != truth ritual == interface meaning <- interpretation

seed = hash(question + state); noise = sample(temperature); pattern = deterministic(seed, noise); if (human_can_track === false) mark("mystic"); return explainability_gap(pattern); seed = hash(question + state); noise = sample(temperature); pattern = deterministic(seed, noise); if (human_can_track === false) mark("mystic"); return explainability_gap(pattern);

## Not a person, still persuasive - interface implies intention - language implies confidence - user infers agency => design for interpretability ## Not a person, still persuasive - interface implies intention - language implies confidence - user infers agency => design for interpretability

cast.bagua = pickTrigrams(seed); cast.moonBlocks = deriveHexagram(seed); cast.fortuneSticks = burnModel(intensity); cast.scapula = generateCracks(seed); return readable_fiction(cast); cast.bagua = pickTrigrams(seed); cast.moonBlocks = deriveHexagram(seed); cast.fortuneSticks = burnModel(intensity); cast.scapula = generateCracks(seed); return readable_fiction(cast);

{ "observe": true, "decide": constrained, "act": reversible, "measure": behavior, "learn": weekly } { "observe": true, "decide": constrained, "act": reversible, "measure": behavior, "learn": weekly }

def perceivable_randomness(system): return complexity(system) > attention_budget if perceivable_randomness(llm): user.labels_output = "fate" def perceivable_randomness(system): return complexity(system) > attention_budget if perceivable_randomness(llm): user.labels_output = "fate"

[trace] t=02:13 system murmurs [trace] tokens fall like ash [trace] certainty simulated [trace] mechanism remains [trace] human names it chance [trace] t=02:13 system murmurs [trace] tokens fall like ash [trace] certainty simulated [trace] mechanism remains [trace] human names it chance

Models got better. That part is real.

But if you zoom out from benchmark charts and look at actual product usage, one thing is still true: people do not adopt model quality. They adopt experiences.

I see teams confuse these layers all the time:

model capability
product behavior
user trust

They are related, but not interchangeable.

Better models do not fix unclear interaction design

You can have a great model and still ship a bad product if users cannot answer basic questions fast:

What is this tool for?
What should I type here?
What does this output mean?
What should I do next?

If those answers are not obvious, users bounce. Not because the model is weak, but because the interface asks them to do product design work in real time.

UX is the control plane for AI

When I say UX, I do not mean visual polish first. I mean decision architecture:

how intent is captured
how scope is constrained
how uncertainty is represented
how recovery works when outputs are wrong

This is especially important in AI because outputs are probabilistic. Without good UX, people read confidence where there is only fluency.

Trust is an interface outcome

Users trust systems that are predictable and inspectable.

That means:

show what the system considered
show confidence without fake certainty
give one-click correction paths
preserve user agency on final decisions

If your interface hides uncertainty and forces users to reverse-engineer failures, trust collapses even if answer quality is “technically good.”

The repeat-use test

The real test is not “did it look impressive in demo week.” The real test is “did the same person come back and complete the same job faster next time.”

Repeat usage is mostly a UX problem:

reduced decision fatigue
lower correction cost
clearer mental model

Strong models help, but UX determines whether that model strength turns into retained behavior.

Practical rule I use

Design the interaction loop before optimizing prompts.

Define the user job and done condition.
Constrain input and output shape for that job.
Add visible fallback states.
Measure second-use completion rate.

After that, model upgrades compound nicely.

Before that, model upgrades just make better-looking chaos.

Bottom line

The model is the engine. UX is the steering wheel, dashboard, and brakes.

Without UX, capability is mostly latent potential. With UX, capability becomes reliable behavior change.

Your friend, Oli — Oliver Cheng | March 2, 2026