The case for minimal design in a maximalist world
Why restraint is the most powerful design tool, and how to wield it without looking like you gave up.
There’s a paradox at the heart of modern product design. As tools become more powerful, the temptation to use all of them grows. Gradients on gradients. Animations triggering animations. Micro-interactions built on top of macro-interactions.
The result? Interfaces that feel busy doing nothing.
What restraint actually means
Restraint isn’t absence. It’s not the lazy default of an empty white page and a single sans-serif font. Real restraint is active—it’s the discipline of choosing what to leave out after you’ve considered everything that could go in.
“Perfection is achieved not when there is nothing more to add, but when there is nothing left to take away.” — Antoine de Saint-Exupéry
That quote gets thrown around constantly in design circles, usually by people who have never shipped a product under deadline pressure. But its truth becomes clearer the more products you actually build.
The Linear problem
There’s a reason why Linear became the reference point everyone points to when talking about “good design.” It’s not because they invented new patterns. It’s because they executed existing patterns with uncommon precision.
The borders are sharp. The motion is purposeful. Every hover state earns its existence. Nothing blinks for attention. Nothing begs.
That discipline is hard. It requires saying no to things that feel like improvements in isolation but create noise at system scale.
// The temptation: add everything that seems useful
const Button = ({ label, icon, badge, glow, animated, ...rest }) => (
<button className={`btn ${animated ? 'animate' : ''} ${glow ? 'glow' : ''}`}>
{icon} {label} {badge && <Badge>{badge}</Badge>}
</button>
)
// The discipline: surface what the component actually needs
const Button = ({ label, variant = 'primary' }) => (
<button className={`btn btn--${variant}`}>{label}</button>
)
Three principles that hold up
After years of shipping interfaces, a few principles have remained durable across every context:
1. Every element has one job. If you can’t describe what a UI element does in a single sentence, it’s doing too much or not enough. Split it or remove it.
2. Color is signal, not decoration. Use color to communicate state, hierarchy, and meaning. Not vibes. When everything is colorful, nothing is.
3. Motion should serve comprehension. Transitions should help users understand what changed and why. If removing an animation doesn’t confuse users, the animation was never needed.
The actual hard part
Knowing these principles is trivial. Defending them in a team environment is the actual work.
Design reviews are full of “what if we added…” and “have you considered…” that chip away at simplicity one reasonable suggestion at a time. Each addition seems defensible. The cumulative effect is bloat.
The minimal designer’s job is to hold the line without coming across as dogmatic. The way to do that is to ask the same question at every turn: “What does the user gain from this, and what do they lose?”
If you can’t answer that question clearly, the default should always be: don’t add it.
A note on this theme
This Jekyll theme is built on that philosophy. The design choices are deliberate:
- One accent color used sparingly
- Borders that differentiate without decorating
- Typography that aids reading, not performance
- Animations triggered by interaction, not load
Nothing here exists because it could. Everything here exists because it should.
That’s the case. Not a manifesto. Not a rule. Just a frame for making better decisions when the tools give you infinite options and the clock gives you finite time.