UX Design

Design Systems: What They Solve, and What They Don't

Oct 16, 2026

Design systems help teams create consistent interfaces, but they don't necessarily help teams create consistent experiences.

Your Design System Doesn't Understand Your Game

Design systems have become an essential part of modern digital product development. They help teams establish consistency, reduce duplicated work and create interfaces more efficiently.

In game development, they provide a shared foundation for building complex UI ecosystems across different screens, features and gameplay situations.

But there is a distinction worth exploring:

Having a consistent UI doesn't necessarily mean having a consistent player experience.

Why?

Because knowing how to use a component isn't the same as knowing how to solve a player's problem.

What design systems do well

A design system provides a shared language for designing and building digital interfaces.

It typically includes several layers:

  • Foundations: typography, colours, spacing, grids and visual principles.

  • Components: buttons, panels, cards, navigation elements and other reusable UI building blocks.

  • Patterns: recurring solutions for common interaction and layout problems.

  • Documentation: guidelines explaining how and when to use these elements.

  • Governance: processes for maintaining and evolving the system.

Together, these elements help teams reduce inconsistencies, improve collaboration and avoid solving the same interface problems repeatedly.

For larger teams and products, this is particularly valuable. Without shared foundations, every new feature risks introducing another interpretation of the same interface.

However, these benefits primarily address the consistency and efficiency of interface production.

They don't necessarily address the bigger question: how does the interface support the overall player experience?

Where design systems have blind spots

Imagine a game with a well-maintained UI library.

The team has reusable panels, buttons, typography, colours and established layout patterns. Everyone knows where to find them and how to implement them.

Now a new feature enters production.

The feature requires players to manage relationships with different factions. It introduces reputation levels, progression, rewards and consequences for player actions.

The components are already available.

But several important questions remain unanswered:

  • How should players understand their current relationship with a faction?

  • How should positive and negative reputation interact?

  • How should progression be communicated?

  • What happens when players reach a new reputation level?

  • How does the feature behave in different gameplay contexts?

  • How does it connect to existing progression and reward systems?

A component library won't necessarily answer these questions.

It can provide the visual building blocks, but it doesn't automatically explain the experience those building blocks should create.

This is where several limitations become visible.

1. Components don't explain context

A component can tell us what something looks like, but not necessarily when, why or where it should be used.

A modal, for example, might be perfectly documented. But should it interrupt gameplay? Should it be used for critical decisions, optional information or reward notifications?

The answer depends on context.

2. Visual consistency doesn't guarantee behavioural consistency

Two features might use exactly the same components and still behave differently.

One might require confirmation before an action. Another might execute immediately. One might preserve the player's previous state, while another resets it.

Without shared interaction logic, visual consistency can hide behavioural inconsistency.

3. Design systems don't necessarily understand the product

A game is not simply a collection of screens.

It is a connected ecosystem of mechanics, progression, economies, player goals, information and interactions.

A design system might describe how to construct a panel, but it doesn't necessarily explain how that panel connects to the broader gameplay experience.

4. Documentation can become disconnected from reality

Design documentation is useful, but it can quickly become outdated.

Screenshots show a particular state. Written guidelines describe intended behaviour. Component libraries represent reusable elements.

None of these automatically guarantees that the documentation reflects the current state of the game.

From interface consistency to experience consistency

I don't think the answer is to abandon design systems or turn them into enormous documentation repositories.

The answer is to connect them to something more comprehensive.

Imagine an environment where designers and other stakeholders can access not only reusable components, but also:

  • Product knowledge and gameplay context.

  • Established UX patterns and interaction logic.

  • Relationships between features and game systems.

  • Different gameplay states and scenarios.

  • Interactive representations of the actual product.

Instead of asking people to interpret disconnected documentation, we give them an environment in which they can explore how things work together.

This changes the purpose of the system.

It is no longer just helping people build interfaces consistently. It is helping them understand and develop experiences consistently.

Introducing the idea of a Design Harness

This is the thinking behind what I call a Design Harness.

A Design Harness builds upon the foundations of a design system but extends them into a shared, interactive environment for product exploration and experience development.

It connects product knowledge, design foundations, UX patterns, interaction behaviour and prototypes.

The goal isn't to centralise every design decision or restrict creative exploration.

It's to provide enough shared context for different people to contribute without losing sight of the overall product experience.

Design systems remain an important foundation. But as products and teams become more complex, we need to think beyond the component library.

What if our design systems didn't just tell us how to build interfaces, but also helped us understand and explore the experiences those interfaces are supposed to create?

That is where the next evolution of design systems could begin.

All rights reserved 2026

All rights reserved 2026