BLOG · 4 JUNE 2026 · 8 MIN READ
AI didn’t change ten design rules. It broke one assumption.
Why every “How AI changes usability” list is describing the same problem — and getting the fix backwards.

There’s a genre of design writing that’s everywhere right now. You take Jakob Nielsen’s ten usability heuristics — the 1994 list every designer can half-recite — and you go through them one by one, asking what each means in the age of AI. Visibility of system status, now with chatbots. Error prevention, but for language models. Help and documentation, except the documentation talks back.
I’ve read a lot of these. I’ve half-written one myself. And the more carefully I went through the exercise, the more I became convinced the exercise is wrong — not in its conclusions, which are usually fine, but in its shape. We keep producing ten separate observations about ten separate heuristics, when what we’re actually looking at is one new thing showing up in ten different places.
AI didn’t evolve ten design rules. It broke a single assumption underneath all of them. And once you name that assumption, the whole list collapses into one principle — and the fix most people are reaching for turns out to be backwards.
The assumption that quietly held everything together
For the entire history of software, there was an equivalence so reliable that nobody bothered to state it: done meant correct.

When a calculator returned an answer, the answer was right. When a form submitted, it submitted what you typed. When a spell-checker changed “teh” to “the,” it was not guessing — it was applying a rule a human had written, and that rule was either triggered or it wasn’t. Rule-based software does exactly what it is told, the same way every time. It can be badly designed, it can be slow, it can be confusing. But within its own logic, it cannot be wrong. “Finished” and “trustworthy” were the same state.
Nielsen’s heuristics were written on top of that equivalence, and they inherited it without ever naming it. “Visibility of system status” only ever had to tell you the system was working and done — because done already implied correct. “Error prevention” was about stopping the user from making mistakes, because the system didn’t make the semantic kind. “Help users recover from errors” assumed the system knew when it had failed, because in deterministic software a failure is an event — something breaks, a flag is raised, you surface it.
Every one of those heuristics rests on the same hidden floor: the system is reliable; the design’s job is to communicate its state and protect the user from their own errors.
AI removes the floor.
What actually changed
A language model is not rule-based. It is probabilistic — it predicts a likely continuation from patterns, which is a sophisticated kind of guessing. Ask it the same question twice and you can get two different answers. More importantly: it can produce an answer that is fluent, complete, confident, and wrong, and nothing in that output will look any different from one that’s fluent, complete, confident, and right.

That is the one thing that changed. Not the interface. Not the conventions. Not the vocabulary. The thing that changed is that done no longer implies correct. The output arrives looking finished whether or not it is true, and — this is the part that matters — the system frequently doesn’t know which it produced.
A spell-checker that flags “teh” is never confidently wrong. A writing assistant that tells you a drug interaction is safe looks exactly as finished and authoritative whether the claim is accurate or a hallucination. Both render the same way. Both feel done. Only one is true, and the interface gives you no way to tell them apart.
Hold that single fact in your head and re-read the heuristics. Watch what happens.
The ten are one in disguise
Take “visibility of system status.” People say it needs to change for AI — that a spinner or a typing indicator no longer tells you enough. But a progress bar never told you what a system was doing either; a checkout spinner never revealed whether the server was validating your card or charging it, and users didn’t need it to. Status barely changed. What people are actually reaching for when they say status “broke” is something else entirely: they want to know whether to believe the output. That’s not status. That’s the done-isn’t-correct problem, wearing a status costume.

Take “error prevention.” The classic version guards the user: confirm before delete, validate the form. People say AI changes it because errors can now enter anywhere — a misread of intent, a bad generation — invisibly. True. But that’s not a new kind of prevention problem; it’s the same single fact again. The system can be wrong without anyone noticing. Same costume, different scene.
Take “help users recognize and recover from errors.” The whole heuristic assumes the system knows it failed. AI often doesn’t — a confidently wrong answer looks identical to a confidently right one from the inside as much as the outside. Once more: this isn’t a distinct evolution of the recovery heuristic. It is the exact same observation as the status one and the prevention one, filed under a third heading.
You can run this for most of the list. “Match between system and the real world” becomes a complaint that you can’t follow the AI’s reasoning — but that’s not about vocabulary, which is what the heuristic governs; it’s about not being able to evaluate what the system did. Again the same root. Heuristic after heuristic, the “AI update” turns out to be the same single problem refracted through a different lens.
This is why the ten-part essay always feels slightly repetitive to write and to read. It is repetitive. We’re describing one thing ten times and calling it ten things.
So let me name it once, plainly, and stop pretending it’s a list:
The system can be confidently, invisibly wrong — so the design’s job is no longer just to show what the system is doing. It is to make the system’s output something the user can actually judge.
That’s the principle. Singular. Everything else is application.
The fix everyone reaches for — and why it’s backwards
Here’s where the genre goes wrong, and it goes wrong almost unanimously. Having sensed that trust is the new problem, nearly everyone proposes the same solution: show the user more. Surface a confidence score — “I’m 90% sure.” Expose the reasoning. Stream every step. Give people transparency, the thinking goes, and they’ll catch the errors themselves.
This sounds right and is mostly wrong, for three reasons.

