For a long time, product design has been closely associated with visual polish.
Spacing, typography, alignment, colour. The details that make something feel “finished.” Tools like Figma became central because they made it easy to refine those details and get to a high level of fidelity quickly.
That still matters, but it’s no longer the main challenge.
As products have become more complex, and especially as AI gets introduced into the mix, the difficulty has shifted. The problem isn’t getting one screen to look right. It’s making sure the system behaves coherently across many states, inputs, and edge cases.
You can have a beautifully designed screen that falls apart the moment something unexpected happens. That’s where the focus is moving.
Figma hasn’t gone away, but its role is changing.
It’s less about polishing a single flow and more about understanding how a system holds together. You’re mapping states, exploring variations, and working through what happens when things go wrong. You’re thinking about consistency across components, not just within a screen.
Design starts to look less like arranging pixels and more like defining a set of rules.
Things like tokens, patterns, and reusable components become more important, not because they’re efficient (although they are), but because they’re the only way to maintain coherence as complexity increases.
Instead of designing a screen, you’re designing something that can produce many screens.
This isn’t a new idea – in Designing Programmes, Karl Gerstner describes a shift from reactive design to programmatic design. Instead of solving each problem as it appears, you define a system—a “programme”—that can generate solutions. At the time, this was framed in the context of graphic design, typography, and early computational thinking. But the core idea holds up surprisingly well.
Rather than creating a single layout, you define the rules that govern many layouts. Rather than making isolated decisions, you build a structure that produces consistent outcomes.
It’s a way of thinking about design as something closer to a system than a series of artefacts.
That perspective feels increasingly relevant.
Modern products aren’t static. They respond to user input, data, and increasingly, to generated content. The number of possible states grows quickly, and it’s not realistic to design each one individually.
So you design the logic instead.
You decide how components behave under different conditions. You define constraints. You think about what should stay consistent and what can vary. You build patterns that can stretch without breaking.
In that context, pixel perfection becomes less important than system integrity.
A slightly imperfect UI that behaves predictably is often better than a perfectly polished one that only works in ideal conditions.
—
This doesn’t mean visual design stops mattering.
It still plays a big role in how products feel and how they’re perceived. But it’s no longer the primary measure of quality. It’s one part of a larger system that needs to work as a whole.
The bar has moved.
Good design now is less about getting to a final screen and more about defining a system that can handle change. Figma is still part of that process, but it’s being used in a different way.
Less as a canvas for perfecting pixels, and more as a tool for reasoning about how things fit together.