A single DESIGN.md works beautifully when you have one brand, one team, and one product.

Then reality arrives.

A second brand. A new theme. A dark mode request. A segment that needs its own colour story but shares the same components.

And suddenly your clean, single file starts showing cracks.

Not because the concept is broken.

Because the system grew. And the file didn't.

This piece is about what happens when your design system gets complex and how to scale DESIGN.md without losing the thing that made it work in the first place.

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

Complexity Arrives in Two Forms

When a design system scales, it scales in two directions at once.

Horizontally: more brands, more themes, more segments. The same components, different visual languages.

Vertically: more contributors, more teams, more opinions about what the rules should be.

Both are real problems. And they need different solutions.

Most teams try to solve both with one file.

That's where it breaks.

The Multi-Brand Problem

One design system. Multiple brands.

Most common B2B scenario for instance, Enterprise gets red. Wholesale gets Black. SME gets their own branding colour. Dark mode gets its own layer entirely.

The components are the same. The tokens are not.

If your DESIGN.md only documents one set of token values, the AI agent has no way of knowing which brand it's building for.

It will pick one. And it will be consistent about the wrong choice.

This is the multi-brand trap.

The Fix: Theme-Aware DESIGN.md Structure

You don't need four separate files.

You need one file with clear theme boundaries.

Here's what that looks like in practice:

## Theme Architecture

This system supports four themes.
Each theme inherits the same component structure.
Token values differ per theme.
Always declare the active theme at the start of any task.

### Themes
- Enterprise — Primary: color-primary-red — #B2064C
- Wholesale — Primary: color-primary-black — #000000
- SME — Primary: color-primary-yellow — #FFDC2E
- Dark Mode — Surface: color-surface-dark — #0F172A

### Theme rule
If no theme is declared — default to Enterprise.
Never mix token values across themes in a single view.
A component built for Enterprise must never inherit 
B2B token values unless explicitly instructed.

Why this works:

The agent now knows four themes exist. It knows the default. It knows mixing is not allowed. And it knows exactly which token to reach for per theme without guessing.

The "always declare the active theme" instruction is the most important line. It turns theme selection from an assumption into a deliberate instruction every time.

The Multi-Team Problem

Multiple teams contributing to the same design system is a different kind of complexity.

It's not a token problem. It's a trust problem.

When one designer owns the system, the rules are clear. When five designers contribute to it, the rules become negotiable.

Someone adds a new button variant without documenting it. Someone updates a token value without updating the changelog. Someone writes a component rule that contradicts an existing one.

And the DESIGN.md becomes unreliable.

An unreliable DESIGN.md is worse than no DESIGN.md.

The agent will follow it confidently and generate inconsistent UI with full conviction.

The Fix: Ownership and Contribution Rules

The file needs to say who owns it and how it gets updated.

Not just for humans. For the agent too.

## Contribution Rules

### Ownership
This file is maintained by the Design System Lead.
All changes require review before merging.
No contributor may update token values without 
a corresponding CHANGELOG.md entry.

### How to contribute
1. Open a branch — never edit main directly
2. Make your change with a clear commit message
3. Update CHANGELOG.md with plain-English context
4. Open a pull request for review
5. The Design System Lead approves before merge

### For AI agents
Only read from the main branch of this file.
Draft branches may contain unreviewed changes.
If you are working from a branch, stop.
Ask which version to use before proceeding.

Why this works:

Contribution rules aren't just governance for humans. They're instructions for the agent about which version of the file to trust.

The "if you are working from a branch stop" line is one most designers never think to include. But an agent working from an unreviewed draft will generate UI based on rules that haven't been approved yet.

One line prevents that entirely.

When One File Is No Longer Enough

There's a threshold where a single DESIGN.md becomes too large to be useful.

When it takes more than five minutes to find a specific component rule, the file has outgrown itself.

At that point, split it.

Not randomly. With intention.

/design-system
  DESIGN.md              ← master file, overview and principles
  /tokens
    TOKENS.md            ← all resolved token values per theme
  /components
    BUTTONS.md           ← button anatomy, rules, variants
    FORMS.md             ← input, select, checkbox, radio
    NAVIGATION.md        ← navbar, sidebar, breadcrumb
    FEEDBACK.md          ← toast, modal, alert, badge
  /themes
    ENTERPRISE.md        ← Enterprise-specific overrides
    B2B.md               ← B2B-specific overrides
    SME.md               ← SME-specific overrides
    DARK.md              ← Dark mode overrides
  CHANGELOG.md           ← plain-English update history

The master DESIGN.md becomes the index. It tells the agent where to find everything else.

## How to read this system

Start here. Then navigate to the relevant file.
- For token values → /tokens/TOKENS.md
- For component rules → /components/[component].md
- For theme overrides → /themes/[theme].md
- For recent changes → CHANGELOG.md

Always read the master file first.
Always read the relevant component file before generating UI.
Never assume if you are unsure which file applies, ask.

The Rule That Scales Everything

Here's what most designers miss when their system gets complex.

The problem isn't documentation volume.

It's documentation trust.

An AI agent will follow your DESIGN.md confidently regardless of whether it's accurate. It doesn't know if the file is outdated. It doesn't know if a rule was overridden last sprint. It doesn't know if a theme token was renamed and nobody updated the reference.

It just follows.

Which means the real job of scaling DESIGN.md isn't writing more rules.

It's keeping the rules you have accurate.

One outdated rule in a complex system causes more damage than ten missing ones. Because the agent follows it at scale across every component, every theme, every team's output until someone notices.

And by then, three sprints have passed.

The Discipline That Keeps It Alive

This is the part nobody warns you about.

Scaling a design system isn't a documentation problem. It's a maintenance discipline.

The file doesn't keep itself updated.

Someone has to own it. Someone has to update it every time a token changes. Every time a rule gets refined. Every time a new theme gets introduced.

That someone is you.

Not because the tools aren't good enough.

Because the design system is only as reliable as the person maintaining it.

And when you maintain it well, the AI agent becomes an extension of your judgment, not a replacement for it.

That's the whole point.

Before You Scale: Audit What You Have

Before adding complexity, check what exists.

Ask these questions:

Is every token in my DESIGN.md still accurate?
Does every component rule reflect how the system actually works today?
Is the changelog up to date?
Does the agent know which theme to default to?
Does it know where to go when it doesn't know?

If the answer to any of these is no, fix that first.

A clean simple file scales better than a complex broken one.

Every time.

Next in this series: Part 5: Here's the System I Built. And Here's How You Can Use It.

Subscribe to Design x Machine for more on UX, intelligent systems, and the future of design practice.

👉 designxmachine.beehiiv.com

You've created the file.

You've named it DESIGN.md.

You've dropped it into the repository.

And the AI coding agent still generated a button with the wrong border radius.

So what went wrong?

Nothing is wrong with the file.

The problem is how you wrote it.

Because writing for an AI agent is not the same as writing for a developer.

And most designers don't know the difference.

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

How a Developer Reads. How an Agent Reads.

When a developer reads your DESIGN.md, they bring context.

They've been in your Slack channels. They've sat in the design review. They know what you mean when you say "use the primary button for CTAs."

They fill the gaps with judgment.

An AI coding agent doesn't have gaps.

It has instructions. And it follows them literally.

If your DESIGN.md says "use brand colors consistently" the agent doesn't know what brand colors are. It doesn't know what consistently means. It will make a decision. And it won't be yours.

This is the core problem.

Vague language that works for humans fails for machines.

What AI Agents Actually Look For

When an AI coding agent reads your DESIGN.md it's doing one thing.

Pattern matching.

It scans for structure, labels, and explicit values it can map to decisions.

It's looking for answers to these questions:

What should I use? 

What should I never use? 

What are the exact values? 

What are the rules for when to use what?

If your file answers those four questions, clearly, specifically, with real values the agent follows it.

If it doesn't, the agent guesses.

And agents are confident guessers.

The Four Things Your DESIGN.md Must Include

1. Token values not references

❌ Don't write: "Use the primary color for buttons."

✅ Write: "Primary button background: color-primary - #2563EB. Do not substitute."

The agent needs the actual value alongside the token name. Token names alone are meaningless without a resolved value unless you've also provided a token file the agent can read.

2. Explicit do and don't rules

❌ Don't write: "Buttons should feel consistent."

✅ Write: "Use the primary button for one CTA per page only. Use the secondary button for all supporting actions. Never use more than two button variants in a single view."

Rules without exceptions are rules the agent can follow.

3. Component anatomy not just appearance

❌ Don't write: "Cards have a shadow and rounded corners."

✅ Write: "Card component: - Background: color-surface — #FFFFFF — Border radius: radius-md — 8px — Shadow: elevation-1 — 0px 1px 3px rgba(0,0,0,0.1) — Padding: spacing-lg — 24px — Never use elevation-2 or above inside a card"

Anatomy gives the agent a complete picture. Appearance gives it half a guess.

4. Hierarchy and priority - what overrides what

❌ Don't write: "Follow the design system."

✅ Write: "Token values in this file take priority over any hardcoded values in the codebase. If a conflict exists, always defer to the token."

Agents need to know what wins when rules collide.

A Partial DESIGN.md With Commentary

Here's what a real section looks like. And why it works.

## Buttons

### Primary Button
- Background: color-primary — #2563EB
- Text: color-on-primary — #FFFFFF
- Border radius: radius-md — 8px
- Padding: spacing-sm spacing-lg — 8px 24px
- Font: font-label-md — Work Sans, 14px, 600

### Rules
- Use ONE primary button per view. It is the main CTA.
- Never place a primary button inside a modal header.
- Disabled state: opacity 40%, non-interactive. Do not change color.

### Never do this
- Do not use color-primary-light as button background.
- Do not create custom button variants outside this system.

Why this works:

The token name and resolved hex value appear together. The agent doesn't have to guess what color-primary resolves to.

The rules are specific and binary: one primary button per view. Not "use sparingly." Not "be consistent." One.

The "never do this" section is the most important part most designers leave out. Agents don't instinctively avoid things. You have to tell them what's off limits.

The One Phrase That Breaks Everything

"Use your best judgment."

Never write this in a DESIGN.md.

An AI agent will use its judgment. And its judgment is trained on the entire internet, not your design system.

Anywhere you're tempted to write "use your best judgment" stop. That's a gap in your documentation. Fill it with a specific rule.

If you don't know the rule yet write a placeholder:

"Rule pending - default to spacing-md until updated."

A pending rule is better than no rule. The agent has something to follow.

Start With One Section

You don't need a perfect DESIGN.md on day one.

Start with buttons.

Write the full token anatomy. Write the rules. Write what not to do.

Get one component documented properly and test it with your agent. See how it performs.

Then add typography. Then color. Then layout.

The goal isn't a complete document.

The goal is a document that gives your agent fewer reasons to guess.

Every section you write is one less decision the AI makes without you.

Stop writing DESIGN.md from scratch. I built the full template so you don't have to. Every section from this article: tokens, components, agent instructions pre-written and ready to drop into your repo.

👉 Download it free on Gumroad

