Confusion is a design decision, not a user problem

We keep building tools that are powerful under the hood and overwhelming at the surface, then blame users for not keeping up.

People are already overwhelmed before they touch our products. They are juggling work, life, expectations, and constant context-switching. Technology is supposed to reduce friction, not become another source of it.

None of us ever needed onboarding to use a calculator. We picked it up, pressed a few buttons, and it worked. The interface didn’t describe itself; it was the explanation.

Now compare that to most modern tools. If users need training just to find the starting line, the system has already failed. This isn’t an argument against complexity. Some domains are genuinely hard. But complexity is not an excuse for confusion. Training should deepen mastery, not compensate for an interface that couldn’t explain itself.

The pattern shows up everywhere

Earlier this month, I tried Midjourney. The gallery is stunning. The outputs look like magic. And yet, I couldn't get it to do what I wanted. I tried tutorials, prompt engineering, and reusing examples, but the results were still unusable.

That’s a very modern kind of failure: something is clearly powerful, but not reliably usable. Don Norman describes this as the Gulf of Execution - the gap between what a user wants to do and what the interface allows them to do. And that gap is not a skill gap. It’s a design gap.

The world is full of Norman Doors

Don Norman popularised another concept that product designers love discussing: Norman Doors. A well-designed door communicates whether it should be pushed or pulled. The shape, handle, and physical cues explain the interaction before any conscious thought occurs.

A badly designed door requires a sign - PUSH, PULL, but the sign isn't the solution. The sign is evidence that the design failed to communicate its intent.

Digital products often suffer from the same problem. Every tooltip explaining basic functionality, every onboarding sequence compensating for unclear navigation should prompt the same question: Could the interface have explained itself better?

Good design is often invisible. It fits so naturally into the task flow that users stop noticing the interface entirely.

The late computer scientist Lawrence Tesler famously argued that complexity cannot be eliminated - it can only be shifted. The question is where? Many organisations unintentionally shift complexity onto users.

Users become responsible for learning hidden workflows, understanding product terminology, memorising exceptions, and figuring out which features matter. Good design absorbs that complexity instead. How? Let us look at it below.

So, what does good look like?

1. Decide what not to show by default.
   Think progressive disclosure in tools like Notion or Figma. You start with a blank page, not a feature list. The complexity is still there; it just waits until you ask for it. As John Maeda puts it, simplicity isn’t the absence of features; it’s the result of deliberate reduction.

   
   

2. Context over clutter
   Users don’t need everything- they need what’s relevant right now. Products like GOV.UK do this well, instead of exposing full systems, they guide users through simple, contextual steps. The system holds the complexity, so the user doesn’t have to.

   
   

3. Replace instructions with affordances
   Instagram never taught users how to use Stories. The interface itself directed behaviour through placement and gesture. People learned by doing, not by reading.

   
   

4. Learn to notice hesitation
   This is the most underrated signal in UX. Pay attention:
   • when users pause
   • hover too long
   • open another tab
   • restart a flow

They're signals that cognitive effort is being spent somewhere it shouldn't be. This idea sits at the heart of what some practitioners call "lizard optimization” - studying small behavioural quirks because they often reveal deeper truths about human decision-making.

The biggest usability problems rarely announce themselves dramatically. They appear as tiny interruptions in flow and that's exactly why they're easy to miss.

A simple test

If you want to evaluate your own product, ask:

• What decision did we avoid making that the user now must make?

• What would break if onboarding disappeared tomorrow?

• Where are we relying on training instead of the interface?

The answers are often very revealing. Because ultimately, good UX is not about making products look simpler, it's about making people feel more capable while using them.