First, visibility is not understanding. Showing someone the steps a system took does nothing if they can’t interpret the steps. When a coding agent streams forty lines of file edits and shell commands at a designer, that is total transparency and zero comprehension. A cockpit shows you two hundred dials; visible is not the same as understood. Dumping the machinery on the user and calling it empowerment is a way of feeling like you addressed the problem without addressing it.
Second, a confidence number is itself a guess. A model can be ninety percent “sure” and flatly wrong, because its sense of its own confidence is as uncalibrated as the answer. A number next to a wrong answer doesn’t help you catch it — it lends the wrong answer a borrowed authority. You can manufacture false trust as easily as a false fact.
Third, and most damning: transparency only helps the people who least need it. You can only recognize an error you already have the knowledge to recognize. The cases where you “know what you intended and can see the output doesn’t match” are the easy ones — you’d have caught those anyway. The dangerous errors are the confident wrong statistic, the plausible fake citation, the subtly broken calculation — exactly the ones where you have no independent reference to check against. The person most likely to lean on the AI’s output as truth — the junior, the non-expert, the someone-using-this-outside-their-domain — is precisely the person least equipped to do the catching you’ve assigned them. “Give users enough signal to catch it themselves” abandons the most exposed users while reassuring the safest ones.
So the popular fix offloads the burden of judgment onto the user, in the name of trust, and lands hardest on the people who can bear it least. That’s backwards.
The principle, stated as a job for the system
If the user can’t reliably carry the burden, the system has to. That’s the whole move, and it’s the gap in almost everything being written. The design frontier isn’t transparency. It’s the system taking responsibility for its own unreliability. Concretely, that’s three things.

Confirm intent before acting, not after. You can’t write a confirmation dialog for a wrong output, because neither side predicted it. But you can confirm the understanding — before the system generates or acts, have it restate what it thinks you’re asking. “Here’s what I understood: you want X, for Y, under constraint Z. Right?” That catches the misread at the exact point it enters, which is the one invisible step everyone worries about. It’s the AI version of validate-before-submit, and almost nobody designs it, because we’re busy building transparency after the fact instead of a checkpoint before it.
Make the system own its uncertainty — honestly, not numerically. Not a fake 90%. The honest moves are concrete: ground answers in sources the user can open and check; say “I couldn’t find anything to support this” when that’s true; decline to answer confidently outside the system’s competence instead of generating a fluent guess. The worst failure mode isn’t a system that says “I don’t know.” It’s a system that answers anyway, beautifully. Designing for the model to visibly reach the edge of what it knows is worth more than any confidence meter.
Scaffold the request so expertise isn’t the price of entry. A blank text box is the most memory-heavy interface we’ve shipped in decades — it demands you already know what to ask, how to ask it, and what’s even possible. The answer isn’t to teach everyone to write better prompts; it’s to build systems that ask the clarifying question, offer the option, and close the gap between what someone wants and what they can articulate. Help stops being a page you visit and becomes a behavior the system has. The burden of being an expert shifts off the user and into the design.
Notice that all three are the same instinct: the system carries the weight. Confirm, so the user doesn’t have to verify a misread they couldn’t see. Own uncertainty, so the user doesn’t have to detect dishonesty they’re not equipped to spot. Scaffold, so the user doesn’t have to master a skill nobody taught them. One principle, three expressions — the mirror image of the ten-headed list, and a lot more useful.
What this leaves you with
The reason all of this matters isn’t tidiness. It’s that the wrong frame produces wrong work. If you believe AI evolved ten heuristics, you’ll write ten patches and ship ten widgets — a confidence badge here, a reasoning panel there — and feel productive while the actual problem sits untouched. If you see that it’s one principle, you design the one thing that matters: a system that helps the user judge it, and carries the parts of that judgment the user can’t.

Because that’s the real shift underneath the shift. When generating an output costs nothing, the value isn’t in the output. It’s in the judgment of whether the output is any good — and that judgment is now the scarce thing, the human thing, the actual job. The cruelest way to design an AI product is to generate fluent answers and quietly leave that judgment entirely to a user you’ve given no real way to exercise it.
Good design in this era has exactly one new responsibility, not ten. Make the system’s output something a person can actually judge — and where they can’t, make the system do the judging honestly, out loud, before it’s too late to matter.
That’s the whole list. It was always just one line.
Written by Jehad Naji
All articles