Next in this series: Part 4: Scaling DESIGN.md When Your System Gets Complex.

Subscribe to Design x Machine for more on UX, intelligent systems, and the future of design practice.

👉 designxmachine.beehiiv.com

In the last piece, we talked about what DESIGN.md is.

A single file. A briefing document for the machine.

The thing that makes your design system legible to AI coding agents.

But there's a question that comes right after.

What happens when the design system changes?

Because design systems always change.

New tokens. Updated components. Deprecated patterns. A color that shifted two shades in the last sprint.

And every time something changes, two problems appear at once.

The file goes stale.

And the developers don't know.

And by the time anyone notices, three sprints have passed and the AI is still generating UI with the old primary color.

This piece is about solving both.

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

The Real Problem Isn't the Tool. It's the Workflow.

Most teams handle design system updates the same way.

A designer makes a change in Figma.

Publishes the library.

Then sends a message somewhere: Slack, email, a comment in Jira - saying something changed.

The developer reads it. Or doesn't.

Interprets it. Or misinterprets it.

And somewhere between that message and the codebase, the update gets lost, delayed, or applied inconsistently.

It's not a Figma problem.

It's not a developer problem.

It's a communication architecture problem.

The update lives in Figma. The code lives in GitHub. And nothing connects them.

Until now.

The Stack That Actually Works

You don't need a complicated setup.

You need three things working together.

Tokens Studio → GitHub → CHANGELOG.md

That's it.

Each one does a specific job.

Tokens Studio moves the tokens.

GitHub holds the review.

The changelog explains what changed and why.

Let's walk through each one.

Step One: Tokens Studio Moves the Tokens

Tokens Studio is a Figma plugin.

It connects your design tokens: colors, typography, spacing, radius, effects directly to a GitHub repository.

When you update a token in Figma and push it through Tokens Studio, it doesn't send a Slack message.

It opens a Pull Request in GitHub.

A PR is a formal change proposal in code.

It shows the developer exactly what changed (before and after) in a structured diff.

color-primary: #3B82F6 → color-primary: #2563EB

Not a description of the change.

The actual change.

And the developer can review it, ask questions, approve it, or flag a concern: all inside GitHub.

Nothing gets lost in a chat thread.

The free plan covers GitHub sync for a single file, which is enough to get started.

Step Two: GitHub Is the Notification 

This is the part most designers don't expect.

You don't need to notify the developer separately.

When Tokens Studio opens a PR, GitHub notifies them automatically.

They get an email. A GitHub notification. A ping if you've set up Slack integration with GitHub.

The PR is the notification.

And unlike a Slack message, it comes with full context.

The developer can see:

• What tokens changed

• What the old values were

• What the new values are

• Whether it affects anything downstream

They review it the same way they review code.

Because it is code now.

Your design decisions, committed to the repository.

This is what a design decision looks like in code. One push from Tokens Studio and your tokens live in GitHub: structured, versioned, and reviewable. No Slack message needed.

Step Three: The Changelog Explains the Why

Token diffs are precise.

But they don't tell the full story.

A developer looking at a color change from #3B82F6 to #2563EB might wonder:

Is this a global rebrand? A contrast fix? A one-off exception?

That context lives in CHANGELOG.md.

A simple file in the same repository. Updated by the designer alongside every push.

The format doesn't need to be complicated.

## [v1.3.0] - 2026-05-17 

### Changed 
- Updated color-primary for WCAG AA contrast compliance 
- Renamed spacing-xs to spacing-2 to align with new scale 

### Added 
- New color-warning-subtle token for inline alert states 

### Deprecated
- color-secondary-light 
— use color-neutral-200 instead

Plain language. Written by the designer. Permanent record.

The developer reads the diff in the PR.

They read the context in the changelog.

They have everything they need to merge with confidence.

What About Figma-Side Updates?

The token pipeline handles the code side.

But designers working in Figma also need to know something changed.

That's where Figma's native library publishing comes in.

When you publish an update to your shared Figma library, every file that uses it shows a quiet banner:

"Updates available from [your library name]."

Designers can review and accept the update or hold off if they're mid-sprint.

It's not as structured as a PR.

But it closes the loop on the design side of the team.

The Full Flow, End to End

Once this is set up, here's what a typical design system update looks like.

You update a token in Figma 
          ↓ 
Push it via Tokens Studio 
          ↓ 
A PR opens automatically in GitHub
          ↓ 
Developer gets notified and reviews the diff
          ↓ 
You update CHANGELOG.md with plain-English context 
          ↓
Developer merges tokens are live in the codebase
          ↓ 
You publish the Figma library update
          ↓
Designers see the update banner and accept changes

No Slack fire. No missed messages. No "wait, when did that change?"

Just a clean, reviewable, traceable update: every time.

Your Role in This

If you're the PIC for your design system, this is your pipeline to own.

You're the one who:

• Pushes token changes via Tokens Studio

• Writes the CHANGELOG entry

• Publishes the Figma library update

• Reviews the PR before it merges

You are the bridge between design and development.

And with this setup, that bridge has structure.

Not because every tool is perfect.

But because the workflow is clear.

Start Small

You don't have to set all of this up in a single afternoon.

Start with Tokens Studio and a GitHub repository.

Get one token change through the PR flow.

See how it feels.

Then add the changelog. Then formalise the library publishing cadence.

The goal isn't a perfect system on day one.

The goal is a system that makes design updates reviewable and traceable instead of announced and forgotten.

That shift alone changes how design and development work together.

And it starts with a single push.

Next in this series: Part 3: How to write a DESIGN.md that AI coding agents actually follow and what to include when your system gets complex.

Subscribe to Design x Machine for more on UX, intelligent systems, and the future of design practice.

👉 designxmachine.beehiiv.com

Recently, I kept seeing the term DESIGN.md pop up in conversations. At first, it looked like another developer thing. A markdown file. A bit of text. Nothing exciting.

But the more I looked into it, the more I realised it wasn’t really a developer thing at all. It’s actually a design systems thing. And it might be one of the most practical shifts happening right now at the intersection of design and AI-assisted development.

So I did what I usually do…I experimented with it. I brought it to my team, tested it in a real workflow, and it worked. We’re now running it in v1.0.

Once I saw it hold up, I introduced it to the team and invited everyone to give it a try. And that’s where it got interesting because from that first try, we didn’t stop. We started building more on top of it. Iterating. Expanding. Making it ours.

What started as curiosity became a foundation.

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

The Problem Nobody Talks About

We spend months building design systems.

Colors. Typography. Spacing. Components. Tokens.

We document it in Figma. We publish the library. We write guidelines.

And then an AI coding agent Cursor, Claude Code, Copilot that generates a UI that looks nothing like it.

Not because the AI is bad at its job.

But because the AI has no idea your design system exists.

It’s working blind.

DESIGN.md is how you fix that.

So What Is DESIGN.md?

It’s a single markdown file that lives inside your codebase.

One file that captures your brand’s visual language: colors, typography, spacing, component rules, motion in a format that AI coding agents can actually read and follow.

Not a Figma link. Not a Notion doc. Not a Storybook URL.

A plain text file. Right there in the repo. Always accessible.

When an AI agent generates UI, it reads DESIGN.md first.

And suddenly, instead of generic beige interfaces, it builds something that actually looks like your product.

Think of it like this.

Your design system is the system.

DESIGN.md is the briefing document you hand to the machine.

Why This Matters Now

AI coding agents are no longer experimental.

Teams are shipping real features with Cursor, Claude Code, and Copilot every day.

But most of them are generating UI without any design context.

The result is inconsistency. Drift. Components that don’t follow the system.

Developers aren’t ignoring the design system on purpose.

The tools they’re using simply don’t have access to it.

DESIGN.md closes that gap.

It makes your design system legible to machines.

And once the machine understands your system, the AI-generated output starts to reflect actual design intent not just technical correctness.

What Goes Inside It

A good DESIGN.md typically covers:

Color tokens: your palette, semantic colors, and how they’re used

Typography: font families, size scale, weights, line heights

Spacing and layout: your grid, spacing scale, component density

Component rules: when to use what, and what variants exist

Motion: easing, duration, what should and shouldn’t animate

Voice: tone, writing style, how the product speaks

It doesn’t need to be exhaustive on day one.

Even a lean DESIGN.md with just your color tokens and typography scale is already better than nothing.

The AI goes from guessing to following.

How to Build One From Your Figma File

You don’t have to write it manually.

There are a few tools that can generate DESIGN.md directly from your Figma design system.

The DESIGN.md Generator plugin on Figma Community extracts your local styles and variables: colors, typography, spacing, effects and produces an editable markdown file you can drop straight into your repo.

If you prefer a browser-based approach, figmadesignmd.com does the same thing. Paste your Figma URL and access token, and it generates the file in seconds.

Once it’s generated, review it. Edit it. Make it yours.

It’s a living document, not a one-time export.

The Part Designers Need to Own

Here’s where it gets interesting.

DESIGN.md sits in the codebase. But it’s written for the machine by the designer.

Which means the designer is now authoring something that directly shapes how AI generates UI.

Not through a Figma file.

Not through a handoff note.

Through a file that lives in the same repository as production code.

That’s a meaningful shift.

It means design intent doesn’t stop at the component library.

It travels into the AI’s context and influences every screen it generates from that point forward.

Keeping It In Sync

The honest truth is: DESIGN.md doesn’t auto-sync with Figma.

When your design system evolves, the file needs to evolve with it.

The practical approach is to treat it like a release note.

Every time you publish a design system update: new tokens, updated components, deprecated patterns and you update DESIGN.md alongside it.

It takes maybe fifteen minutes per update.

And it’s worth it, because an outdated DESIGN.md is worse than no DESIGN.md.

Stale guidance actively misleads the AI.

What This Changes

For a long time, the gap between design systems and AI-generated code felt invisible.

Designers built systems. Developers used AI tools. The two didn’t connect.

DESIGN.md is a small file.

But it does something important.

It gives the machine a design language to work with.

And it gives designers a direct line into how AI shapes the product, not through prompts or reviews after the fact, but through a clear, structured brief that travels with the code.

That’s the shift worth paying attention to.

Not just what the AI builds.

But what designers give it to work with.

If you found this useful, subscribe to Design x Machine where I write about UX, intelligent systems, and the future of design practice.

👉 designxmachine.beehiiv.com

Recently, I spent some time reading one of Figma’s latest industry reports.

At first glance, it looked like most design reports do: charts, data, and statistics about how designers work today.

But halfway through reading it, something more interesting started to appear.

The report wasn’t just describing how designers work.

It was quietly revealing how the role of design itself is changing.

Not slowly.
Not gradually.

But faster than many of us realise.

And if you look closely at the signals inside the report, you begin to see a shift happening beneath the surface of everyday design work.

Design Is No Longer Just About Screens

For a long time, design was mostly about screens.

Designers created layouts.
They designed flows.
They defined interactions.

But today, design work looks very different.

Many modern design teams are no longer just producing UI. They are maintaining systems that power entire products.

Design systems.
Component libraries.
Design tokens.
Reusable interaction patterns.

