Ten Principles Of Interface Design

By Justin Wetch

Design is respect made visible.

Dieter Rams gave us ten principles for good design. The Gestalt psychologists mapped how the brain organizes perception. What follows is my attempt to synthesize these traditions and my own experience and opinions into something I can continually reuse and refer back to. Not a checklist, but a way of seeing. Ten ideas that explain why some interfaces feel right and others feel like work.

1. Cognitive load

Good interface design does not demand any more cognitive effort than necessary.

This sounds obvious. It isn't. Most interfaces ask users to hold too much in working memory, to remember which screen they came from, what that icon meant, which of six similar buttons does the thing they want. Every unnecessary demand is a tax. The tax accumulates. Eventually the user is exhausted and doesn't know why.

A product is well-designed when it performs its function without demanding mental energy that should be reserved for the user's actual purpose. You're not designing an interface. You're designing a clear path through a forest. The path should be obvious enough that the user can think about where they're going, not where they're stepping.

2. Signal over noise

To subtract the redundant is to add to the significant.

Every element on screen is either signal or noise. Signal serves the user's goal. Noise competes for attention without earning it. The ratio matters more than the total. A dense interface can feel clean if everything present is necessary. A sparse interface can feel cluttered if half of what's there is decoration.

The discipline is subtraction. Not minimalism for its own sake, but the refusal to let anything remain that doesn't carry meaning. When you remove something and nothing is lost, it should never have been there.

3. Legibility

Design must speak for itself.

A legible interface is one you can read. Not just the text, but the structure. Form reveals function. Status is unmistakable. Intent is transparent. The user should never have to guess what something does or what state the system is in.

Legibility means the design never keeps secrets. If something is clickable, it looks clickable. If something is disabled, the reason is apparent. If data is loading, the user knows. The user should not have to guess if a process is happening or not (is this even working?) The interface is a language, and like any language, it only works if both parties understand the grammar.

4. Biological alignment

The machine must bow to the biology.

Human brains evolved for a world without screens. They have constraints. They process certain visual patterns faster than others. They can hold a few (about four) items in working memory. They fatigue. They have expectations shaped by millions of years of interacting with physical objects.

Design that ignores these constraints forces the user to adapt to the machine. Design that respects them creates flow. The interface becomes an extension of natural cognitive processes rather than an obstacle to them. You're not teaching the user a new language. You're speaking in patterns their nervous system already knows.

This extends to the body. Good design anchors proprioception. It respects muscle memory. It builds trust through consistency. The user should be able to reach for a button without looking, confident it will be where it was yesterday.

5. Regulated resistance

Friction is not inherently bad. Unintentional friction is.

The goal is not frictionless design. It's intentional friction. Accidental friction (confusing labels, buried functions, inconsistent behavior) should be eliminated ruthlessly. But strategic friction (confirmation dialogs before destructive actions, speed bumps before irreversible choices) prevents error.

Users should feel safe to explore. The cost of curiosity should be low. Undo is a philosophy. It says: you are allowed to be wrong here. When an action truly cannot be undone, the friction should scale proportionally. Delete my account should be harder to trigger than change my profile photo.

6. Constraint-first

Design backwards from the budget.

Most design processes build up and then trim. Add features, add elements, then cut what doesn't fit. This creates bloat with good intentions. The alternative: start with the constraints and reverse-engineer what can exist within them.

The constraints are real. Attention is finite. Screen space is finite. Cognitive bandwidth is finite. These aren't limitations to fight, they're parameters to design within. A photographer choosing a fixed lens isn't handicapped. They're freed from the paralysis of infinite choice. Same with interface constraints. Accepting them early produces cleaner solutions than ignoring them until the end.

7. Coherence

A good interface speaks one language.

Consistency is usually framed as a rule: buttons should look the same, spacing should follow a system. The deeper principle is linguistic: the interface must possess an internal grammar. If an interaction works this way here, it must work that way there. Learning one part of the system should teach the user how to use the rest.

Incoherence forces translation. When the same action requires different gestures in different contexts, the user maintains a mental lookup table. That's cognitive load you're adding for no benefit. Coherence means the user can trust their intuitions. What they learned generalizes.

8. Invisibility

The best design disappears.

When everything works, the user forgets they're using a tool. They experience only their own intention manifesting. The interface dissolves. This is the goal. Not that the design is unnoticeable, but that it becomes so natural it stops requiring attention.

A hammer becomes invisible in the hand of someone driving a nail. They think about the nail, not the grip. Interfaces achieve the same state when they stop being interfaces and become extensions of the user's will. You know you've succeeded when nobody comments on the design. They just do what they came to do.

9. Progressive disclosure

Complexity should be earned, not imposed.

The novice and the expert have different needs. Showing everything at once overwhelms the novice. Hiding everything frustrates the expert. Progressive disclosure threads the needle: the simple surface is visible by default, and depth reveals itself as the user demonstrates readiness.

This is about layering features, not hiding them. The new user sees what they need to get started. As they explore, they discover more. The expert eventually accesses power tools that would have terrified them on day one. Simplicity that prevents mastery is its own failure; the interface should grow with the user.

10. Visual physics

Distance is meaning. Weight is importance.

Interfaces obey a kind of physics. Related elements should be close (proximity). Important elements should feel heavy (gravity). Visual relationships are semantic relationships. The user reads spatial arrangement as conceptual arrangement, whether you intend it or not.

When layout violates this, when related functions are scattered across the screen or unrelated functions are clustered together, the user has to maintain a mental translation layer. They're constantly correcting for the mismatch between what they see and what they mean. That's friction you've manufactured.

Visual weight should match functional weight. Primary actions anchor the composition. Secondary elements orbit. Tertiary elements drift to the periphery. If something feels important, it should look important. If it looks important but isn't, you've lied to the user's perceptual system. They won't forgive you consciously. They'll just feel vaguely irritated and not know why.

These principles are meant to be pattern recognition, not formula; more of a codification of intuitions than anything else. Sometimes they conflict (progressive disclosure can reduce legibility; regulated resistance adds cognitive load). The skill is knowing which principle takes precedence in a given moment in the user’s experience of using the interface.

But the foundation is simple. Design is an act of respect. Respect for the user's time, their attention, their cognitive limits, their goals. It’s not about following a set of rules, it’s about having a system around designing good user experiences. The fundamental question is: "what does this person actually need?"

The answer is usually: less than you think, arranged more carefully than you'd expect.