The work has expanded far beyond pixels.

In large organisations, design is no longer just a craft practiced by individuals.

It’s becoming infrastructure for how products are built.

Tools like Figma reflect this shift. What started as a design tool is now a shared workspace where designers, developers, and product teams collaborate in real time.

Once design becomes infrastructure, the role of the designer inevitably changes.

Designers Are Becoming System Thinkers

One of the most interesting signals in the report is how design work is becoming more system-oriented.

Designers today are not just deciding how something looks.

They are defining:

• components
• variables and tokens
• reusable patterns
• interaction rules
• documentation for teams

In other words, designers are increasingly shaping how design scales across an organisation.

This requires a different mindset.

Instead of designing one interface at a time, designers are thinking about:

• how patterns repeat

• how systems evolve

• how design decisions propagate across multiple products

In many ways, designers are becoming system architects.

And that shift fundamentally changes the nature of the job.

The Hidden Shift: Design Is Becoming Operational

But there’s another signal hidden beneath the surface.

As design systems grow in importance, designers are spending more time on operational work.

Maintaining libraries.
Aligning with engineering.
Auditing inconsistencies.
Managing tokens and components.
Documenting patterns.

This is necessary work.

But it also changes how designers spend their time.

In some organisations, maintaining the system can take nearly as much effort as designing new experiences.

And yet, only a relatively small portion of designers are formally responsible for design systems work.

Which means a small group of designers often ends up shaping the foundations that entire product organisations depend on.

This is one of the quiet shifts happening in design today.

The influence of system-level design work is expanding far faster than the number of people formally assigned to it.

AI Is Quietly Entering the Design Workflow

At the same time, another transformation is happening.

AI is beginning to enter the design workflow.

According to Figma’s research, 78% of designers say AI tools significantly speed up their workflow, yet only 58% believe AI improves the quality of their work.

That gap is interesting.

It suggests that AI is already helping designers move faster, but the industry is still figuring out how these tools should shape the craft itself.

The report also shows how designers are experimenting with AI in different ways:

• 33% use AI to generate design assets

• 22% use AI to create first drafts of interfaces

• 21% use AI to explore layout variations

In other words, AI is currently being used more for exploration and acceleration than final design decisions.

And that makes sense.

Design has always been about judgment.

AI may help generate possibilities but humans still decide which possibilities matter.

Design Is Becoming a Team Sport

Another important signal from the report is how closely designers now work with other disciplines.

According to Figma’s findings, 84% of designers collaborate with developers at least once a week.

That number alone tells an important story.

Design tools are no longer just tools for designers.

They are becoming shared workspaces for entire product teams.

Design decisions increasingly happen through conversations between:

• design

• engineering

• product

• research

• and sometimes even customers.

Which means design is becoming less of a solo craft and more of a collaborative system.

What This Means for Design Leaders

Reading the report made me reflect on what the future of design leadership might look like.

A few things feel increasingly clear.

1. Design systems will become product platforms

Design systems are no longer just UI libraries.

They are becoming platforms that connect design, engineering, and product decisions.

2. Designers need to think in systems

The ability to design beautiful interfaces will always matter.

But increasingly, the most impactful designers will be those who can think in patterns, rules, and systems.

3. AI will reshape parts of the workflow

AI will likely automate parts of operational design work.

But the responsibility of defining what the system should do will remain deeply human.

The Bigger Shift

Industry reports often focus on tools and trends.

But the most interesting signal in Figma’s report isn’t a specific feature or workflow.

It’s this:

The role of design itself is evolving.

Designers are no longer only crafting interfaces.

We are shaping systems.
Defining patterns.
Creating rules that scale across products.

And increasingly, collaborating with intelligent tools that help execute those rules.

The future of design may not be about pixels alone.

It may be about the systems that produce them.

And perhaps the real question isn’t:

How AI will design for us.

But rather:

How designers will shape the intelligence behind future products.

If experience continues to evolve after launch and increasingly outside the interface —
what exactly are designers responsible for shaping now?

It’s a question I keep coming back to as tools, systems, and AI start to change how products are built.

And it’s something I explore often in Design x Machine, where I write about UX, intelligent systems, and the future of design practice.

👉 If you haven’t yet, subscribe here to get my free UX prompt guide for designing with AI.
It’s the easiest way to keep exploring these ideas with me.

Jordan opens his telco self-care app.

At the top of the dashboard, a soft gradient card appears:

Below it:

View recommendation
Dismiss

Nothing flashy.
No bold savings number.
No urgency.

Just a suggestion.

And that restraint is the design decision.

The UX Tension in AI Recommendation Systems

In intelligent products, the real tension isn’t automation vs manual decision-making.

It’s delegation vs control.

Delegation happens when users allow the system to analyse and recommend on their behalf.

Control exists when users retain the final say even if they ultimately follow the system’s advice.

AI recommendation systems quietly shift this balance.

When suggestion and action are collapsed into one step, systems move from assistance to dominance.

Users may comply. But compliance is not trust.

Why This Telco Self-Care UI Feels Different

The dashboard card does something subtle but important.

It separates recommendation from commitment.

The wording is deliberate:

• “May better match” introduces humility

• “Based on recent activity” introduces reasoning

• “View recommendation” invites exploration

• “Dismiss” protects autonomy

The AI has already analysed Jordan’s usage.
It has compared plan structures.
It has identified a potential match.

But it stops short of authority.

That separation preserves user control.

And in high-stakes systems, control is everything.

Why AI Plan Recommendations Are Riskier in Telco

AI recommendations behave differently in subscription products compared to e-commerce or content platforms.

In a telco self-care app, changing a plan affects:

• Monthly recurring costs

• Contract duration

• Roaming fees

• Billing cycles

This is financial territory.

Users often do not fully understand downstream implications.

That asymmetry increases perceived risk.

When risk is high, users look for signals of control not signals of optimisation.

Without visible override, AI recommendations feel coercive rather than supportive.

What Research Says About AI Trust and User Control

Across industries, research consistently shows:

Users don’t reject AI because it’s inaccurate.
They reject it when it feels uncontrollable.

Key findings include:

• 75% of users express concern about AI bias or misinformation, especially when decisions appear opaque or final.

• Interfaces with clear opt-outs significantly reduce perceived risk and increase trust.

• Perceived fairness in AI systems influences user decisions more strongly than fairness in human-to-human interactions.

In other words:

A visible “Dismiss” button is not cosmetic.

It is a trust mechanism.

Human-in-the-Loop Design in Regulated Industries

In finance and insurance, human-in-the-loop (HITL) systems consistently show:

• Higher perceived accountability

• Reduced automation bias

• Improved decision quality

Training users about AI limitations reduces blind acceptance.

Allowing users to remain responsible stabilises trust.

The lesson is not to remove automation.

The lesson is to design AI systems with visible boundaries.

AI can recommend.

Humans must remain responsible.

The Business Risk of Removing Control

Many AI-powered optimisation systems focus on short-term conversion metrics.

Aggressive defaults and friction reduction may increase immediate plan switches.

But in high-stakes environments, trust erosion compounds over time.

When AI recommendations feel final:

• Suspicion increases

• Confidence decreases

• Long-term retention suffers

In subscription businesses like telco, retention is built on trust not pressure.

The Design Principle

In high-stakes AI systems:

Delegation without visible override erodes trust faster than poor recommendations.

Control is not friction. Control is reassurance.

Sometimes, the most intelligent thing a system can say is:

“You can say no.”

Beyond the Dashboard Card

This recommendation card is only the first boundary.

The deeper design questions emerge after Jordan taps “View recommendation”:

• How much explanation is enough?

• Where should hesitation be detected?

• When should reversibility be introduced?

• What trade-offs exist between conversion and long-term trust?

In the full Pattern Report, I break down:

• The complete 4-screen AI plan recommendation flow

• Behavioural traps such as automation bias and default bias

• Real-world performance metrics from telco and regulated industries

• A production-ready prototype walkthrough

If you’re designing AI systems that influence money, contracts, or risk, these details matter.

🔒 Unlock the full Pattern Report on Gumroad.

Ever notice your “smart” app making choices behind your back? You’re not paranoid - AI is quietly grabbing the wheel. This recurring Design x Machine pattern the tension between delegating decisions to the system and keeping humans in charge, defines intelligent design. Miss it, and you risk user trust, finger-pointing chaos, and sidelined influence. Here’s how to navigate it.

TL;DR

AI sneaks control through “helpful” auto-moves. Designers hide the strings. Ask 5 key questions to expose and balance it. Ignore it, and over-trust, blame games, and enterprise disasters follow - sometimes right in telco systems.

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

The Tension

Picture this: Netflix auto-queues a show you never picked. Tesla’s Autopilot veers left while you sip coffee. AI doesn’t wait for permission - it acts faster than you can think.

Designers face a brutal choice: delegate to keep pace, or cling to control and risk falling behind. The line blurs the second intelligence wakes up.

Why It Creeps In

In basic UX days, users called the shots - systems just followed orders. Enter AI: it predicts your next email, pre-fills forms, tweaks Spotify playlists. Each tweak feels helpful - “Hey, I saved you time!” but stack them up, and suddenly the system decides your day. Delegation isn’t a switch; it’s death by a thousand “helpful” cuts.

Designer Pitfalls (And Real-World Wrecks)

• Assuming auto-magic equals delight. Instagram “helps” by prioritising viral posts over your best friend’s story - users bail, feeling spied on instead of served.

• Binary thinking. Control isn’t manual vs auto - it’s graduated. Photoshop’s AI upscaler lets you dial aggression from subtle to wild. UI sliders are table stakes; the real fight is in backend defaults.

• Pretending overrides fix everything. In hiring tools, AI flags “risky” candidates silently. Users can override, but if they don’t know what the AI scanned - tattoos, accents - that’s not control. It’s a puppet show.

Telco example: AI-driven network optimisation can reroute traffic during peak demand. Engineers might not see why decisions were made, and if something fails, the question “Who decided - the system or us?” becomes critical. Delegation earns trust only when humans clearly understand what the system is doing.

Ignore It? Carnage Ensues

Zillow’s AI priced homes wildly; buyers overpaid, lawsuits followed. Airline pilots over-deferred to autopilot; crashes followed. Teams dodge responsibility, designers shrink, and trust evaporates. In B2B, this kills deals dead.

5 Key Questions To Rule This Pattern

Before pixels hit Figma, ask:

1. What decisions is AI making without explicit user intent?

2. When does “assist” slide into “assume,” like auto-archiving emails at 70% confidence?

3. Can users see what the system is deciding?

4. Who owns errors?

5. How fast does control snap back - before the act, mid-flow, or after regret?

Fuzzy answers? You’ve already lost the wheel.

My AI Audit Trick

I prompt AI to betray my own designs:

It flags buried auto-routes, hidden churn flags, or auto-deleted tickets - fixed before launch.

Lock It Down

Delegation fuels AI’s edge; control keeps humans sovereign. Nail this balance, and your products don’t just work they command loyalty.

In Part 1, we talked about what AI exposed, not what it broke.

This part goes one step further.

Because once the illusion of control fades, another tension becomes visible:
what designers intend is no longer what users experience.

This isn’t a failure of skill or craft. It’s a mismatch between how UX is designed and how experience now unfolds.

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

Designers Design Flows. Users Experience Decisions.

Most UX work still relies on flows.

Flows imply order. They suggest that if a user does A, the system will respond with B. They make experience feel explainable, predictable, and intentional.

But intelligent systems don’t always follow flows. They infer. They prioritise. They optimise based on signals users never see.

When a system skips a step, changes a recommendation, or reshapes content dynamically, the experience isn’t broken but it’s no longer explained by the flow that was designed.

At that point, the question isn’t “Does the flow work?”
It’s “Does the user understand why the system chose this outcome?”

Designers Design States. Users Experience Transitions.

Traditional UX is comfortable with states.

Empty. Loading. Success. Error. Each state is named, designed, and reviewed. They give designers a sense of control over what users will encounter.

But in intelligent systems, the most meaningful moments often happen between states.

A pause feels different when a system is “thinking” rather than loading.
A suggestion feels different when it’s inferred rather than selected.
A delay feels different when intent is unclear.

Yet we often represent all of these moments with the same neutral patterns.

When transitions carry meaning but design treats them as technical artefacts, users fill in the gaps themselves usually with uncertainty.

What they experience isn’t the state.
It’s the ambiguity between states.

Designers Design Interfaces. Users Experience Behaviour.

Interfaces are shared.
Behaviour is not.

Over time, users learn how a system behaves — what it prioritises, what it ignores, and how it reacts when it’s uncertain. These lessons aren’t taught explicitly. They’re inferred through repeated interaction.

That’s why two users can use the same product and walk away with completely different impressions of it. The interface is identical. The behaviour they experienced is not.

And behaviour doesn’t live neatly in components or design specs. It accumulates slowly, shaped by data, feedback loops, and system decisions.

Which raises an uncomfortable realisation:
much of what users experience today is shaped by systems designers influence — but do not fully control.

When Experience Emerges, UX Shifts

The gap between designed UX and lived experience isn’t a sign that UX failed.

It’s a signal that experience is no longer bounded by what designers specify upfront. It unfolds over time, through system behaviour, adaptation, and interpretation.

In that world, UX quietly changes role.

Not from designing screens to designing meaning —
but from designing meaning to negotiating it.

Negotiating expectations.
Negotiating trust.
Negotiating how much agency a system should take, and when.

That shift doesn’t make UX irrelevant.
But it does make it incomplete in its current form.

A Quiet Question to Carry Forward

If experience is shaped as much by system behaviour as by interface design, then UX can no longer be just about what users see or do.

It must account for what systems decide, how they explain themselves, and how users learn to trust them over time.

This is the moment where we must ask not just what we design, but how we design trust, how we design for emergence, and how we help users navigate that journey.

And that leads to a question worth sitting with — not answering too quickly:

If experience continues to evolve after launch, and outside the interface, what exactly are designers responsible for shaping now?

👉 If you haven’t yet, subscribe here to get my free UX prompt guide for designing with AI - it’s the easiest way to keep exploring with me.

In 2026, the problem isn’t whether AI works.

It does.

Products ship faster. Interfaces feel smarter. Systems respond in ways that would’ve felt magical just a few years ago.

And yet, something feels off.

Designers aren’t excited or terrified anymore - they’re tired. Not of AI itself, but of how often we talk about it as a feature while ignoring the experience it creates. The system technically does the right thing, but users feel misunderstood. Confident predictions arrive at the wrong time. Helpful suggestions feel intrusive. Automation saves effort, but erodes trust.

These aren’t implementation problems. They’re experience problems.

More specifically, they’re problems of interpretation - how people make sense of systems that think, adapt, and decide on their own.

What’s breaking in 2026 isn’t usability. It’s our ability to explain and shape what users are actually experiencing.

UX, as we’ve defined it, no longer fully describes the experience.

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

What AI Exposed (Not What It Broke)

It’s tempting to say AI broke UX.

But that gives AI too much credit.

Most of the discomfort designers feel right now didn’t come from new technology — it came from old assumptions being pushed past their limits. AI didn’t create new problems. It surfaced the ones we’ve been quietly designing around for years.

Traditional UX assumes predictability.
AI introduces probability.

Traditional UX assumes that designers define the experience.
AI systems continue shaping it long after launch.

Traditional UX treats behaviour as something users bring.
AI embeds behaviour directly into the system.

None of this is inherently bad. But it changes the nature of experience in ways our existing UX language struggles to describe.

When a system adapts, the experience isn’t just what appears on the screen - it’s when it appears, why it appears, and whether the user feels in control of the outcome. When an AI model makes a confident decision, users don’t evaluate accuracy alone. They evaluate judgment. Intent. Tone.

These moments don’t live in flows or components.
They live in interpretation.

AI didn’t break UX.
It exposed how much UX relied on the illusion of control - the belief that if we designed the right flow, the experience would remain stable.

Once that illusion fades, a quieter question emerges - one many designers are already carrying, even if they haven’t named it yet:

Most 3D and spatial UX doesn’t fail loudly.

It fails quietly through confusion, fatigue, or abandonment.
Not because the technology is immature, but because UX decisions don’t scale automatically into space.

In Part 1, we talked about principles.
In Part 2, we’ll look at how those principles show up in real products and where they break down.

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

Case Category 1: 3D in Product & E-commerce UX

When It Works 😎

Example pattern:
Interactive 3D product views that replace static image galleries.

What works well:

• User-controlled rotation (no auto-spin)

• Clear affordances (“drag to rotate”)

• Limited interaction scope

• 3D answers a specific question: size, fit, or form

Here, 3D reduces uncertainty.
It helps users make decisions faster, not admire visuals longer.

UX principle applied:
👉 Depth reduces effort.

Example: Nike 360° Product Exploration

• AI can generate photorealistic 3D shoe models and multiple colour-ways in minutes.

• Humans decide which views are meaningful, how rotation is controlled, and which interactions clarify size or fit.

UX Principle: Depth reduces effort
AI role: Rapid asset generation and variation
Human role: Selecting orientation, motion, and interaction clarity

When It Fails 😞

Example pattern:
Auto-rotating 3D models embedded by default.

What goes wrong:

• Motion without intent

• No explanation of interaction

• Cognitive overload on entry

• Performance issues disguised as “immersive experience”

Instead of clarity, users get distraction.

UX lesson:
3D should be invited, not forced.

Case Category 2: Augmented Reality (AR) Interfaces

When It Works 😎

Example pattern:
AR used for contextual guidance—navigation, measurement, or placement.

Why it succeeds:

• Overlays appear only when needed

• Visuals are lightweight and restrained

• AR clarifies reality instead of replacing it

The user remains grounded in their environment.
AR acts as an assistant, not a performer.

UX principle applied:
👉 Orientation before interaction.

Example: IKEA Place

• AI helps scale furniture accurately to a room’s dimensions using computer vision.

• Human designers ensure the AR overlay communicates clearly — orientation, scale, and interaction cues.

UX Principle: Orientation before interaction
AI role: Spatial measurement and asset placement
Human role: Interaction clarity and user guidance

When It Fails 😞

Example pattern:
Persistent AR overlays competing for attention.

Common issues:

• Visual clutter

• Too many floating elements

• No prioritisation

• User fatigue within minutes

The interface demands attention instead of supporting action.

UX lesson:
AR should respect reality, not dominate it.

Case Category 3: VR & Spatial Workflows

When It Works 😎

Example pattern:
Task-specific VR experiences—training, simulation, or focused collaboration.

What they get right:

• Clear session boundaries

• Purpose-built interactions

• Minimal UI

• Strong spatial anchors

These experiences don’t try to be everything.
They are opinionated, scoped, and intentional.

UX principle applied:
👉 Comfort is a UX requirement.

Example: Horizon Workrooms (Meta VR)

• AI assists in rendering environments and avatars realistically.

• Humans decide interaction scope, session length, and spatial anchors to prevent fatigue.

UX Principle: Comfort is a UX requirement
AI role: Asset rendering and variation
Human role: Spatial design, interaction pacing, and accessibility

When It Fails 😞

Example pattern:
2D interfaces “ported” into 3D space.

Symptoms:

• Floating panels

• Endless menus

• Long sessions

• Interaction fatigue

Nothing is gained by depth.
Everything becomes harder.

UX lesson:
If a workflow works best on a screen, forcing it into VR is not innovation.

Case Category 4: Hybrid 2D + 3D Interfaces

When It Works 😎

Example pattern:
3D used sparingly to explain structure, hierarchy, or relationships.

Why it works:

• 2D remains the backbone

• 3D adds meaning, not noise

• Motion communicates state changes

These interfaces feel modern but familiar.

UX principle applied:
👉 Motion is language, not ornament.

Example: Sketchfab 3D Model Viewer 

• AI-assisted rendering and compression make interactive 3D models fast.

• Humans select which models to display, how they’re oriented, and which interactions communicate value.

UX Principle: Motion is language, not ornament
AI role: Rendering and optimising 3D content
Human role: Curating interaction and information hierarchy

When It Fails 😞

Example pattern:
3D added as visual flair without functional purpose.

What happens:

• Slower interactions

• Increased cognitive load

• No clear benefit over 2D

The interface looks impressive.
The experience feels heavier.

UX lesson:
If users can’t articulate why 3D helps, it probably doesn’t.

Where AI Fits Into These Examples

AI shows up consistently across both good and bad cases but not as the deciding factor.

AI helps by:

• Generating assets faster

• Exploring variations

• Reducing production cost

AI fails when:

• It drives structure

• It replaces judgment

• It accelerates bad decisions

The difference between success and failure is never the tool.
It’s the design intent.

The Pattern Behind Success

Across all successful examples, the same signals appear:

• Clear purpose

• Limited scope

• Respect for human perception

• Restraint over spectacle

Good spatial UX doesn’t shout.
It settles.

Designing for Space Is Designing for Responsibility

As interfaces move from screens to spaces, designers don’t just design interactions.
They design how users feel inside systems.

Disorientation, fatigue, and confusion aren’t technical problems.
They’re UX signals.

The future of UX isn’t flatter or deeper.
It’s more intentional.

And in spatial interfaces, intent is felt immediately.

Final Thought

3D and extended reality aren’t the future of every interface.
But they are the future of some interactions.

The designers who succeed won’t be the ones who adopt 3D fastest.
They’ll be the ones who know when not to use it.

👉 And if you haven’t yet, subscribe here to get my free UX prompt guide for designing with AI - it’s the easiest way to keep exploring with me.

For most of its history, UX has been comfortably flat.

Screens. Cards. Modals. Scroll. Tap. Repeat.

Now, interfaces are gaining depth - literally.
AI can generate 3D objects, environments, and motion in seconds. AR and VR are no longer niche experiments. Hybrid visuals that mix 2D, 3D, and tactile aesthetics are quietly entering mainstream products.

This doesn’t mean every interface needs to become immersive.
It means UX is expanding beyond the screen.

And with that expansion comes responsibility.

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

Why 3D & Spatial UX Matter Now

3D in UX isn’t new. What’s new is accessibility.

AI has dramatically reduced the cost of creating:

• 3D assets

• Motion

• Environmental variation

• Visual depth

What used to require specialised teams is now available inside everyday design workflows.

But here’s the uncomfortable truth:
AI lowered the barrier to creation, not the barrier to confusion.

When depth is easy to add, it’s also easy to misuse.

This moment isn’t about trends or the return of the metaverse.
It’s about designing interaction in expanded space and doing it well.

The Designer’s Role in Spatial Interfaces

When interfaces move into 3D or spatial environments, designers don’t gain freedom.
They gain accountability.

In 2D, poor decisions can be hidden behind familiarity.
In 3D, bad UX is felt immediately - through discomfort, disorientation or fatigue.

Designing for depth forces a question we don’t always ask clearly enough:

Before interaction.
Before motion.
Before delight.

Core UX Principles for 3D & Spatial Design

These principles aren’t about visuals.
They’re about human perception and behaviour.

1. Spatial Clarity Beats Realism

Realism is seductive. It’s also distracting.

Users don’t need environments that look real.
They need spaces that make sense.

Clear hierarchy, orientation cues, and predictable behaviour matter more than textures or lighting.

If users are admiring the environment instead of understanding the task, the design has already failed.

2. Orientation Comes Before Interaction

In spatial interfaces, users must answer three questions instantly:

• Where am I?

• What can I do?

• What happens if I move?

Interaction without orientation creates anxiety.

Before inviting action, give users anchors - visual, spatial, or behavioural.
Movement should feel intentional, not exploratory by default.

3. Depth Must Reduce Effort

Depth is not value on its own.

3D should:

• Reduce steps

• Clarify relationships

• Replace cognitive load, not add to it

If an interaction works better in 2D, forcing it into 3D is not innovation — it’s decoration.

Good 3D UX feels simpler, not more impressive.

4. Motion Is Language, Not Ornament

In spatial interfaces, motion communicates meaning.

It shows:

• Cause and effect

• Hierarchy

• State change

• Direction and intent

Unnecessary motion is noise.
Inconsistent motion breaks trust.

Motion should explain the system, not perform for the user.

5. Comfort Is a UX Requirement

Discomfort is not a technical issue.
It’s a design failure.

Fatigue, dizziness or disorientation aren’t edge cases - they’re signals that the experience is asking too much.

In spatial UX:

• Shorter interactions are better

• Stillness is underrated

• Restraint is a design skill

Comfort isn’t the opposite of innovation.
It’s the foundation of it.

What Designers Must Unlearn

As UX expands into 3D and spatial environments, some habits need to be questioned:

• More depth does not mean better UX

• Visual novelty is not engagement

• 3D does not automatically equal immersion

Many spatial interfaces fail because they copy 2D patterns instead of rethinking interaction entirely.

Designing With Intent, Not Excitement

AI will continue to make 3D faster, cheaper, and more accessible.
That doesn’t make every interface better.

Design quality in spatial UX will be defined by:

• Clarity over complexity

• Comfort over spectacle

• Intent over possibility

As interfaces gain depth, UX must gain discipline.

What Comes Next

In Part 2, we’ll look at real examples  where 3D and spatial UX succeed, where they fail, and what designers can learn from both.

Because principles matter.
But seeing them in action is how designers sharpen judgment.

👉 And if you haven’t yet, subscribe here to get my free UX prompt guide for designing with AI - it’s the easiest way to keep exploring with me.

Why Designers Aren’t Being Replaced — They’re Being Repositioned

AI can now generate screens, flows, personas, UX copy, and even research summaries in minutes.

So the uncomfortable question is no longer “Can AI design?”
It’s “What exactly is the designer’s role now?”

If you’re feeling both excited and uneasy, that tension is the point.
We’re not watching design disappear.
We’re watching it move upstream.

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

AI Is Fast. Design Is Still Human.

Let’s get one thing clear:
Human–AI collaboration is not about handing over decisions to machines.

It’s about redistributing effort.

AI is exceptionally good at:

• Exploring variations at scale

• Spotting patterns across large datasets

• Accelerating ideation and execution

• Turning rough intent into something tangible

But design has never been about speed alone.

Design is about:

• Framing the right problem

• Making trade-offs under constraints

• Understanding human behaviour, culture, and emotion

• Balancing user needs with business reality

Those are not mechanical tasks.
They’re judgment calls.

And judgment is still very human.

The Shift We’re Experiencing (But Rarely Name)

What’s really changing isn’t what we design.
It’s where designers spend their cognitive energy.

We’re moving from:

• Doing → deciding

• Executing → orchestrating

• Crafting pixels → shaping systems

In a Human–AI workflow, the designer is no longer the primary producer.
They’re the editor, curator, and strategist.

AI generates.
Humans choose.

A Practical Human–AI Design Workflow

Here’s what collaboration actually looks like in practice using tools many of us already touch daily:

Human-AI Design Workflow

1. Human sets intent
   Define the problem, constraints, user context, and success criteria.

2. AI explores possibilities
   Generate flows, content options, layouts, or research summaries.

3. Human critiques and reframes
   What feels off? What’s missing? What assumptions are being made?

4. AI refines
   Iterate based on human judgment and direction.

5. Human decides
   Final calls, trade-offs, and accountability remain with the designer.

This loop repeats - not to replace thinking, but to amplify it.

The danger isn’t using AI.
The danger is skipping the human checkpoints.

Where AI Helps and Where It Absolutely Shouldn’t Lead

AI excels at:

• Speed and scale

• Pattern recognition

• Generating options without fatigue

• Reducing blank-canvas anxiety

Humans must lead in:

• Problem framing

• Ethical judgment

• Contextual understanding

• Taste, nuance, and narrative

• Long-term system thinking

If we allow AI to lead in the second list, we don’t get better design.
We get faster sameness.

The Real Risk: Design Without Ownership

The biggest risk in AI-powered workflows isn’t job loss.

It’s responsibility loss.

When everything is prompt-driven, it becomes tempting to:

• Accept outputs without critique

• Confuse plausibility with quality

• Ship faster without understanding why

Design doesn’t disappear in this future.
Accountability does.

And when no one owns decisions, users feel it.

The New Skill Designers Must Build

The most valuable designers won’t be the ones who know the most tools.

They’ll be the ones who:

• Ask better questions

• Write clearer intent

• Challenge AI outputs instead of polishing them

• Design guardrails, not just interfaces

Human–AI collaboration rewards thinking clarity, not prompt cleverness.

Designing With Machines, Not For Them

AI will continue to accelerate.
Design will continue to evolve.

But the role of the designer doesn’t shrink—it sharpens.

The future of design isn’t human vs machine.
It’s human with machine.

And humans still decide what matters.

If you want to collaborate with AI without losing design judgment, I’ve put together a practical AI Prompt Pack for UX Designers — prompts I use to frame problems, critique outputs, and make better decisions with AI as a co-pilot.

Explore it here:
👉 https://designxmachine.gumroad.com/l/AIPromptPackfor-UXDesigners

In 2025, I designed faster than I ever had in my career.

Not because I suddenly became more disciplined, but because AI quietly removed the friction that used to slow me down. I could generate personas in hours instead of weeks. I could explore multiple complex flows in a day. I could audit parts of a design system without starting from nothing.

From the outside, it looked like progress.

But somewhere between generating my fifth persona and reviewing my tenth AI-assisted insight summary, I noticed something uncomfortable.

I wasn’t tired from doing too much.
I was tired from deciding too little.

Designing with AI didn’t make my work less human.
It made me more aware of when I stopped being human in my thinking. So, I wonder…

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

When AI Becomes a Mirror

The first time AI generated a set of personas that looked good enough, I felt impressed.

The structure was there. The motivations made sense. The frustrations were believable.

And that’s when it hit me.

These personas weren’t insightful - they were familiar.

They mirrored patterns I had already internalised over years of designing. AI didn’t invent anything new. It simply reflected what I had been doing but faster.

That reflection was confronting.

If AI could reproduce my thinking so easily, it meant some of my design decisions had become habits rather than choices.

AI became a mirror.
And sometimes, the reflection showed me where curiosity had quietly faded.

Personas Are Easy. Conviction Is Not.

In 2025, I created more personas than in any other year of my career.

AI helped me draft, refine, and stress-test them. It surfaced assumptions. It filled gaps. It accelerated clarity.

But when it came time to present those personas to stakeholders, the questions changed.

People didn’t ask how they were generated.
They asked whether I believed in them.

AI could help me create personas.
It couldn’t help me stand behind them.

That responsibility - deciding what mattered, what to prioritise, what to defend - remained human. Speed didn’t remove accountability. It amplified it.

User Testing Reminded Me That Insight Isn’t Empathy

AI made user testing outputs cleaner.

It summarised feedback. Grouped patterns. Highlighted themes.

But the moments that stayed with me weren’t in the summaries.

They were in the pauses.
The hesitation before an answer.
The frustration someone tried to laugh away.

AI could tell me what users said.
It couldn’t sit with how it felt to hear it.

Empathy didn’t come from synthesis.
It came from attention.

When Speed Stops Being the Advantage

By mid-2025, execution stopped being the bottleneck.

I could generate flows, components, and variations faster than teams could review them. The question was no longer Can we design this? but Should we?

This became especially clear in design system work.

AI could help audit components and surface inconsistencies. But it couldn’t navigate organisational politics. It couldn’t weigh legacy constraints against future scalability. It couldn’t decide when consistency mattered and when flexibility mattered more.

Those decisions lived in grey areas.
And grey areas don’t respond well to automation.

Judgment became the real craft.

Systems Made Responsibility Visible

Design systems in 2025 weren’t just about reuse.

They were about governance, intent, and impact.

AI expanded the reach of decisions. Which meant the consequences of those decisions traveled further than before.

Every token, rule, and constraint carried downstream effects.

AI amplified my influence.
Which meant it also amplified my responsibility.

There was no hiding behind best practices anymore - only clear intent or its absence.

Letting Go of Designer Ego

And this impacted me the most - the hardest part of designing with AI wasn’t learning new tools.

It was letting go of an identity.

For years, being a designer meant being the expert - the one with answers, taste, and control. AI disrupted that comfort.

Good ideas could come from anywhere. From machines. From non-designers. From unexpected places.

My role shifted from creator to orchestrator.
From expert to editor.

At first, it felt like loss.
Eventually, it felt like clarity.

The best work didn’t come from proving I was right.
It came from staying curious long enough to choose what was better.

What Stayed Human

After a year of designing with machines, I don’t believe AI is here to replace designers.

It’s here to remove the hiding places.

It exposes shallow thinking. It challenges comfortable habits. It forces us to be explicit about why we design the way we do.

What stayed human was never the output.

It was the doubt.
The judgment.
The care.
The responsibility to choose thoughtfully when speed made it easy not to.

That’s what I’m carrying into 2026.

A Quiet Note If You’re Designing With AI Too

Throughout this year, I’ve been building and refining prompt kits - not as shortcuts, but as thinking scaffolds.

They’re designed to help designers:

• Frame better questions

• Slow down decisions when AI speeds things up

• Apply judgment, not just generation

If you’re navigating design in the age of intelligent systems, you might find them useful.

Explore the Design x Machine prompt kits

No pressure. Just tools I use myself.

Goodbye, 2025. Here’s to designing with more intention in the year ahead.

-Ryda.

2025 Was Just the Beginning

2025 quietly changed design forever. AI started whispering in our tools suggesting colours, predicting layouts, generating components. By the end of the year, we realised: design isn’t just about making screens anymore.

Heading into 2026, the question shifts from:
“Can AI help me design?”
to
“How do I scale multi-channel, multi-product experiences with AI?”

And at the centre of this shift stands Figma.

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

The Multi-Channel Maze

Designing for one platform is tricky. Designing for many? It’s chaos.

• A button looks perfect on web but awkward on mobile.

• A dashboard flow works for SMEs but fails under enterprise requirements.

• Iterations feel endless when updating multiple brands or product variants.

If you’ve ever tried updating a component across three platforms for six products, you know the struggle.

Figma as the Single Source of Truth

Figma has long been powerful for UI/UX design: component libraries, variants, design tokens, collaborative real-time editing. But with the latest wave of updates — especially from the 2025 Config launch slate — Figma is evolving into a design-to-product platform.

What’s new in 2025:

• Figma Make: AI-powered “prompt-to-app / prompt-to-prototype” tool — turn prompts or Figma designs into interactive prototypes or functional web apps.

• Design systems integration: Import Figma libraries (colours, typography, components) into Make — prototypes respect your brand/design system.

• Backend support: Make integrates with databases (e.g., Supabase) so prototypes are dynamic, not static.

• Expanded AI tooling: Beyond Make, Figma is rolling out AI-assisted site builders, asset tools, improved vector tools, and better design-to-dev workflows.

Together, these updates turn Figma from “just a design canvas” into a foundation for multi-channel product design, letting you maintain a single source of truth across platforms.

What 2026 Could Bring: AI-Driven Multi-Channel Workflows

Looking ahead, here’s how AI + Figma might shape multi-channel design workflows:

• Automated consistency enforcement: AI detects divergences from design tokens and recommends fixes.

• Smart variant adaptation: Build desktop components; AI generates responsive/mobile/tablet versions automatically.

• Accessibility & UX checks: AI highlights issues with contrast, spacing, or readability before dev handoff.

• Faster prototyping → faster validation: Spin up early interactive prototypes for web, mobile, or dashboards to get feedback quickly.

• Unified design + code pipelines: Reduce friction between design and dev for multi-brand or multi-business systems.

In short, 2026 may be the year design systems evolve from static libraries into living, AI-enhanced product foundations.

Practical Tips for Designers/Teams

• Keep your design system tidy: Organise components, tokens, typography consistently.

• Start small: Prototype one module/flow first, then scale.

• Use prototypes for alignment: Demo flows for different segments (SME, Enterprise, Wholesale).

• Review AI-generated output: Clean up quirks, check accessibility, performance. AI is an assistant, not a replacement.

• Document workflows & decisions: Maintain consistency across variants and future iterations.

Vision: The Future of Design × AI at Scale

By 2026, many teams will shift from multiple design libraries to a unified, AI-backed system:

• Designers define the rules, AI enforces, adapts, and implements.

• Front-end engineers focus on complex logic, while AI handles UI generation, system consistency, and rapid iteration.

• Enterprises juggling multiple product lines gain scalable, faster, more agile design systems.

What’s Fact vs. What’s Vision

Figma is evolving fast. What’s your vision for AI-powered design in 2026? Share your ideas or predictions - I’d love to hear from you!

Before you share your thoughts, don’t forget to subscribe and grab my free UX prompt guide for designing with AI - it’s the easiest way to start experimenting with the future of design.

TL;DR

• Design drift is becoming the biggest cost in scaling design systems.

• In 2026, AI will automatically flag token duplication, naming drift, and structural inconsistencies.

• Multi-brand systems will shift from “shared libraries” to orchestrated inheritance models (Core → Brand → Product).

• Semantic, intent-based components will replace rigid atomic structures.

• AI can enhance governance, but it cannot replace cross-functional alignment.

• The smartest systems will be predictive, not reactive — catching issues before they spread.

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

Design systems used to be style guides.

Then they became living systems.

Now entering 2026 - they’re becoming intelligent ecosystems.

If 2025 was the year of “AI-assisted design,” 2026 will be the year of AI-enforced consistency, multi-brand orchestration, and deep operational clarity. For teams managing multiple segments, business units, or product lines—telecoms, enterprise, and wholesale, for example—this evolution isn’t optional.

It’s survival.

The Problem: Drift Happens Faster Than You Think

Every design system has a silent killer:
Design drift.

Not malicious.
Not intentional.
Just… human.

Different teams move at different speeds. Tokens get duplicated. New product squads introduce “just one more exception.” Engineers override styles to hit deadlines. And before you know it, the system that was supposed to unify becomes a maze of inconsistent shades of blue, eight competing button sizes, and three naming conventions no one fully understands.

In a multi-brand environment?
Multiply that pain by five.

In 2026, the biggest cost in design systems won’t be creating components.
It will be detecting and preventing drift before it spreads.

This is where AI quietly becomes the hero.

Prediction #1: AI Will Flag Token Drift Automatically

Forget manual audits (or spending nights scrolling through token lists like a zombie).

By mid-2026, modern design systems will have AI that:

• Detects duplicate or near-duplicate tokens

• Flags broken naming patterns

• Identifies mismatched semantic tokens

• Predicts which components are likely to cause future inconsistencies

• Auto-generates clean naming recommendations

Think of it as linting, but for your design system.

We’re moving into a world where AI will watch the system as it evolves and whisper:
“Hey, your spacing scale is drifting.”
Or: “This business unit is about to create a rogue colour ramp.”

The teams that adopt AI auditing early?
They’ll save thousands of hours (and headaches).

Prediction #2: Multi-Brand Systems Will Shift from “Shared” to “Orchestrated”

2026 will also be the year teams stop forcing everything into one global system.

Instead, expect orchestrated multi-brand systems:

• A Core System with primitives, tokens, and foundational rules

• Brand Variants that inherit but override with intelligence

• Automated guardrails to prevent breaking changes

• AI that suggests what should be shared vs. forked

The future isn’t “one system for all brands.”
It’s one intelligent framework coordinating many systems.

Brands will no longer fight for alignment
the system will enforce it.

Prediction #3: Component Libraries Will Become Semantic, Not Atomic

Atomic design served us well.

But in complex enterprise and multi-market ecosystems, atomic = too rigid.

Semantic systems
where a button is not just “primary/secondary” but “action tier based on intent, risk level, and platform priority”
will dominate.

And AI will help classify components automatically based on usage patterns.

This means:

• No more guessing which component variant to use

• No more 40-variant dropdowns

• No more “why do we have six modals?”

The system becomes smarter because it learns from real product data.

Pitfall #1: AI Won’t Fix Your Governance Problems

AI will detect drift.
AI will suggest token cleanup.
AI will predict breaking changes.

But AI will not:

• Solve unclear ownership

• Replace cross-functional governance

• Fix a team structure that ships chaos faster than consistency

If your org still treats the design system as a “side project,” AI will only help you fail faster.

Pitfall #2: Multi-Brand Without Multi-Discipline = Disaster

Multi-brand scaling requires:

• Design

• Product

• Engineering

• Marketing

• Brand

• Accessibility

Without cross-discipline alignment, you’ll end up with a “Frankenstein System” where tokens are shared but behaviour isn't, or where brand overrides break engineering logic.

The system must serve all—not just design.

Power Move #1: Adopt AI-Enabled Token Governance

Make 2026 the year you shift from “manual policing” to “smart guardrails.”

Practical steps you can implement right now:

• Run AI audits on token duplication

• Map semantic token usage across business units

• Use AI to simulate how new tokens might affect existing components

• Train your system to recommend naming and scaling patterns

This turns your design system into a predictive engine, not a reactive one.

Power Move #2: Set Up a Multi-Brand Inheritance Model

Before the AI magic, get your architecture right.

Define:

• What is Global Core

• What is Brand Layer

• What is Product Layer

• What is allowed to override and what is locked

Once these rules are set, AI can enforce them.

Without this clarity, AI becomes noise.

Power Move #3: Build a “Design System Intelligence Dashboard”

In 2026, design leaders won’t ask:

“How many components do we have?”

They’ll ask:

• “Where is drift happening?”

• “Which tokens need consolidation?”

• “Which products ship inconsistent variants?”

• “Where are duplication hotspots?”

• “Which teams are creating the most exceptions and why?”

Your DS dashboard will be your new north star.

And AI will populate it for you.

Final Thought: The Design System of 2026 Is Less About Components… and More About Intelligence

Design systems are entering their machine era.

Not to replace designers
but to help us stay consistent at scale, especially when our orgs move faster than we can police.

The future belongs to teams that:

• Let AI catch drift early

• Build multi-brand systems that scale with clarity

• Follow semantic logic instead of arbitrary rules

• Treat design systems as a strategic product, not a task list

2026 won’t reward the prettiest systems.

It will reward the smartest ones.

And the teams who embrace AI-powered consistency?
They’ll turn chaos into clarity before it becomes costly.

What shift do you think will define the future of design systems in 2026 and why? I’d love to hear your take.

👉 And if you haven’t yet, subscribe here to get my free UX prompt guide for designing with AI - it’s the easiest way to keep exploring with me.

TL;DR

• Speed and Clarity: Gen Z expects fast, mobile-first, frictionless interactions.

• Community & Social Proof: Engagement thrives through peer validation—think duets, reviews, and live reactions.

• Galau Moments: Design for emotional expression with quick content creation tools, mood-based filters, and real-time validation.

• Hyper-Personalisation: Offer personalised experiences with full transparency, without creepy tracking.

• Gamification: Use reward loops and progress bars to boost engagement and create continuous interaction.

• Inclusivity & Ethics: Ensure diverse, accessible design options and reflect ethical values in every interaction.

• Emerging Tech: Seamlessly integrate AR, AI, and voice features to enhance—not distract—from the UX experience.

Want more like this?
Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

Why We Know UX Psychology but Rarely Apply It

Gen Z isn’t just a younger demographic—they’re digital natives, hyper-connected, and shaped by an ecosystem of TikTok loops, AI recommendations, and short-form content. Traditional UX patterns don’t always resonate with them, and if your designs feel slow, cluttered, or irrelevant, users will swipe past.

In Malaysia and Southeast Asia, the ways Gen Z expresses themselves online—through trends, emotions, and rapid content consumption—offer clues for designing products that feel intuitive, meaningful, and addictive in the best way. Here’s how to design for this emerging behaviour.

1. Digital Natives Demand Speed and Clarity

Gen Z users expect near-instant access to content. Slow load times or confusing navigation triggers drop-offs immediately. UX must prioritise mobile-first interactions, streamlined flows, and minimal friction. Short scrollable feeds with visible progress indicators or instant previews can make a huge difference in retaining attention.

2. Social Proof and Community Are Non-Negotiable

This generation thrives on peer validation and community engagement. Reviews, likes, duets, and live updates influence trust. Platforms that make it easy to participate, not just consume, create deeper engagement. TikTok’s duet and stitch features are a prime example—users aren’t passive; they’re co-creating, commenting, and reacting in real-time.

3. Local Flavour: Designing for “Galau Moments”

One thing we can’t ignore in a Malaysian Gen Z context is their love for “galau” moments—the tiny, emotional snapshots of heartbreak, stress, or existential musings they post on TikTok. These aren’t just viral trends; they’re a window into how this generation expresses emotion online.

“Galau” trend on TikTok

From a UX perspective, platforms that make it easy to create, share, and interact with these bite-sized emotional expressions win. Quick templates, mood-based filters, or simple sticker and text tools allow users to convey feelings instantly. Community validation through likes, duets, or comments amplifies engagement, turning emotional micro-moments into shared experiences. Designing for galau isn’t just playful—it’s designing for connection.

4. Hyper-Personalisation Without Creepy Factor

Gen Z loves personalised experiences but resents overly invasive tracking. AI can recommend content, layouts, or features—but transparency and user control are key. Spotify’s Daily Mix playlists, for instance, feel personal without revealing all the data behind them, striking a balance between delight and privacy.

5. Gamification and Reward Loops

Gamified elements like streaks, badges, or leveling up increase engagement. Gen Z responds to visual, immediate feedback. Subtle reward loops, progress bars, and celebratory animations encourage continued interaction without overwhelming the user. Duolingo and TikTok challenges are prime examples of this principle in action.

6. Ethics, Inclusivity, and Representation Matter

Social consciousness shapes this generation. They notice when apps ignore diversity, accessibility, or sustainability. UX must reflect inclusivity—dark/light modes, pronoun options, and customisable avatars are simple yet powerful ways to show respect for user identity.

7. Embrace Emerging Tech Thoughtfully

AR, AI, and voice interfaces are part of Gen Z’s daily digital experience. Early adoption is high, but novelty alone isn’t enough. Seamless, human-centered implementation matters more than flashy tech. AI-assisted recommendations, AR try-ons, and voice shortcuts should enhance the experience, not distract from it.

Actionable Takeaways:

• Design for speed, clarity, and mobile-first interactions.

• Make social and community elements central to UX.

• Enable hyper-personalisation responsibly.

• Gamify thoughtfully to boost engagement without fatigue.

• Prioritise inclusivity, accessibility, and ethics.

• Experiment with emerging tech while keeping the user human-centered.

• Recognise local and emotional trends like galau to design for real-life cultural expression.

Gen Z is shaping the future of UX. They won’t adapt to your product; your product must adapt to them. By understanding their digital behaviours (both global and local) you’re not just designing interfaces; you’re designing connections, emotions, and shared experiences.

👉 And if you haven’t yet, subscribe here to get my free UX prompt guide for designing with AI - it’s the easiest way to keep exploring with me.

TL;DR

AI isn’t dangerous because it’s biased or hallucinates - it’s dangerous because designers often trust those outputs too quickly. In a recent usability test, one of the lead designers accused our instructions of being “leading” based on a ChatGPT response without asking for context.

This moment revealed a bigger truth: AI can create false confidence, bias our judgment, and weaken our critical thinking. Ethical UX in the era of AI requires slowing down, asking the right questions, and interrogating AI’s assumptions not outsourcing our own.

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

I didn’t plan to open this story with an arrogant lead designer.
But here we are.

A week ago, during a usability test recap, one of the senior designer colleague pasted our findings into ChatGPT and immediately concluded:

Just like that.
One sentence.
Full stop.
Case closed.

What he didn’t know or didn’t bother to ask was this:

The question wasn’t leading.
It was instructional.
We were testing what happens after the task.
We wanted the behaviour that followed, not the phrasing of the instruction.

But because an AI model said it looked leading, he concluded it was leading.
He trusted the model more than the humans running the study, and definitely more than the context.

This is the new danger of AI in UX:
false confidence wrapped in fluent sentences.

AI speaks smoothly.
Humans trust smoothness.
And smoothness becomes “truth” - even when it’s wrong.

The Day I Realised AI Isn’t the Problem — People Are

The problem isn’t that ChatGPT said the question looked leading.
The problem is that someone with authority believed it without thinking.

No asking:

• “Why does it look leading to you?”

• “What context is ChatGPT missing?”

• “What behaviour did we actually want to observe?”

• “What assumptions are we making here?”

No 7 Whys.
No curiosity.
Just judgment.

And this is exactly how bias, hallucination, and ethical blind spots enter a product team.

Not because AI is malicious —
but because humans get lazy when a machine sounds smart.

AI Creates Problems Designers Aren’t Trained For

UX has always been about understanding humans.
Now UX also has to understand machines that think like humans… but not really.

AI has a few behaviours that every designer urgently needs to recognise:

1. The Bias Illusion

AI mirrors whatever dataset it was trained on.
If it saw more Western examples, male personas, English-speaking flows, or common patterns, it will assume that’s the world.

Bias becomes invisible, because it feels “normal.”

2. The Hallucination Problem

AI generates confident answers even when it has no basis for them.
It fills the gaps with guesses.

Guesses made with style ≠ truth made with evidence.

3. The Authority Trap

Humans give AI “expert status” because it sounds certain.
Designers stop asking questions.
They stop challenging assumptions.
They stop being curious.

And slowly, the designer becomes the assistant, not the machine.

The Real Ethical Danger: When Designers Stop Thinking

AI doesn’t create unethical products.
Designers do — when they blindly accept what AI gives them.

The moment a designer thinks:

That’s when the damage begins.

It can be small:
a mislabelled persona, a wrong assumption, a biased research summary.

Or huge:
a broken flow rolled out at scale,
a misinterpreted user behaviour,
a design that misleads instead of guides.

All because no one asked,
“Why does the AI think this way?”
“What’s missing?”
“What don’t we know?”

Ethical UX isn’t a policy.
It’s a muscle.

And AI is quietly making that muscle weaker unless we intentionally fight it.

The 7 Whys: Your New Defence Against AI Overconfidence

If there’s one habit every designer needs in the era of AI, it’s this:

**Never accept an AI answer at face value.

Interrogate it. Always.**

Use the 7 Whys method:

1. Why did it generate that assumption?

2. Why does this sound correct?

3. Why might this be wrong?

4. Why is context missing?

5. Why would a human think differently?

6. Why would a user behave differently?

7. Why does this matter for the product?

AI is not a critical thinker.
It cannot reason with lived experience, culture, behaviour, or nuance.
It can only remix patterns and probabilities.

Designers, on the other hand —
we work with consequences.
We make decisions that affect real people.

Critical thinking is not optional anymore.
It’s ethical.

The Truth We Don’t Want to Admit

AI makes everything feel faster.
But it also makes everything feel easier - too easy.

And easy thinking is dangerous thinking.

The arrogant lead designer from my story didn’t realise this:
He wasn’t using AI wrong.
He was using himself wrong.

He stopped thinking.
He outsourced judgment.
He traded curiosity for confidence.

And that, right there,
is the dark side of AI in UX.

Not the technology.
Not the hallucinations.
Not the bias.

But the moment a designer assumes:
“The machine has already thought for me.”

If AI is the machine… then designers must become the mind.

We’re not here to accept what AI gives us.
We’re here to question it, interpret it, reshape it, and align it with human reality.

In the era of AI, the most powerful skill a designer can have isn’t speed.
Or aesthetics.
Or prompt-engineering.

It’s ethical critical thinking.
The courage to ask:
“Is this really true?”
“Who might this harm?”
“What bias is hiding here?”
“What context is missing?”
“What would a real user actually do?”

The Designer’s Mind Is the Last Line of Defense

AI will keep getting smarter, faster, smoother, and more convincing.
But that doesn’t mean our thinking should get softer.

The truth is this:
AI won’t replace designers - but it will replace designers who stop thinking.

The future of UX isn’t about who can prompt the best or move the fastest.
It’s about who can pause, question, interpret, and challenge the machine with a human lens.
It’s about designers who understand that every AI answer is a draft, not a decision.

Because products don’t become unethical in a single big moment.
They become unethical in hundreds of small ones -
when assumptions go unchecked,
when context is ignored,
when bias slips through quietly,
and…
when curiosity is replaced by convenience.

If we want to design responsibly in an era of intelligent systems, we need to protect the one skill AI can’t mimic:
our ability to think critically, ethically, and with intention.

AI can give us speed.
But only designers can give meaning.

And that’s the real work now -
not fighting the machine,
but staying awake while using it.

If this kind of exploration resonates with you…
👉 And if you haven’t yet, subscribe here to get my free UX prompt guide for designing with AI - it’s the easiest way to keep exploring with me.

TL;DR

• Messy design tokens cost more than you think.
  They quietly slow teams down, fragment user experiences, and create invisible debt that compounds over time.

• Redundant values, unclear naming, missing documentation, and token drift aren’t small mistakes - they’re system signals we often ignore.

• AI changes the game. It can now surface conflicts, inconsistencies, and outdated values in seconds, giving teams clarity without the manual grind.

• A clean token architecture isn’t just visual hygiene. It’s performance. It’s efficiency. It’s brand integrity.
  Your tokens always leave clues.
  This time, we’re reading them.

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

Every System Has a Pulse

Design systems are built to bring order - a shared language across designers, developers, and product teams.
But even the strongest systems begin to show tiny fractures over time.

You’ve probably seen it.
You open a design file and something just feels… not quite right.
A button shade that looks fine in isolation but clashes on a different page.
A type scale that’s almost consistent, but something is off.
Spacing that seems familiar until it isn’t.

These moments feel small, but they are early warnings.
Subtle signals that your tokens are drifting out of alignment.

And once they drift, the ripple effect begins.

Why Tokens Matter More Than We Admit

Tokens aren’t glamorous.
They’re not flashy hero components or fancy motion transitions.
But they’re the structural DNA of your system.

Color.
Typography.
Spacing.
Elevation.
Borders.
States.

Tiny decisions that silently decide everything.

When they’re clean and aligned, your product feels intentional.
When they’re messy, the entire experience absorbs the chaos - slowly, invisibly, but deeply.

The Hidden Cost of Messy Tokens

 Here’s what actually happens when tokens go unchecked:

1. Redundancy Creeps In

Two tokens doing the same job.
Three different shades of “blue” that users will never distinguish.
A spacing token that repeats under three different names.

Each duplication adds friction:
Which one should designers use?
Which one should developers follow?
Which one is the real one?

Redundancy quietly bloats your system and erodes trust.

2. Lack of Documentation Breaks Flow

A token with no description is a decision without context.
Teams hesitate.
Misuse happens.
You spend more energy explaining than designing.

Without documentation, tokens lose purpose and your system loses clarity.

3. Token Drift Happens Faster Than You Expect

As products evolve, new tokens get added, but old ones rarely get removed.
Migrations happen halfway.
Brand updates apply here, but not there.

This is token drift.
A slow separation between what your design system says and what your product actually looks like.

Users may not pinpoint the cause, but they feel the inconsistency.
And that feeling affects trust.

How AI Helps You Catch What Humans Miss

This is where AI becomes a silent partner in design operations.

AI can now:
✅ Detect redundant tokens
✅ Highlight mismatched values
✅ Spot accessibility violations in color contrast
✅ Compare component variants against token definitions
✅ Flag outdated or unused tokens
✅ Visualise patterns humans overlook

What used to take hours of manual auditing becomes a 20-second scan.

AI doesn’t replace design judgment but it amplifies it.

It gives you the clarity to fix what matters, and the time to focus on the decisions humans should be making.

Why Cleaning Up Tokens Pays Off

A clean token architecture unlocks:

✅ Faster workflows
Teams spend less time guessing, matching, validating.

✅ Stronger product consistency
Every screen feels like it belongs to the same universe.

✅ Reduced technical & design debt
You stop accidental complexity before it spreads.

✅ Better performance
Optimised tokens lead to leaner components and smoother UI.

✅ Scalable design maturity
A robust token layer is the foundation of every future upgrade — from dark mode to theming to multi-brand systems.

Tokens may be small, but their impact is systemic.

Final Thought

Design tokens are the quiet storytellers of a design system.
If something feels off in your product, your tokens usually knew it first.

Listen to them.
Audit them.
Let AI help you see what you’ve been overlooking.

A cleaner foundation creates a calmer, more predictable system - for your team, your product, and your users.

Discover what your design system is really saying

Download the FREE Mini Token Audit Kit.

Start auditing your tokens today with a simplified Figma workspace and AI prompts. The full version with multi-category tables, complete workflows, and dev-ready exports is coming soon.

👉 And if you haven’t yet, subscribe here to get my free UX prompt guide for designing with AI - it’s the easiest way to keep exploring with me.

TL;DR

• AI now reads micro-behaviours far earlier than humans can.

• Patterns like hesitation, looping, friction, and cognitive bias trails are detectable in real time.

• Telco, enterprise, and SaaS workflows reveal the biggest gaps - AI predicts churn and confusion before analytics do.

• UX in 2025 is no longer reactive; it’s anticipatory and behaviour-aware.

• This article breaks down 20 behaviours AI already understands better than designers and why that matters for intelligent experience design.

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

In 2025, UX has quietly crossed a threshold.
We no longer design for behaviour - we design with it.

AI models observe micro-patterns the human eye glosses over, decode irrationality at scale, and surface cognitive biases long before they become friction, churn, or a “mysterious drop in conversions.”

Below are 20 behaviours AI already detects long before humans do, drawn from real product realities - enterprise portals, telco workflows, finance management systems and the invisible decision-making loops inside them.

1. Choice Overload Drift

AI sees the subtle pause - the “Hmm…” moment when too many options stall a decision.

2. Form Fragmentation

It identifies the exact field where hesitation turns into abandonment.

3. Navigational Loops

Humans see clicks. AI sees the pattern: looping, uncertainty, wandering.

4. Preference Micro-Shifts

Minor changes in feature usage hint at evolving priorities.

5. Engagement Dip Signals

Before dashboards turn red, AI catches micro-interaction decline.

6. Scroll Fatigue

Long scrolls + zero action = attention slipping away.

7. Confirmation Bias Trails

AI predicts where users cling to familiar options even when better ones exist.

8. Input Error Hotspots

It detects the fields users repeatedly correct or abandon.

9. Feature Ghosting

Features that users “see but don’t process.” AI flags the blind spots.

10. Decision Latency

Micro-hesitation signals reveal uncertainty in the workflow.

11. Click Hesitation Signatures

Hover - pause - hover again. Cognitive conflict, captured early.

12. Onboarding Blindness

Patterns of skipped tooltips and ignored guidance.

13. Menu Circling

Unclear IA - circular behaviour. AI identifies it long before complaints surface.

14. Label Misinterpretation

If users keep triggering tooltips, the terminology is the problem.

15. Time-to-Task Deviations

AI flags when routine tasks start taking longer than baseline.

16. Priority Heat Zones

Scroll maps become prediction maps - AI tells you what users truly care about.

17. Partial Workflow Drop-Offs

The earliest signals of churn hide inside incomplete actions.

18. Frustration Micro-Bursts

Rapid taps, repeated clicks, jittery cursor movements - immediate friction alerts.

19. Shortcut Instincts

Users improvise workarounds; AI spots the hacks and suggests better pathways.

20. Disengagement Drift

Long before NPS dips, AI predicts who’s about to fade away.

The deeper story

These behaviours aren’t new.
What’s new is our ability to read them.

AI decodes irrationality with clarity.
Designers can finally design with psychology, not just around it.

This article ties directly into my previous deep dive:

“Predictably Irrational: What AI Thinks About Human Behaviour in Design.”

Where cognitive bias meets machine pattern recognition.

🎁 Download the “UX Psychology × AI Prompts Pack”

Everything in this article becomes actionable when you know how to prompt AI the right way.
This toolkit gives you the exact frameworks and prompts to:

• Surface hidden biases in user behaviour

• Spot friction before it becomes churn

• Design with AI as a behavioural analysis partner

• Build intelligent flows across telco, finance, healthcare, e-commerce, and SaaS systems.

👉 Grab the UX Psychology × AI Prompts Pack

TL;DR

• Most teams don’t have a dedicated UX research function - designers carry the weight.

• AI now acts as a research partner, not a replacement for real users.

• AI accelerates domain learning, interview prep, note synthesis, and insight generation.

• A full research cycle can now be done in days instead of weeks.

• A simple 5-step workflow:

  1. AI domain absorption

  2. Interview script generation

  3. Synthetic interviews (hypothesis shaping)

  4. Real user interviews

  5. AI-assisted insight synthesis

• Designers focus on judgment and interpretation - AI handles the heavy lifting.

• AI removes the excuse for “no research budget or time.”

• Designers shift from executor → research orchestrator.

Want more like this? Subscribe to get my free UX prompt guide for designing with AI and join the exploration.

Most teams don’t have a research department.
Some don’t even have two designers.

And yet every product decision demands evidence.
Every feature requires user understanding.
Every roadmap meeting asks, “What do the users actually need?”

But in the real world, research often gets pushed aside because teams believe it requires time, budget, and headcount they don't have.

This is where AI steps in - not to replace researchers, but to become the research partner designers have needed for years.

AI doesn’t replace user truth.
It replaces the silence between your questions and the answers you need.

This article explores how designers can run credible, insight-driven research with AI even in environments where a research team doesn’t exist.

The Research Gap No One Talks About

Here’s the honest reality of many B2B product teams:

• One designer doing the job of three.

• Zero dedicated researchers.

• Tight timelines and tighter expectations.

• Decisions made based on senior opinions, not user evidence.

Research is rarely deprioritised because it’s unimportant - it’s deprioritised because it feels impossible under pressure.

AI changes this.
It removes the logistical barriers and gives designers a second brain for research — fast, structured, and scalable.

What AI Actually Solves (and What It Doesn’t)

AI is extremely good at the parts of research that drain time:

✅ AI excels at:

• absorbing domain knowledge instantly

• suggesting interview structures

• simulating behavioural patterns for early thinking

• analysing transcripts in seconds

• clustering themes into insight patterns

• summarising long notes into clear briefs

• identifying contradictions or gaps

• running quick competitive analysis

❌ AI cannot replace:

• emotional nuance

• cultural or contextual depth

• lived experience from real users

• ethical decision-making

• your strategic interpretation

• real-world observation

The 5-Step “AI Research Partner” Workflow

This workflow is built for real teams - small, fast, high-pressure environments where asking for a 6-week research sprint is unrealistic.

Step 1: Instant Domain Absorption

Instead of spending days studying complex domains, you instruct AI to break it down.

Example:

“Explain the SME onboarding ecosystem in telco. List goals, frustrations, workflows, and decision moments.”

This gives you a research baseline instantly.

Step 2: Interview Script Generation

Input your research goal.
AI gives you structured interview questions, including probes and follow-ups.

You refine:
AI drafts → You sharpen.

Step 3: Synthetic Interviews (Hypothesis Shaping)

You interview AI as if it's a persona representing common user patterns.
This is not “real research.”
This is early discovery to uncover blind spots, assumptions, and directional insights.

It prepares you for real users.

Step 4: Real User Interviews

Now you focus human effort where it matters:

• emotional cues

• motivations

• frustrations

• contextual details

AI transcribes and analyses these sessions immediately - no manual note-taking, no late-night synthesis.

Step 5: AI-Assisted Insight Synthesis

AI handles the heavy lifting:

• clustering themes

• generating patterns

• identifying behavioural dynamics

• suggesting opportunity areas

• creating insight briefs

You filter.
You validate.
You interpret.

This is where human judgment elevates the machine output.

A Realistic Example: The 4-Day Research Sprint

Imagine you're the only designer in a B2B team and the PM needs insight for an SME portal redesign — in four days.

Before AI 🥲
Impossible.

With AI 😄

• Day 1: Domain absorption + interview script

• Day 2: Synthetic interviews + hypothesis map

• Day 3: 3 real user interviews

• Day 4: AI synthesis + opportunity recommendations

You deliver a research-backed direction that looks like a 3-week effort.

This is the new pace of research.

The Modern AI Research Stack

A simple, practical stack any designer can start with:

• ChatGPT — domain learning, scripts, synthesis

• Perplexity — competitive + market intelligence

• Dovetail AI — instant transcript analysis

• Useberry AI — fast remote usability

• Figma AI — rapid concept exploration

• Notion AI — organising insights and field notes

You don’t need a big stack.
You need the right stack.

The Designer’s New Skill: AI-Orchestrated Research

AI turns designers into research orchestrators — not just executors.

Your value becomes:

• asking sharper questions

• guiding machine reasoning

• validating AI-generated insights

• distinguishing patterns from noise

• contextualising findings for the business

The designer isn’t disappearing.
The designer is evolving.

Final Thought: AI Removes the Excuse for Not Doing Research

Research still depends on real users, real environments, real stories.

But AI eliminates the blockers that used to slow teams down:

• no time

• no budget

• no researcher

• no bandwidth

AI doesn’t replace research.
It democratises it.

Every designer now has a research partner — one that works fast, works consistently, and keeps the work grounded in evidence.

And that changes everything.

Bonus: AI Research Partner Checklist

I provide Notion, Figma and PDF checklists for you to kickstart your AI-driven research. Click below to download:

• Download AI Research Partner Checklist

This checklist will guide you step-by-step through the 10-stage AI-powered workflow, from Define Research Objective to Final Deliverables, so you can start implementing these AI-driven research methods in your projects right away.

👉 And if you haven’t yet, subscribe here to get my free UX prompt guide for designing with AI - it’s the easiest way to keep exploring with me.