❌

Normal view

There are new articles available, click to refresh the page.
Today — 18 November 2026Smashing Magazine

Meet AI 2027 Conference (Dec 1)

AI is changing how we design and build, and it isn’t slowing down. On December 1, 2026, SmashingConf is hosting the AI 2027 Conference, a live online half day event to take stock of where AI stands today, what we can expect in 2027, and where teams are getting it right.

With AI maturing, it’s clear we need to learn how AI can elevate your workflow as a UX designer and Design System engineer. Most of us are still figuring it out and trying to work smarter in this new world, so we invited industry experts who have been doing this for a while. They show their experience and tell you what works and what doesn't, so you don’t have to figure it all out yourself.

Every session is practical. Speakers show how they actually work: their tools, their setups, and the small things that are easy to miss. The event ends with moderated breakout rooms, where you can bring your own workflow questions. See you there?

About AI 2027 Conf And Schedule

This conference is dedicated to designers and engineers (front-end, UI, UX) who want to understand how AI can improve the way their team works, without the hype. If you’re interested in AI-ready design systems, AI and Figma, harness engineering, agentic AI UX patterns, and AI workflows for design and engineering teams, this conference is right up your alley!

Showing, not telling: All sessions will be highly practical, focusing on how to integrate AI in your daily work and what to expect in 2027.

07:45 AM — Doors Open
8:00 AM — Welcome!
+

For our AI 2027 Conference, your friendly host Vitaly will welcome you and quickly explain how the event will run. We can’t wait to meet you!

8:10 AM — Designing AI Experiences in 2027
+

AI is moving fast. With it come new workflows in product teams, new design patterns, new user expectations and new ways of thinking about building and designing for AI.

Let’s look at where things stand today. A lot changed in 2026, and there are things we can now design and build that simply weren’t possible a year ago. We’ll cover the patterns taking shape heading into 2027, from multi-modal experiences to accessibility, and what tends to go wrong along the way. A big part of that is designing for trust, so people feel confident using what we make.

What makes AI products reliable in practice? We’ll look at how teams cut down on hallucinations with better context, a well-built harness and sensible guardrails. Then we’ll finish with what’s coming in 2027, including new experiments, regulations and a few takeaways to bring back to your team.

Roll up your sleeves for a packed session, full of real-life examples and design patterns.

8:45 AM — Prototyping AI Functionality
+

Great AI-powered products live at the intersection of engineering depth, design craft and product thinking. In this talk, Anna Arteeva shows how to build real, working AI experiences, not just one-shot prototypes that fall apart the moment someone uses them.

You’ll learn how to design and prototype an AI-powered experience from scratch, with functionality built on LLMs, voice and image generation logic. Anna will also show how to add that little bit of delight to your app, and how it can respond to different types of input, whatever the person on the other side of the screen gives you: text, voice or images.

9:20 AM — Nobody Will Read Your Documentation
+

What coding agents need from your design system docs, and how to write it.

Documentation is the part of the design system teams are least happy with, and it’s been that way for years. Luke Murphy looks at how we ended up with docs nobody reads and why agents change the picture. Then, drawing on DS ARC’s tests of real design systems, he walks through the small writing changes that make docs work for agents and people alike.

This is a talk from our friends at zeroheight. Thank you for joining in!

9:40 AM — Design Systems and Figma MCPs
+

The big question for many teams is how to get your code and your Figma file talking to each other. In this session, Christine Vallaure shares how she has set this up in practice: going from code to Figma instead of the other way around, moving back and forth between the two for the best result, and what that means for how we work.

You’ll hear why design system basics suddenly matter a lot more, why naming things well pays off, and why AI builders so often produce code that looks like your design system but still has to be rebuilt. She’ll also explain the engineering side that designers don’t always see, like the checks and files your developers set up, so you know how it works and what to ask for. Along the way, she covers the problems you’re likely to run into, what to keep in mind, and where Storybook fits in.

Expect plenty of small tips and tricks you can take straight back to your team.

10:15 AM — Alternative Workflows for AI and Design Systems
+

AI flipped the script on the traditional, linear design system workflow. That’s okay. We’re all experimenting, and nobody has this figured out yet.

TJ Pitre has spent the past two years working with dozens of teams to find the flow that fits them. He’ll show three alternative workflows live. Which one fits depends on you: how big your design system is, how big your team is, how much effort you’re willing to put in, and how well it needs to scale.

The goal is to get you thinking, and to send you back to your team with a few workflows worth trying.

10:50 AM — Real-World AI & Design Systems Workflow
+

Brad Frost shares his actual workflow for building products with AI and a design system. He’ll show the setup, architecture, and tools he uses to keep AI on the rails of his components, tokens, and patterns.

Expect live building, real design decisions, and plenty of practical tricks along the way. You’ll see how it all works together and leave with ideas to apply to your own design system and workflow.

🔌 Breakout Session 1
+

Designing & Building AI Experiences in 2027

The way we design and build is changing massively, and we are all adapting to the new reality. In this session, we’ll talk about how to design and build AI experiences that actually work, and are a delight to use. Bring your questions, post your problems and work with Vitaly and Anna, and all the other attendees, to solve them together. We’ll look at everything from interaction patterns and prototypes to adding those little touches of delight, and have some fun while doing it!

Have a specific UX AI problem? Ask it in the Google doc, and get your question answered!

🔌 Breakout Session 2
+

Design Systems & AI in 2027

Let’s be honest: work is messy. But let’s see how we can make it work, and have some fun while doing it! Ask all your questions, post your problems and work with Christine, Brad & TJ, and all the other attendees, to solve them together.

Have a specific design system headache? Bring your questions, and let’s discuss!

Goodbye!
+

We will be emailing you with the video recordings, the slides, the collaborative docs, the takeaways and more. Everything in one place, so you can rewatch the talks you loved and catch the ones you missed.

We’ll open the doors 15 minutes early! Make sure to check your timezone 🌍 so you make it on time. We look forward to seeing you there!

  • 🌁 8:00 AM — San Francisco
  • 🍁 11:00 AM — Toronto
  • 🗼 5:00 PM — Paris
  • 🐪 8:00 PM — Abu Dhabi
  • 🐉 12:00 AM (+1) — Beijing
About The Speakers

On December 1, 2026, you’ll get to learn from and share your UX AI problems and design system headaches with six experts: they’re all very excited to share their personal practical tips, clever tricks and valuable insights that you can put into action right away. Expect plenty of inspiration, useful takeaways, and, of course, a little fun along the way!

Vitaly Friedman

Vitaly Friedman loves beautiful content and doesn’t like to give in easily. When he is not writing or speaking at a conference, he’s most probably running front-end/UX workshops and webinars. He loves solving complex UX, front-end and performance problems.

I’ve been running my AI design patterns workshop for a while now — and everywhere I look, it’s the same story: people don’t want more AI hype, they want to actually get better at using it. That’s exactly why we decided to organise this event.

— Vitaly, your friendly host of this event.

Anna Arteeva

Anna Arteeva is a product design leader turned agentic coding instructor, and one of Maven’s top-ranked educators, formerly head of product design at Payoneer. With a technical background (frontend), a career in product design, and a healthy obsession with building things. She found her calling in helping designers unlock their superpowers with coding agents, helping designers move beyond AI hype and one-shot prototypes, and develop the technical fluency, practical skills, and good judgement to make agentic coding a powerful part of professional design practice.

Christine Vallaure

Christine Vallaure is a designer and educator with twenty years in product work. She is the founder of Moonlearning.io, a learning platform that helps designers blur the line between design and code, and the author of The Solo. Christine spends most of her time in the developers’ weeds and brings back what designers actually need, then turns it into far too detailed articles, hands-on teaching and talks at conferences around the world.

TJ Pitre

TJ Pitre is the Product Architect for AI and Design Systems at Figma, and Founder/Owner of Southleft, a design systems consultancy. He works with teams to bridge design and engineering using structured context, modern tooling, and practical experimentation.

Brad Frost

Brad Frost is a design system consultant, web designer & developer, speaker, writer, teacher, musician, and artist located in beautiful Pittsburgh, PA. He helps people establish & evolve design systems, establish more collaborative workflows, and design & build software together. Brad is the author of the book Atomic Design, which introduces a methodology to create and maintain effective design systems. He co-hosted the Style Guides Podcast and has helped create several tools and resources for web designers, e.g. an online course, AI & Design Systems, with experts from the industry.

Our Friends From zeroheight Are Joining Us!

We’re excited to have our friends at zeroheight on board. The folks at zeroheight have created a platform for creating, managing and publishing design system documentation. Designers and developers get to work in the same place, so docs are more than a handoff. Find out more at zeroheight.com.

Join zeroheight’s Principal Design Advocate Luke Murphy for a partner talk on why nobody reads your design system documentation, and what coding agents need from your docs. (Thank you for joining in, dear Luke!)

“Smashing Conference has always been one of my favourite events, so I’m really excited to be wrapping up all the findings I’ve discovered over the last six months and bringing them to the audience!”

— Luke Murphy, Principle Design Advocate at zeroheight

More Upcoming Smashing Workshops And Events

AI Conf 2027: See You There?

AI Sped Up The Build: How Can Accessibility Testing Keep Up?

This article is a sponsored by Level Access

Lately, I’ve been thinking and writing a lot about what AI is doing to product development, and what that means for accessibility. The thing that has my wheels turning is a finding from Level Access’s 2026 State of Digital Accessibility Report. Basically: AI is helping us hit fast-forward on the build, but testing practices haven’t kept up.

We asked more than 2,500 professionals where they noticed AI was speeding up their work in the SDLC. Most said they noticed gains in planning (58%), design (61%), and development (51%). But QA and testing lagged behind: Only 30% said AI had sped up that stage.

These results point to a two-speed workflow. AI has turbocharged design, planning, and development, while checking and validation are still running at a very different pace. This means a lot of teams are likely racing through the build, then being forced to hit the brakes the moment someone has to answer a pretty fundamental question: Is this thing actually accessible?

Accessibility has historically been treated as a QA bottleneck, and AI is pushing far more work into it, faster. If your team has already shifted left on accessibility, you’re off to a good start. But AI has reshuffled the workflow, so even proactive teams need to work out where those early checks belong now.

This matters because right now, the web is moving in the wrong direction. WebAIM’s latest scan of the top million home pages found that automatically detected errors per home page rose 10.1% in a year, from 51 to 56.1 per page. WebAIM cited AI-assisted coding as one possible contributing factor.

So how do we get validation out of first gear? How do we build human judgment into the workflow as AI keeps pushing the pace?

AI Isn’t The Biggest Differentiator

We looked at the organizations that are improving across every accessibility metric they track (a group we call the “improvers”) to find out what they’re doing differently.

Here’s what stood out: AI adoption made the smallest difference of anything we measured. Improvers use AI at a similar rate to everyone else we surveyed. Their edge shows up in the maturity of their surrounding accessibility practices — things like training, communication, and a culture of accessibility.

A quick caveat: This is survey data, so it only shows correlation, and mature programs may simply be better at tracking and reporting their wins. Even so, this finding was hard to ignore.

And it got even more interesting. Professionals in mature accessibility programs were nearly six times as likely to say AI helps them prioritize issues. They were also nearly three times as likely to say it helps them tackle accessibility more proactively in development.

In other words, AI works best as an amplifier of a strong program. With context, testing, environments, and guardrails in place, agents can take on a large share of the work from drafting through to operations, and much of the time lost to waiting and handoffs goes away. People stay responsible for deciding what to build and for approving what ships.

So let me ask you: When it comes to accessibility, where does human judgment sit in your workflow today?

Not sure? Here’s a quick way to find out.

Pick a feature you shipped recently and trace it from the first Figma frame to production. Mark every moment a person decided whether it would work for someone using a keyboard, a screen reader, or their browser at 400% zoom.

How many marks did you get? If most of them cluster at the end of creation, you’re likely heading to one of two places: You’ll either ship accessibility barriers or spend the time you saved upstream fixing them later, when they’re harder and costlier to fix.

Here’s how to avoid both outcomes by building the right accessibility checks and judgment calls into the work your team is already doing.

Build The Judgment Calls Into Your Workflow

As AI takes on more work, people need to stay involved at three points: finding issues, fixing them, and documenting the evidence. Each one plugs into a step your team already takes, like a handoff, a pull request, or a review, so nothing new gets added to the timeline, and accessibility keeps pace with the work that’s in motion.

1. Find: Catch Issues While The Work Is Still Warm

Context fades fast. Put the first judgment checkpoints as close to the creation work as you can:

  • Start at the handoff.
    Spell out focus order, accessible names, states, heading structure, and what gets announced when something changes or goes wrong. If you leave anything vague, the model fills the gap with its own defaults. Then, put it where the model reads it: your design system components, rules files (Cursor rules, AGENTS.md, Copilot instructions), and prompt templates, not only a spec document. For designers, free annotation kits make this concrete. GitHub’s Annotation Toolkit offers Figma components for marking headings, landmarks, focus order, and keyboard behaviour on the canvas, so the intent travels with the file instead of living in someone’s head.
  • Gate the pull request.
    Run checks in your CI/CD pipeline and at the pull request. Let them block or warn on a merge. Compare against a baseline so you only review changes. (This is the automated half of the gate: The human half of this same checkpoint shows up again under Fix). Most teams already have the tooling in place for this, but what is new is volume. AI-assisted pull requests arrive faster than reviewers can read them, so the automated gate matters more, not less. In React projects, eslint-plugin-jsx-a11y flags issues before commit, while Pa11y and Lighthouse CI scan builds for new errors. Level CI also brings accessibility testing into the CI/CD workflow, including pre-merge detection, delta findings, quality gates, and fix recommendations in pull requests.
  • Let automation do the sweep, send the judgment calls to people.
    Run automated checks across pages, screens, and documents for broad, repeatable coverage. For the sweep, QualWeb, for example, checks pages against the W3C’s ACT rules. Running your tests across several engines, like axe-core and Equal Access, can be a good idea, as one may help you catch things that the other misses. But, have people assess usability: A dropdown can pass automated checks while its submenu remains inaccessible to keyboard users.
  • Give every check an owner.
    For example, designers specify focus, errors, and states. Developers run a keyboard pass and a screen reader smoke test on custom components. (Note: Screen reader testing is harder in practice than it may seem at first, so your team might need an introductory training). UX or QA navigates the full journey. Put accessibility metrics in acceptance criteria and the definition of done, and back it with component-level tests because “everyone owns it” has a funny way of turning into “nobody did it.” When teams decide, in advance, who is responsible for each check, they create the clarity and communication that our data shows sets the organizations improving accessibility apart from those stuck fighting ever-growing backlogs.

2. Fix: Act Before The Context Goes Cold

Found the issue? Great. Fix it while it’s fresh. When issues end up as tickets, make sure the context travels with them. They should carry the element, the repro, the related WCAG criterion, a suggested fix, and the PR link, so context doesn’t leak.

  • Move the guidance to the work.
    Whether the fix happens in the editor, the design file, or the component library, the answers should be right there. If your team uses an AI coding assistant, an MCP server can pull accessibility findings and fix guidance straight into it so developers can work through issues without leaving their editor. Level Access offers one that connects to tools like Cursor and Claude.
  • Let AI take the first pass.
    Use AI to draft, with guardrails. AI coding assistants can propose changes quickly, but they optimize for a passing check, not a correct experience. Give them grounded fix guidance for the specific issue, and treat their output as a draft. Open-source skill sets can help ground that guidance. A good starting point is the accessibility instructions file in the Awesome Copilot collection, which steers Copilot toward accessible patterns. Once you’ve got your draft, re-run the check, then review the semantics and test the behaviour because a green result can come from markup that looks right and isn’t (e.g., role="button" on a div, redundant ARIA, invented alt text). The speed is useful only if verification keeps pace.
  • Review before anything merges.
    Test the change in context. Did it solve the original problem without breaking anything else? Does the interaction now behave and announce itself as intended? Note: This gate is doing different work than the per-check testing upstream in “Find”: That caught the issue; this work confirms the fix actually holds in context.
  • Work the backlog by impact.
    Pulling older findings? Start with things that block someone from completing a key journey, like paying a bill or resetting a password. Then tackle the quickest fixes first. Include the component, what went wrong, and the guidance to fix it. Don’t expect someone to reconstruct the story.

3. Prove: Leave A Receipt

The worst time to start gathering evidence is when somebody’s asking for it.

Every check, fix, and judgment call throughout the process described above should ideally leave a trail. A fix isn’t done until something fails if the issue comes back. Ask your AI assistant to write the regression test with the fix and put the finding link and any judgment call in the PR description. That’s the receipt.

A passing test shows a known issue hasn’t returned. It doesn’t show the experience works. For what automation can’t cover, add a short note to the PR: what you tested, with which assistive technology, and any judgment calls you made.

  • Let tooling do the admin.
    When someone later asks what was tested and who approved it, tooling can assemble the answer from those PRs and tests. We cut VPAT/ACR authoring time by more than 70% this way with the Level Access Reporting Agent, but only because the evidence already existed. Again, the tool compounds a practice. It doesn’t replace one.
Keep The Speed: Move The Judgment With It

AI has given digital creation a speed boost, but broadly speaking, validating the work hasn’t kept pace. Closing that gap isn’t about adopting more AI in more places or abandoning the toolset that helped make your team faster.

According to our data, the opportunity in front of teams is to build the practice around that toolset, so that human judgment is flagged, embedded, and acted on earlier, and more often.

We’ve only scratched the surface of what our data tells us about AI and accessibility. If you’re curious about what else we found, check out the 2026 State of Digital Accessibility Report. There’s plenty more to unpack.

Before yesterdaySmashing Magazine

Should You Actually Add AI To That? A Four-Question Audit For Product Teams

A product team at a large health insurer wants to add AI that writes the full written determination for benefits appeals specialists. The technology works as specified. However, the specialists stop using it, and the ones who keep using it take longer on each case than the ones who ignore it.

A short evaluation with the specialists surfaces the problem fast: reading an AI-written determination carefully enough to sign it takes about as long as writing one, and the specialist also has to check for mistakes they would never have made themselves. The feature adds work to a task these people had already mastered.

Rescoping the release fixes it. A second version surfaces the policy provisions and prior decisions relevant to each appeal and leaves the writing to the specialist. The search step disappears, review time drops, and the part of the job the specialist is good at stays where it was.

The technology is identical in both versions, and the difference is which part of the task the AI handles.

Finding The Break-even Line

Every interface change costs the user something before it pays anything back. They have to rebuild their picture of how the tool works, learn where things are now, and decide how far to trust what the AI hands them. Nelson Cowan’s review of working memory research (2001) put the limit at about four items held in mind at once. All three of those jobs draw on the same small supply.

An AI feature in an enterprise software setting requires more from the user than a redesigned menu, because it changes what they do all day. Hand the synthesis to an AI and the user becomes a checker. Give it the recommendation too, and the job shrinks to signing off. Either change costs user attention, and for people whose training is their standing at work, either one can feel like a demotion. For example, in one study, Sophia Ackerhans (2025) and colleagues found that physicians asked to sign AI-assisted decisions reported a more serious threat to their professional identity, and explanations of the AI’s reasoning raised both trust and that threat together.

An AI feature earns its place when what it returns beats what it costs the user to adjust, for one user doing one task.

We can call that the break-even line. Returns to users come in three forms:

  • Effort the feature removes,
  • Errors it catches that the person would have missed, and
  • Consistency across people doing the same work.

For example, an AI-powered fraud screening tool shows the errors-caught form at work, since the analyst reviews flags they would never have raised themselves, which costs attention, and the catch rate pays for it. That puts the feature above the break-even line.

Four questions can help your team locate the break-even line before design work starts. Each one produces a design condition the brief can act on.

These questions do not replace the build decision. Funding, strategy, and existing commitments all weigh on that, and four questions cannot see any of it.

Run through all four questions together, since no single question settles the issue alone. Do it while the feature is still a proposal, before anyone sinks weeks into design. You will also need at least one person who does the task for a living, such as a loan officer, analyst, or benefits specialist. They do not have to sit in the roadmap meeting, and a short conversation tells you where the mental effort actually sits and whether the feature would help or add work.

Question 1: Does This Reduce The Total Effort The Task Takes For This User?

Count everything the task asks of the user: the thinking, the clicking, and the checking they will owe once AI is involved. Fewer clicks proves nothing on its own, because a feature can cut clicks and still leave the person working harder. Write down the cost even when it goes up, since Question 2 may find a return that pays for it.

A loan officer reading 40 financial disclosures to find the three that conflict with lending policy is thinking hard, and AI that surfaces those conflicts cuts that demand directly. Compare that with typing a loan number into a tracking system, which costs a few seconds and almost no thought. Pre-filling that field relocates the cost instead of removing it, because the officer now checks what the machine entered. Conventional wisdom says to automate the repetitive and monotonous tasks, and the pre-filled field is where that advice misfires. In this example:

  • When AI fills in a field, the user takes on checking it.
  • The original task requires a short keystroke sequence and no sustained attention.
  • The automation trades a low-effort action for a high-attention one.

You can find the tasks worth automating by comparing total effort before and after. Count the checking the user inherits on the after side.

Who the user is matters as much as what the task is. One feature can clear the line for a junior analyst and fall short for a senior one. Hand a junior analyst an AI-drafted risk summary, and they gain a starting point they lack the pattern library to produce on their own. A senior analyst, however, reads that same summary against the analysis already formed in their head, spends four minutes doing it, and learns nothing.

A finding like that tells you who to ship to. Scope the addition to the group it serves.

Design condition: Name the user segment the addition serves, and design an exit for the other segments.

Question 2: Does This Beat The Way The User Does The Task Now?

Compare the AI approach against the user’s current method, including the spreadsheets and workarounds they built for themselves. Genuine ambiguity is one reason AI comes out ahead when someone explores options, produces a starting point, or looks for patterns too numerous to spot by hand. Scale, speed, and consistency across a group of people doing the same job are three more. A fourth is catching what the current method reliably misses, which is how the fraud screening tool earns its place. The advantage disappears once the user has a practiced route to a known answer.

For example, an HR team building a succession planning tool finds the answer running both ways inside one product. Using AI to surface internal candidates whose skill combinations nobody would think to search for wins on ambiguity and scale together, since no single right answer exists and manual review of that search space would take weeks. Drafting the notification email after someone picks a candidate loses to the method already in place. The format is familiar, the writing takes two minutes, and the person sending it holds firm opinions about tone. The candidate search earns the addition. The email draft layers an interaction onto a task that runs fine without one.

The nature of the input and the shape of the output are separate decisions. A task can hold genuine ambiguity and still call for a structured visual result instead of a conversational one. Pair this audit with a modality evaluation for the output side.

Design condition: Remove AI from any step where the user’s current method already reaches the answer quickly and reliably.

Question 3: Can The User Catch The Errors?

Every AI system makes mistakes. The question is whether your user will notice. Start with how visible the error is. Then weigh what it costs when nobody catches it, and whether the user still has the skill to catch it. Question 1 asks what checking costs. This one asks whether checking is even possible.

Error visibility varies enormously, and product teams tend to estimate it badly. For example, an AI trip planner that suggests a museum on the day it closes produces an invisible error, because nothing in the output looks wrong. The traveler finds out while standing outside a locked door in Tokyo. Compare that with a suggested flight that departs before the connecting flight lands, where the contradiction sits right there on the screen.

Automation bias makes the invisible cases worse. Raja Parasuraman and Dietrich Manzey (2010) reviewed decades of human factors research showing that people defer to automated output even when that output is wrong, across aviation, medicine, and process control. Trust climbs fast, and rarely as a conscious decision. Once it does, users stop applying the scrutiny that would catch the mistake.

Map the error surface, meaning the ways this feature can be wrong, before design work starts. List the three likeliest error types. Rate each one on visibility to the user and consequence if it slips through. Any combination of low visibility and high consequence becomes a design requirement.

Show users where the output came from and how the system produced it. That is provenance, and it is what lets trust settle at the right level. People who can see the source, the data behind it, and when it was pulled catch errors more often. Tell the traveler that a restaurant’s hours came from a page cached in March and they know what to check. A confident-sounding paragraph with no source attached leaves them guessing.

Design condition: Any addition with a high-consequence, low-visibility error surface ships with provenance display and verification prompts, or it does not ship.

Question 4: After A Year Of Using This, Can The User Still Tell When The AI Is Wrong?

Letting the routine work go is a real benefit of adding AI. Nobody needs to protect a specialist’s ability to format a citation or an analyst’s ability to total a column by hand, and arguing to preserve skills the technology has absorbed wastes everyone’s time.

Still, the judgment that catches the machine’s mistakes stays exempt from replacement. That judgment makes every other delegation safe, and disuse degrades it like any other skill.

Research in radiology shows how fast a suggestion can override a reader’s own judgment. In a 2023 experiment, Thomas Dratsch and colleagues had 27 radiologists read mammograms alongside what they were told was an AI system (a simulation created solely for the experiment). The radiologists worked through a 10-image training set where the suggested category was always correct, then 40 more mammograms with incorrect suggestions planted in 12 of them. The result showed how incorrect AI suggestions damaged diagnostic accuracy at every experience level. The most experienced readers, averaging 15 years, assigned the correct category 82.3% of the time when the suggestion was right and 45.5% of the time when it was wrong, while the least experienced group fell from 79.7% to 19.8%. Experience softened the effect without preventing it. A year of deferring to the same system, with the judgment it replaced sitting unused, leaves a reader in a weaker position than the one these radiologists started from.

Question 3 looks at your user today. Extend the same test 12 months forward and you arrive at Question 4. Teams that answer the first and skip the second read the resulting failures as a quality problem in the model, when the cause is the human judgment they took out of daily use.

Ask whether this user could judge the quality of the output 12 months from now if the feature vanished tomorrow. When the answer is no, the design needs a mechanism that keeps verification skill in use. Periodic blind review works well and costs little, with the user forming a judgment before seeing what the AI produced. Rotating a share of cases off AI assistance does a similar job, as does a weekly comparison between machine output and a human-produced version.

Design condition: Name the mechanism that keeps verification skill in use, and build it into the workflow itself. A slide in the training deck will not do it.
A decision Matrix

Table 1 below gathers the four questions, the signals pointing each way, and the condition each one produces.

Audit question AI earns its place when… AI costs the user when… Design condition
Does this reduce the total effort the task takes for this user? The task demands synthesis across large or varied inputs, and judgment calls create the bottleneck The task follows a known procedure with a fast manual path, or verification costs as much as the original work Name the segment served, and give other segments an exit
Does this beat the way the user does the task now? The AI approach wins on ambiguity, scale, speed, consistency, or catch rate against the method the user has now The user’s current method already reaches the answer quickly and reliably Remove AI from steps the current method already handles well
Can the user catch the errors? Errors appear on their face, stakes stay low, correction is cheap Errors stay subtle, stakes run high, or verification needs the skill being delegated Provenance display and verification prompts, or no build
After a year, can the user still tell when the AI is wrong? AI absorbs volume while the user keeps making the judgment calls AI absorbs the judgment calls with no feedback on quality A named mechanism that keeps verification skill in use

Table 1: The AI Addition Decision Matrix. Clear answers across all four questions point toward building the feature as proposed. A poor answer on Question 1 calls for a design condition or a change in scope, unless Question 2 finds a return that covers the cost. Questions 2 and 4 work the same way without that exception. A poor answer on Question 3 can stop the build.

Put the conditions in the design brief, where they become project requirements. Teams reduce AI features to yes or no because roadmap reviews demand it, and that throws away everything the audit found. A feature that answers well on Questions 1 and 2 and poorly on Question 3 proceeds only with provenance built in. Write that in on day one. Requirements that arrive at the end read as polish, and teams cut polish when timelines slip.

Running The Audit On The Appeals Scenario

Let’s return to the insurer scenario from our opening. The first version of the tool fails Question 1. Writing a determination takes sustained thought, and the AI that produces the draft moves that effort into verification without reducing the total. An hour with the four questions would surface that before the first version reaches design.

Question 2 points in the same direction. Appeals determinations follow a familiar structure, and specialists reach the answer through a practiced route. The ambiguity in the task sits earlier, in finding which provisions and prior decisions apply.

Question 3 raises the stakes. A wrong determination affects someone’s medical coverage, and an error buried in fluent prose stays invisible until the next appeal arrives. That answer produces the provenance requirement in the second version, which cites the source document and retrieval date for every provision it surfaces.

Question 4 explains why the second version holds up. Specialists still write every determination, so the judgment that evaluates the retrieved material stays in daily use. Keeping version one would train specialists for a year to approve text they no longer have the practice to assess.

The Same Audit On Meeting Summaries

AI-generated meeting summaries sit inside products that millions of people open every day, and the audit reaches a different answer for them.

On Question 1, a summary removes the work of writing notes and adds the work of checking whether it attributed a decision to the right person. Total effort drops for the participant who never took notes. For the person who always took the notes and circulated them, the trade is closer, and the verification lands on them. That split is exactly what Question 1 is built to surface.

Question 2 compares the summary against someone typing while half-listening, which produces patchy notes. A summary beats that on completeness and on consistency from meeting to meeting, so the feature clears this question for most teams.

A summary that assigns a commitment to the wrong person looks exactly like a correct one, and nobody rereads the transcript to check. On Question 3, low visibility and real consequence together turn into a requirement for a linked source timestamp behind every action item.

The feature clears Question 4, and the design needs no mechanism. Nobody loses a skill worth protecting by giving up meeting notes, and the participants keep making every decision the summary records.

Two clear answers, one segment finding, and one condition. The timestamps ship with the feature, and the habitual note-taker is the segment the team checks after launch.

The 60-minute Version Of The Audit

You can run this before the next AI feature reaches your roadmap.

  • State the task specifically (10 minutes). Write it at the level of one user in one sitting. For example, help a mid-level financial analyst find the three highest-risk items in a 40-page due diligence report inside a two-hour review window. A task described as helping users summarize documents is too loose to evaluate.
  • Answer the questions with someone who does the work (25 minutes). Their read on where the effort actually sits beats any product team estimate. Ask which parts of the task they find hard, listen for whether the proposed feature touches those parts, and ask what they would lose the ability to check if the feature made the judgment calls for a year.
  • Map the error surface (15 minutes). Identify the three likeliest error types, each rated on visibility and consequence. Low visibility plus high consequence becomes a build requirement. For instance, a medical diagnostic tool suggesting a treatment plan with a high mortality rate if incorrect requires strict provenance and verification triggers, while a scheduling assistant proposing the wrong meeting time is easier to spot and repair.
  • Write the conditions into the brief (10 minutes). Provenance display, verification prompts, segment scoping, and skill mechanisms belong in the brief that goes to design, in the same document as the feature description.

Everett Rogers (2003) called this pro-innovation bias, the assumption that new capability means progress before anyone verifies the benefit, and competitive pressure turns a rival’s announcement into an internal mandate. An hour of structured questions gives your team a way to answer that pressure.

Bringing The Results Into The Room

Audit results land badly when a designer presents them as reasons the feature should not exist. The conditions are the useful output, so bring those into the product review.

Start by naming the segment the feature serves, which makes the answer a yes for someone. Hand over the error surface as a requirement with a cost attached. A product manager can act on a request for timestamps behind every attributed decision, and nobody can act on a worry that users might not trust the output. Then offer the change in scope without waiting to be asked. A version that surfaces the provisions instead of writing the determination is a smaller build with a better adoption story, and that framing moves a roadmap conversation forward.

A sentence that works out loud: We think this clears the bar for junior analysts and adds a verification step for senior analysts, so we would scope it to onboarding and revisit the rest next quarter.

The attention a person can spend in a working day stays fixed no matter how good your model gets. Before the next feature reaches design, write down what it will cost the person doing the work and which of the three returns pays for it. With both answers in hand, your team can walk into the roadmap review with a scope to propose.

References

A New Community For In-House UX People

You might have already read my name every now and then here at Smashing Magazine. I’m Paul Boag. I’ve written three books with Smashing and 77 articles (yes, I counted), and I sit on Smashing’s advisory board.

So when Vitaly and the Smashing team offered me this slot in your inbox, I didn’t take it lightly. I want to tell you about something I’m launching in January with Smashing as my partner, and why I think it matters right now.

The Bit Of The Job Nobody Talks About

Every year I talk to hundreds of people working in digital. Some work in-house, some run agencies, and some freelance. And the same thing comes up again and again. The hardest part of the job usually isn’t the design work. It’s everything around it.

The stakeholder who redesigns things in the review meeting. The business case sitting in someone’s inbox. The project that has been “about to start” since last spring. And now, the senior manager who has read that AI can do user research in an afternoon.

What makes it harder is that a lot of us deal with all this on our own. Many are a team of one, or a team of a few.

Their colleagues are great, but they work in the same organization with the same blind spots. Nobody down the corridor has dealt with this before.

What’s missing is an outside view. Someone who has dealt with the same awful stakeholder and can tell you how they handled it.

Most of us rarely get that conversation, and the job is changing faster than ever. There’s very little established best practice for working with AI yet. Everyone is figuring it out at once, mostly alone.

So I’m Starting UX Insiders

UX Insiders is a small, paid community for people doing UX inside organizations. Designers, researchers, UX leads, and anyone championing UX where they work, whatever their job title.

UX Insiders

$ 65/mo Join in-house UX community

For in-house UX teams. Founder rate for as long as you stay. Launches Jan 5, 2027.

Agency Academy

$ 65/mo$ 105/mo Join Agency community

For freelancers and agency owners. With the Smashing price until the end of November.

Here’s what you get:

  • 📞 Weekly call every Tuesday from 3:30 to 4:30pm UK time (10:30am ET, 7:30am PT). Bring a problem, a question, or a win.
  • 💬 Private Slack for the questions that can’t wait until Tuesday, and a second opinion on that email before you send it.
  • 🎥 Every call recorded with a summary, so you can catch up when a meeting gets in the way.
  • 📚 A shared library of the business cases, templates, and research plans that have actually worked for other members.

I run every call myself, and I’m in Slack most days.

But the best advice usually comes from other members. I’ve seen that first-hand running Agency Academy, my community for agency owners, every week since July 2024.

It’s For In-House People Only

That’s deliberate. It means people can talk openly about their organization without wondering who’s listening. And it keeps out agencies and freelancers who’d join just to sell you their services.

So you apply first. It takes about a minute, and I only check that you work in-house. If you do, the answer is almost always yes.

Founder Pricing And How The Launch Works

The first 25 members get founder pricing: £49 a month billed annually (£588 a year) + VAT, or £59 a month + VAT paid monthly. You keep that rate for as long as you stay.

Your employer can pay by invoice too, so it can often come out of a training budget.

Nobody is charged until we launch on Tue, 5 January 2027. If fewer than 15 people have joined by Friday 11 December, it doesn’t go ahead and nobody pays a penny. Apply for a founder spot →

Run An Agency Or Freelance?

UX Insiders is just for in-house people. But if you run an agency or freelance, Agency Academy works the same way: a weekly call every Thursday and a Slack full of people who get it. Members even pass work to each other.

Until the end of November, Smashing readers can join for £59 a month + VAT, or £49 a month + VAT billed annually (£588 a year). That’s down from £79 a month, and you keep that rate for as long as you stay.

UX Insiders

$ 65/mo Join in-house UX community

For in-house UX teams. Founder rate for as long as you stay. Launches Jan 5, 2027.

Agency Academy

$ 65/mo$ 105/mo Join Agency community

For freelancers and agency owners. With the Smashing price until the end of November.

Whichever fits, I’d love to see you there. And if you have questions first, just email me at paul@boagworld.com. I read and respond to every one.

Making Immersive LLM Chat Experiences More Accessible

I have had the privilege of helping to improve the accessibility of multiple immersive LLM chat experiences in the course of my career. Now I want to share this knowledge with you.

Accessibility is a core part of a functional digital experience. As the LLM chat pattern continues to spread like wildfire across the web, we risk excluding people if these experiences are not built with accessibility as a core consideration.

It is also worth re-mentioning what “exclusion” means here: It’s the loss of knowledge, the loss of opportunity, the loss of utility, the loss of employability, the loss of entertainment, and more.

What Is An Immersive LLM Chat Experience?

“Immersive LLM chat experience” is a catch-all term for full-screen experiences like Claude, ChatGPT, GitHub Copilot, Gemini, America.gov, Glean, and other similar websites and web apps:

The majority of what this post covers applies to both web apps and native apps. This is because these experiences are typically built using web technologies, then placed in a native wrapper via frameworks such as Electron or Tauri.

Immersive LLM chat experiences are not patterns such as a pop-up chat, inline text generation utilities, or summarization tools. These simpler applications of LLM technology will have different considerations and expectations. Instead, this is a starting point for making those other experiences accessible.

Reframing

There is nothing special about chat-based UIs when viewed via the lens of the Web Content Accessibility Guidelines. They are interactive experiences, built using web technologies. The losses I’ve described — and the legal liability associated with them — are access barriers in the same way any other web content can be an access barrier.

I would also like to mention the social model of disability here: the idea that exclusion can be created by the built environment. For example, consider an elevated entryway that uses a gently sloping ramp in place of stairs.

Built environments also extend to digital experiences, and the social model also applies here. The main activities undertaken to operate an LLM chat are already well-established:

  • Inputting text and submitting it, and
  • Reading content and taking action on it.

It is how we facilitate — or fail to facilitate — those interactions that’s the salient bit.

Visual Bias

Before we get into the technical aspects, we must consider the overwhelming visual bias that permeates software creation.

We live in a highly visual culture, so our outputs unconsciously reflect and reinforce that. What we need to do here is be aware of and think through the non-visual considerations.

While not all disabilities are blindness or low vision conditions, a lot of the core interactions of an LLM chat do need specific accommodations for these two types of disability.

Recall the social model of disability here, and how it applies to the main flow of using an LLM-based chat. You:

  1. Type some words into an input and send it as a message,
  2. Wait for the LLM to parse your message, then
  3. Read the message the LLM generated.

Let’s demonstrate at a high level what someone who can fully see the screen experiences compared to someone who uses a screen reader and cannot see the entire screen, or large portions of it:

(Large preview)

Visually, we can see the LLM reply appear. Someone who uses a screen reader does not know new content has appeared because:

  • Their focus is still on the input that sent the prompt.
  • No non-visual mechanism is present to signal new content showed up.

So, how do we create an experience for someone who uses a screen reader that is equivalent to the experience of someone who can fully see the screen? To start, we use live regions.

Use Live Region Announcements

Live region announcements will enable someone to know what the LLM has responded with without having to move focus from the input used for prompting. This is equivalent to someone who can see the screen, glancing upwards to read the LLM response when it appears.

First, read this excellent article by TetraLogical if this is your first attempt at getting live region announcements working. They’re tricky to get right, and this article sets the record straight.

One common pitfall I want to call specific attention to is applying aria-live on each LLM response message. Don’t do this. Instead, use a dedicated live region area to announce each message’s content.

The live region area should be placed at the end of the DOM and used for all live region messaging. This method is far more stable and reliable, which is important for ensuring everyone understands what the experience is communicating.

With that established: What we want to do is trigger a live region announcement when the LLM’s chat reply shows up in full on the screen.

(Large preview)

This creates an outcome where you can read the message if you can see the screen, and hear or feel the message if you cannot.

Usability Considerations

There are a few things to do when creating a good user experience for the people who rely on these live region announcements. These considerations mean the difference between a compliant-yet-unusable outcome and something that genuinely works for the person using it.

Only Announce The Completed Message

Attempting to announce the message as it streams in may create a juddering and confusing experience that’s difficult for someone to parse.

It is better to wait until the message has completed streaming, and then announce the message’s content in full.

(Large preview)

Let Someone Know Their Request Is Processing

Responses from an LLM often take time to complete. Generally speaking, there are three ways to show a response is still processing:

  1. Using text,
  2. Using a loading animation,
  3. Using text and a loading animation.

These experiences are typically only shown visually. If you cannot see the screen, it may lead to it feeling like the experience has stalled or crashed — especially if the response is for a large or complicated request that takes a while to work through.

To address this, we’ll want to use live region announcements:

If text is visually shown on the screen: Ensure a companion live region announcement is also triggered at the same time the loading message text is displayed. The text string for the live region announcement should be the same as what is shown visually, to be sure to ensure parity of experience:

(Large preview)

If a text-less loading animation is shown on the screen: Ensure the loading state is also communicated to assistive technology.

A live region announcement that mentions the reply is loading after a set amount of time will facilitate an equivalent experience for this interaction. It doesn’t have to be too verbose; the word “Loading” can suffice:

(Large preview)

Triggering the loading message five seconds after prompt submission seems to be the sweet spot, according to the inclusive user research I evaluated. You can then have your logic repeat the loading message every five seconds until the LLM completes its actual reply.

Be sure to also announce the reply immediately as it finishes streaming. You don't need to wait until the next five-second loading message cycle is complete.

Also consider randomly selecting from a set of different phrases that communicate that a response is being formulated after the initial “Loading” message is dispatched. This helps in scenarios where someone may think the loading experience itself has crashed or stalled.

(Large preview)

A Note About ariaNotify()

We’ll eventually be able to replace the technique TetraLogical outlined with ariaNotify(). It is a much-needed and welcome addition to the platform, and will drastically lower the hacks and headaches many developers encounter when creating and managing live region announcements.

Baseline lists the ariaNotify() method as having cross-browser availability at the time of this article’s publication. However, there are two factors to consider here:

  1. The presence of evergreen browsers does not automatically guarantee something is automatically available. There are a whole host of factors that can conspire to keep someone from using the latest and greatest browser version.
  2. Many people who rely on assistive technology have upgrade hesitancy. This is a learned behavior, as you want to be risk-averse and avoid breaking the primary mechanism you use to operate a desktop, laptop, tablet, or smartphone.

Also consider that while a polyfill for ariaNotify() is available, you need to factor in whether it has both:

  1. The full, wide range of support in the actual compared to the dedicated DOM live region technique.
  2. A support policy that is conducive to your organization’s level of accessibility buy-in.

What this realistically means is holding off for a while on ariaNotify() in favor of the tried and true TetraLogical live region technique.

Use Headings

Headings are the most popular way people who use screen readers navigate around an experience. Because of this, I advocate for inserting visually-hidden headings before each chat message.

Here’s a simplified version of that in code:

<article>
  <hX 
    class="sr-only"
    aria-label="You said/{agent name} said"
    tabindex="-1">
    You said:/{agent name} said:
  </hX>
  <div>
    {message body}
  </div>
</article>

To break this down:

  • The article element is used to encapsulate each individual message.
  • hx is a placeholder for the heading level. I’m using an h2 in our actual context example, as the h1 will be the chat session’s title.
  • class="sr-only" applies a treatment that hides the text visually, but ensures screen readers can access it.
  • aria-label repeats the heading element’s string value verbatim. This handles a couple of screen reader bugs, ensuring the vital name part of WCAG’s Name, Role, Value success criterion is present if a heading receives focus — more on that in a bit.
  • tabindex="-1" is the mechanism that allows said heading to receive focus.
  • {agent name} is a placeholder for the name of your LLM. Real-life examples are Claude, Copilot, ChatGPT, etc. I‘m going to call my example coding agent “Cody” because I’m clever and funny.

And here’s what the code might look like using the actual content from a human question and an LLM response:

<article>
  <h2 
    class="sr-only" 
    aria-label="You said:"
    tabindex="-1">
    You said:
  </h2>
  <div>
    what are the strengths and drawbacks of using utility css?
  </div>
</article>

<article>
  <h2 
    class="sr-only" 
    aria-label="Cody said:"
    tabindex="-1">
    Cody said:
  </h2>
  <div>
    Utility CSS trades cleaner global styling for faster, more explicit component styling. It works best with component-based frameworks, where repeated class groups can be encapsulated. It is less attractive when semantic HTML must stay visually uncluttered or styling changes independently from templates.
  </div>
</article>

So, why the “You said:”/”Cody said:” prefix? Remember the visual bias. Visually, we can see the left- or right-hand alignment of messages, used to indicate who is saying what.

The prefix serves the same purpose: identifying the message’s owner. This allows people to quickly move through a conversation the same way someone might quickly scroll upwards to re-establish context, checking who said what and when.

Use Landmarks, But Not Too Many

Using landmark regions to wrap the larger overall areas of your LLM chat experience helps people understand its overall layout. It can also enable quick screen reader navigation to each area:

  • The nav element contains a list of sessions.
  • The main element contains the session messages.
  • The form element contains the input you use to write prompts.
  • The aside element contains a sidebar used to display code or other generated content.

Landmarks allow someone who cannot see the screen to learn about its overall makeup. This is the equivalent of how we quickly move our eyes and tilt our heads to different overall areas when scanning the screen to initially learn the overall layout of an experience.

I am hesitant to wrap chat messages in section or other landmark elements. The reason for this is that they “pollute” the list of landmarks a screen reader can generate, making navigation more laborious. This is especially relevant for long-running sessions where many messages are present.

Compare the following and ask yourself which one would be easier to move through with your keyboard if trying to jump from the prompt content area back to the sessions area:

Here, our visually hidden heading elements serve as a dedicated navigation mechanism for moving through the LLM conversation.

Use Skip Links And Composite Widgets

In addition to headings and landmarks, there are two other ways to let people get around quickly:

1. Skip Links

Skip links — sometimes referred to as skip navigation — allow you to quickly jump to another area on the same page or view.

Skip to main content links are commonplace on many mature websites and web apps. Immersive LLM chat experiences should be no different.

Place a skip link in the DOM that allows someone to jump to the main conversation area before any other DOM content that is shown visually on the screen.

Also consider using additional skip links that enable:

  • Quickly jumping to the prompt input, as well as
  • Bypassing the side panel list of conversations to quickly access the area where profile information and settings are located.

2. Composite Widgets

Composite widgets are used when a discrete section of content contains multiple interactive elements. Focus is then managed within this section by the developer, so that:

  1. The entire overall content area is one tab stop, and
  2. Its child interactive elements are navigated via keyboard.

For the purposes of an immersive LLM chat experience, we want to make conversation lists composite widgets. This enables someone to quickly navigate both within and past the entire list.

Here, consider the use case of someone who exclusively relies on a keyboard to navigate. Compare pressing Tab 50 times to get through each of the 50 conversation sessions you’ve created versus pressing Tab once. Now consider motor control conditions where those keypresses can be fatiguing, or even painful to perform.

Once someone places focus on a conversation list composite widget, they can use the Up and Down arrow keys to navigate through each conversation session list item.

(Large preview)

As a quality-of-life improvement, I also like to support the following keyboard interactions:

  • Home and End to jump to the topmost and bottommost conversation session list items.
  • Typeahead, to match the characters typed with the starting characters of the conversation list item’s title. This is equivalent to what you can do with items within a select menu.
Don’t Use A Feed Pattern

To save you a lot of headaches and prototyping: Corner cases around focus management and usability expectations for people who rely exclusively on keyboards work against you if you try to go with a feed pattern approach.

There’s no need to unnecessarily overcomplicate things. The article elements’ wrapping messages with visually-hidden headings approach that I’ve described earlier is both simple and effective.

People who use assistive technology understand the simpler approach, and it involves far less effort to maintain. It’s a win-win!

Consider Supporting Control + F6 Navigation

Pressing F6/Shift+F6 to hop around different areas of the app is an older navigation technique some people who use Windows screen readers employ when navigating through installable desktop apps. Think of it a lot like navigating by landmark.

(Large preview)

LLM chat experiences are effectively apps in their own right. Because of this, we can recreate the F6 navigation experience and accommodate those who might attempt it. That means:

  • Using Control+F6/Control+Shift+F6 for web experiences. Here, Control serves as a focused modifier key, as the browser itself already has F6 navigation support built into it.
  • Using F6/Shift+F6 for native app experiences built using web technologies. This is because a dedicated, installable app has the expectation that it will operate like one, regardless of how it was built.

How To Build F6 Navigation

There’s no secret sauce here. For starters, place an id on each landmark, as well as tabindex="-1". Also ensure each landmark other than main has an accessible name, granted via either aria-label or aria-labelledby.

After that, have an event listener set up to recognize Control+F6 and Control+Shift+F6 key presses. Set focus to:

  • The next landmark in sequence when Control+F6 is pressed.
  • The previous landmark in sequence when Control+Shift+F6 is pressed.

And voilà! We now have web-based F6 navigation.

How To Socialize F6 Navigation

As it is an older technique, people who are younger or less experienced with screen readers may not know F6 navigation exists.

Consider socializing the capability in the accessibility portion of your application’s settings menu to address this lack of awareness. Also consider exposing and making F6 navigation re-bindable as another discovery technique, provided your application supports keyboard shortcut rebinding.

Special Considerations For Where To Set Focus Using F6 Navigation

Again, this advice only applies to an immersive LLM chat experience. Help agent popups and other less-sophisticated experiences have different expectations.

There are two areas that deserve more finesse when considering where to set focus when F6 navigation is used: the prompting input and the conversation.

Setting focus directly on the input used to type prompts — and not its parent form landmark element — allows someone to quickly get into the action.

Similarly, setting focus on the visually hidden heading of the last message displayed allows them to quickly jump to the content the LLM generated — a data attribute such as data-last-message can be really helpful for managing this.

Using F6 and Shift+F6 keypresses allows someone to hop from the chat input to what the LLM outputs, then back again. This enables rapid keyboard-based review and iteration on an LLM’s output.

(Large preview) Double-Check Zooming

Adjust the text size of your experience and double-check that content is not clipped, or that there’s horizontal overflow.

People increase the text size of the experiences they use, and more than you’d probably guess. They also resize application windows. Also consider that most LLM-based chat designs tend to use a smaller text size to allow for more information shown on screen.

Because of these two factors, it makes sense to evaluate how your experience holds up when the browser font size is increased.

Provide Preferences

Customization lives at the heart of accessibility. It’s only natural that LLM-based chat experiences have preferences to better accommodate all the different ways people use them.

In that vein, thoughtful preference offerings can go a long way to helping out people with access needs. Here are some that I’ve found to be particularly useful.

Set Announcement Granularity

Some LLMs perform interim actions that are circumstantially less important than the messages they ultimately generate. Here, consider programming-oriented LLMs. They can perform actions like researching and reasoning, code search, and tool calls.

These secondary actions typically have a smaller, less visually important treatment compared to the messages that contain the main LLM response content. This is because the results are more important than the methodology when using this type of interaction.

Announcing each of these secondary actions could lead to a confusing or overwhelming experience, especially if multiple actions are clustered and fire off live messages in rapid succession.

To address this, you can allow people to circumstantially switch off the announcements for this type of ancillary information. The content in the conversation is still present; it just isn’t announced via a live region. This is equivalent to how someone who can see the screen can skim over them.

Letting someone re-enable these types of announcements also grants parity in experience, in that it allows them to know the actions are happening if they want a more information-intensive experience. This is equivalent to someone who can see the screen, intentionally paying close attention to the LLM’s actions.

It might also be worth investigating letting people toggle visually hiding and showing these less important announcements, as well. This can help people with attention or cognitive considerations, who may be less familiar with technical jargon.

Disabling Animations

Loading animations and large animated effects, like streaming conversations and side panels expanding and collapsing, can be distracting for some people with attention and cognitive considerations. That can go a long way toward breaking someone's flow.

To address this, you can provide a toggle to turn off animations, reducing their transition time to zero.

You should also strive to be a respectful and courteous steward of the experience. Default your animation toggle to an off state if a request for a reduced motion experience has been in the device operating system. You can use the prefers-reduced-motion media feature to achieve this. Also consider a setting that can re-enable animation, even if a reduced motion request is present.

Disabling Sound

Some people can get distracted by, or have their focus disrupted by, sound effects. This is similar to animation considerations.

Letting people turn off app-specific sound effects means they don’t have to mute their entire device. Here, consider things like other apps playing flow state-inducing music or white noise that they might be using to help them focus.

Alternatives for sound-based notifications include, but are not limited to:

  • Native notifications. This places alerts in a known, expected, and centralized area. Many people already have existing preferences set up for, as well as habits and muscle memory for checking.
  • Badging. Similar to native notifications, many people are familiar with a small dot placed over the application icon being used to show an update.
  • Email. This places updates in another place people also have existing habits for. It is less immediate than a notification, and also threaded into a larger asynchronous communication stream.
  • In-app banners. This is also an asynchronous update technique, one that is intentionally less prioritized than email. Here, someone checks in on progress on their own time, but has a highly visible and consistent way to see if a task has completed or not.

Make Keyboard Shortcuts Re-Bindable

I am of the school of thought that any experience that uses keyboard shortcuts also needs to allow both editing and being switched off, both in bulk and on a shortcut-by-shortcut basis.

This allows people to:

  • Undo conflicts that may arise from other applications they may have installed, and also
  • Set keyboard shortcuts to something that better matches their expectations.

You may be quick to think of conflicts with assistive technology, but I’d also like to take this space to remind you of different language keyboard layouts.

Consider How Special Content Is Announced

Live region messages are plain text strings. These strings are announced by screen readers in full in one go from start to end.

Semantic information that comes for free by using the appropriate HTML element isn’t present in live region announcements—it’s stripped out. Because of that, we need to think about how we could make our live region content both clear and useful.

Note: Parsing and processing strings — including strings used for live regions — is both a brittle and finicky experience. It is also invisible and unglamorous infrastructure.

The act of creating and maintaining this specialized logic often requires far more time and investment than most organizations are willing to expend. Consider keeping up with refactors, localization, and the maintenance budget this will all require.

Only take on special content announcements if you’re absolutely sure you can stay on top of it.

Each type of special content has its own considerations. For my work, I created special cases for tables and blocks of code:

Tables

A table’s cell content will sound odd when announced without the companion semantic structure conferred by elements such as table, th, tr, and td. Relationships between columns and rows aren’t present in a live region announcement, either.

Because of this, we can convert the live region announcement of tables to use a concise description of the number of rows and columns, plus a general description and overall trends it might highlight.

Example output:

Table containing a performance audit, with 4 columns and 36 rows. Audit is broken down by severity.

Code Blocks

A block of code sounds like gibberish when the line breaks are stripped away, and the content is flattened into a single string.

And if it’s a large block of code, it can be a tedious amount of gibberish to parse — nobody wants to sit through an announcement of 2,376 lines of code, painstakingly announced character-by-character.

To accommodate this, we can convert the live region announcement of code blocks to use the filename or file type, plus how many lines of code the block contains.

Example output:

settings.json, 738 lines.

Also note here that people can revisit the actual message content itself. The actual message content will ideally have the appropriate semantics applied to it. This means things like tables being announced as, and navigated through as, table content.

In this way, the live region message is a context-setting preview of what to expect. This is the equivalent of quickly visually skimming a message as it is streaming in, then scrolling back to review its content with more attention afterward.

Ask People What They Think

All of the previous is built atop feedback from testing different approaches and noting what works, and what could be improved. You want to facilitate disabled people being the experts in their own lived experience, and not treat others’ advice as the more credible source.

Inclusive user research is a vital way of determining if an experience is actually usable. Centering disabled people’s observations and perspectives is a way to take an experience beyond baseline compliance and create something usable and equitable.

Wrapping Up

It is vital to ensure that everyone can use chat-based LLM interactions as the pattern continues to proliferate. Although this is not an exhaustive list of everything you’ll need to do, the content above covers a wide swath of the main places accessibility barriers and friction may show up.

It is my sincerest hope that the improvements I’ve learned about and implemented can help you with your efforts to make chat-based experiences on the web more accessible and usable for people who use assistive technology to get what they want or need online.

Thank you to Sarah Higley, whose research and efforts in this area informed key parts of this work.

Modern CSS Might Make Your Front-End More Complex

Have you ever replaced fifty lines of JavaScript with a few lines of CSS, merged the PR, and felt like you just did the codebase a favor? You replace ResizeObserver with a container query, the diff is mostly red, and everyone approves it before lunch.

This was what it looked like before you made the change:

  1. The selector matches more than we meant.
    The :has(img) rule matches any descendant image, so the comment’s avatar counted as a hero image. And the p element selector matches any descendant paragraph. As a result, the comment’s text was caught in the selection.
  2. The selector outweighed the comment’s own rule.
    MDN’s specificity guide explains that :has() adds no weight by itself, but its argument does. That gives .card:has(img) p a specificity score of 0-1-2, while .comment p comes in at just 0-1-1 and loses the battle.

It could get even more complex and difficult to catch because the state changes at runtime. Let’s say a user posts a comment that includes an avatar. The body text of the card above it loses its spacing. Good luck reproducing that from a bug report that says “spacing looks off sometimes.”

The fix is to constrain the selector with child combinators:

.card:has(> img) > p {
  margin: 0;
}

This helps the selector get more specific about what it is yelling about.

Nesting Also Borrows Weight

Native nesting has the same habit. MDN’s guide to nesting and specificity says the & selector takes “the largest specificity in the associated selector list,” exactly like :is(). Look at this adaptation of MDN’s example:

/* Specificity 1-0-0 */
.card, #featured {
  /* Specificity: 1-0-1 */
  & a {
    color: blue;
  }
}

/* Specificity: 0-1-0 */
.button {
  color: red;
}

A .button link inside a .card is blue, even though the #featured ID is nowhere near it. The usual reaction is a more specific .button rule, then an exception to that rule. Before you know it, you are in a war of specificity you never knew you had declared.

The way out is to keep the selector list and drop its weight by wrapping it in :where():

/* :where() always weighs 0-0-0 */
:where(.card, #featured) {
  /* Specificity: 0-0-1 */
  & a {
    color: blue;
  }
}

/* Specificity: 0-1-0 */
.button {
  color: red;
}

Plain links inside a card are still blue, and the .button link is red again. Again, another way to quiet the loud housemate.

Layers Don’t Rescue You By Default

Don’t be fooled into thinking specificity is the whole story. MDN’s introduction to the cascade puts origin, importance, and cascade layers ahead of specificity, and notes that “normal layered styles have less precedence than normal unlayered styles.” In my test, a layered rule with a specificity of 0-4-0 lost to an unlayered .title (0-1-0). So if your new component styles go into @layer components while the legacy stylesheet stays unlayered, the legacy rule wins every conflict, however carefully you wrote the new one. The exception is when the !important keyword is used, because it actually reverses the cascade order.

Miriam Suzanne’s original proposal for cascade layers describes exactly the pain layers were meant to remove: having to “be very careful with matching specificity to layer.” Layers do remove it, but only when the rules on both sides of the conflict are layered. A half-layered codebase just gives you one more ordering to keep in your head.

An Old Fight With A New Tool

None of these battles started with :has() or nesting. In an r/webdev thread titled “CSS-in-JS: What’s the biggest performance drop you actually felt?”, one of the most upvoted answers isn’t about performance at all. It is about the cascade:

“Here’s a fun one: refactoring your JS can cause your CSS to break, because your CSS builds are determined by JS import orders.”

— mq2thez

This is about the “order of appearance,” which is the last step in the cascade that ends up deciding a conflict nobody knew existed. Another commenter in the subreddit adds that the injected styles can land in a different order in development and production builds: “Who doesn’t love debugging something that works locally but not in prod.”

Not everyone in the thread agrees on who is to blame. TheThirdRace replies, “It’s a coding issue, not a technology issue.”

I think both are right, and that is exactly the point. CSS-in-JS is a different technology from the native features we are looking at, so take this as a neighboring example, not as proof. But the shape of the problem is the same: the tool did what it promised, and the trouble arose from how it complied with the existing rules.

Before you add the rule:

  1. Constrain it. Use > so the selector stops at the component’s own children.
  2. Drop the borrowed weight. Wrap heavy selectors in :where(), which always has a specificity of 0-0-0.
  3. Check the layers. Which layer does your rule land in, and where do its competitors live?
Scenario 4: The Housemate That’s Slow To Pay Rent

“We moved it to CSS, so it’s faster now.” You have probably heard this in a code review, and maybe said it yourself. In my last article, I warned that it isn’t always the case. Let’s test it.

Moving a behavior from JavaScript to CSS changes who does the work. It doesn’t tell you how much work there is. The last housemate, the browser’s rendering engine, is the one who gets the bill. Everyone in the apartment shares it, and nobody looks at it after the move.

Take :has() as an example. Browser vendors were worried about its cost from the start. In a CSS Working Group issue about :has() restrictions, Emilio Cobos Álvarez noted that implementations wanted to ship it with limitations “in order to prevent performance footguns and complexity.” Today, MDN’s :has() page has a whole section on performance with two pieces of advice:

  • Don’t anchor :has() to an element with a large subtree, “like body, :root, or *.”
  • Constrain the inner selector with > or +, because otherwise “the browser might need to traverse the entire subtree of the anchor element on every DOM mutation.”

I wanted numbers, so I built a list with 5,000 rows. The test toggles an .is-selected class on the same row 300 times, so the row’s selected state changes on every toggle, and forces a style and layout update each time. I ran it in Chrome 153 on a Mac in October 2026, and recorded a trace in DevTools to count how many elements each toggle restyles.

See the Pen Scenario 4: The Rewrite Nobody Measured [forked] by Shoyombo Gabriel Ayomide.

Rule What is in the stylesheet Median time per toggle Elements restyled
1 JavaScript toggles a class on the toolbar Under 0.1ms 1
2 body:has(.row.is-selected) .toolbar About 1.4ms 1
3 .list:has(.cell > b) .row, with the toolbar handled by JavaScript Under 0.1ms 1
4 Rules 2 and 3 together About 7ms 5,001
5 For scale: JavaScript restyles all 5,000 rows on every toggle About 6ms 5,001

There are two lessons in that table.

First, the “bad” selector was fine. Rule 2 is exactly the shape MDN warns against: a :has() anchored to body. It cost about a millisecond and a half more than the script, and it restyled a single element, the toolbar. A frame at 60Hz lasts 16.7ms, so I would take that trade for deleting an event handler any day.

Second, two harmless rules were not harmless together. Rule 3 styles the rows, and its :has() condition remains unchanged throughout the test. On its own, it costs nothing measurable. Put it in the same stylesheet as the second rule instead, and every toggle restyles all 5,000 rows plus the toolbar. That is about what it costs a script to restyle every row on purpose.

Let’s keep this in proportion. Since 7ms still fits inside a frame, nobody would notice it on this page. However, the browser is now restyling 5,001 elements to change just one, and neither rule says so. Also, the cost grows with the list. When I set the demo to 20,000 rows, the two rules together restyled 20,001 elements and took about 31ms per toggle, which is nearly two frames.

I can tell you what Chrome does here, but not why. Changing .is-selected on one row restyles every element that the other :has() rule targets, even though that rule never mentions .is-selected and its result never changes. I have filed this with the Chromium team as an issue, with a reduced test case, and I only tested Chrome. Whatever the cause, neither rule looks suspicious in a code review, and the cost applies only when both are met.

That is system complexity in a single table. And please take the pattern from it, not the numbers: this is one page, one browser, and one machine.

The same goes for animation. The animation guide on web.dev recommends restricting animations to opacity and transform where possible, and warns that “an animation that moves an element using something other than transform is likely to be slow.” MDN’s CSS performance guide lists the properties that trigger layout when animated, such as width, height, margin, top, and left. A CSS transition on left runs layout on every frame, while a JavaScript animation of transform skips it. The property determines the cost, regardless of which language you write it in.

To be fair, CSS often wins. A script that reads layout, writes styles, and reads layout again forces the browser to do layout several times in one frame, and a container query hands that whole job to the browser. But that win is something you can measure, so measure it:

  1. Record the interaction in the “Performance” panel of Chrome DevTools, before and after the change.
  2. Compare the time spent in “Recalculate Style,” “Layout,” and “Paint.”
  3. Enable CSS selector stats in the panel’s settings to see which selectors cost the most.
  4. Use production-sized data. A 20-row fixture hides what a 5,000-row list reveals.
When All Four Show Up In One Pull Request

Each of these scenarios is small on its own. The trouble is that a real migration could hit all four scenarios at once. You have already seen three of them. They are the three bugs in the “after” demo at the top of this article. Add a long list, and you get the fourth. One move-in, four housemates disturbed.

A team replaces a card’s JavaScript-driven responsive layout with a container query and :has(). The pull request adds twelve lines of CSS, deletes one script, and misses another. Within a month, three bug reports land, and there’s a chance a performance trace turns up as the fourth problem:

  1. The card title is too big on tablets. The observer still sets .card--wide, and one rule still reads it. The developer goes digging through the JavaScript.
  2. The cards on the dashboard have disappeared. On the dashboard, the card is a flex item, and inline-size containment collapsed it to 0px. The developer reads the parent’s layout.
  3. The text is squashed in some cards. Those cards have comments with avatars, so .card:has(img) p matches. The developer traces the winning declaration in DevTools.
  4. Selecting a row might become laggy for our biggest customer. At 5,000 rows, the two :has() rules cost about 7ms per selection. That fits within a frame, even though each selection restyles 5,001 elements, whereas it used to restyle one. As the number of rows increases, the elements restyled increase, and the cost of the two :has() rules per selection will also increase, but who renders a table with a large number of rows without pagination?

None of these reports means that container queries or :has() were the wrong choice. Each bug lives in the meeting point between the new CSS and the system it moved into. Still, one small pull request has sent a developer through the JavaScript, the page layout, the cascade, and the profiler.

And the way out is not a return to JavaScript. Here is the same page once more, fixed.

See the Pen demo (fixed PR) [forked] by Shoyombo Gabriel Ayomide.

It still uses a container query and :has(), with three changes:

  1. The observer and the leftover .card--wide rule are removed, so the layout has a single owner.
  2. The query container is a wrapper that inherits its width from the surrounding layout, so the card can no longer collapse.
  3. The selector is constrained to the card’s own image and its own paragraphs, so the comment keeps its spacing.

This gap between a clean start and a real codebase shows up in the same r/webdev thread. The person who started it, JRM_Insights, opens with an observation that could describe any of our four scenarios:

“I often find that the initial tooling simplicity gives way to harder-to-debug runtime styling issues.”

— JRM_Insights

Further down, mq2thez describes moving an old CSS-in-JS codebase to a newer pattern: “In isolation or greenfield maybe it wouldn’t be a huge issue,” but in practice, it meant rewriting “whole component trees.” TheThirdRace, who had been defending the technology, answers that they had only ever evaluated it “from a greenfield project perspective,” and that it was “very enlightening to see this through the lens of a spaghetti CSS migration.”

That is the honest version of this whole article.

Most of what we read about a new feature is written from the greenfield perspective. Most of what we ship is a migration.

Your Migration Checklist

Before you replace JavaScript with a modern CSS feature, or adopt one in an existing codebase, answer these six questions. Think of them as the conversation to have with the housemates before the new tenant gets a key. I suggest putting the answers right in the pull request description.

  1. Ownership: Is exactly one of CSS or JavaScript the owner of this behavior?
  2. Scope: What changes for the element’s formatting context: its width, its parent, its children, and its neighbors?
  3. Cascade: Which existing rules could override this one, and which rules could it override?
  4. Migration: Have you deleted the old implementation, including every class and selector it relied on, and tested every state?
  5. Performance: Have you measured the real workload before and after, rather than assuming the rewrite is faster?
  6. Maintainability: Can the next developer tell why this rule exists and where its effects stop?
Conclusion

Modern CSS is great and a huge improvement to styling as a whole. In particular, container queries and :has() let us express things that used to need a script, a dependency, or a hack. But a new capability does not hand us a simpler system by default. In every scenario we looked at, the new tenant did something that didn’t sit well with others, and that was because nobody introduced them to the housemates’ ways of doing things. We get a simpler system when the new rule has one clear owner, a scope we have checked, a place in the cascade we chose on purpose, and numbers showing it helped.

So, the next time a pull request deletes more than it adds, enjoy the red lines. Then ask where the complexity went, and run the six questions. If you can’t answer one of them, the migration isn’t finished yet.

References

A Spark Of Color In November’s Gray (2026 Wallpapers Edition)

November can feel rather gray in many parts of the world, so what better way to brighten the month than with some colorful inspiration? Our new collection of desktop wallpapers has you covered.

Following our monthly tradition, which has been going on for more than 15 years already, the wallpapers in this post were designed by artists and designers from across the globe. All of them come in a variety of screen resolutions and can be downloaded for free. A huge thank-you to everyone who shared their creations with us — this post wouldn’t be possible without your wonderful support!

If you would also like to get featured in one of our upcoming wallpapers posts, please don’t hesitate to join in. We are always looking for creative talent and can’t wait to see what you come up with! Happy November!

  • You can click on every image to see a larger preview.
  • We respect and carefully consider the ideas and motivation behind each and every artist’s work. This is why we give all artists the full freedom to explore their creativity and express emotions and experience through their works. This is also why the themes of the wallpapers weren’t anyhow influenced by us but rather designed from scratch by the artists themselves.
From Spooky To Scruffy

“Halloween may be officially over, but the real monster mash is just getting started on your face. This month, we swap the plastic vampire fangs for the ultimate terror: thirty days of completely uninhibited facial hair growth. Think of it as extended character cosplay. By week three, you won’t just be skipping your morning shave, you’ll be auditioning to play Cousin Itt in the next Addams Family reboot. Embrace the itch, dodge the hairbrushes, and let your chin go full ghoul. Who needs a costume when your jawline is the haunted forest?” — Designed by PopArt Studio from Serbia.

One More Bat

“While I was playing with parametric curves, I noticed a gap inside my drawing: it looked like a bat shadow. Bats are protected animals, not only during Halloween.” — Designed by Philippe Brouard from France.

Lost In Time

“All those moments will be lost in time, like tears in the rain. November is here, a transitional month leading into December, winter, and everything that entails. November reminds me of home, the warmth of being indoors and enjoying unique, unrepeatable moments, which brings to mind a fitting line from Blade Runner.” — Designed by Veronica Valenzuela from Spain.

AI In 2027

“Let’s get ready for our shiny new AI 2027 Conference (online), with friendly, approachable experts showing how to set up AI-ready design systems, run AI-driven research, and design for trust in AI. Dec 1, 2026. Tickets are only €50. See you there?” — Designed by the Smashing Magazine Team.

Be Proud Of Yourself

“Be proud of yourself for how far you’ve come. You’ve handled things that once felt impossible.” — Designed by Hitesh Puri from India, Delhi.

Candlelight November

“In Lithuania, the first days of November belong to remembrance: families light candles on the graves of their loved ones and cemeteries across the country glow softly in the evening mist. I wanted a calm, warm wallpaper that turns your desktop into a small candle-lit corner, a quiet pause before the busy end of the year.” — Designed by Justas Arbatauskis from Lithuania.

Colorful Autumn

“Autumn can be dreary, especially in November, when rain starts pouring every day. We wanted to summon better days, so that’s how this colourful November calendar was created. Open your umbrella and let’s roll!” — Designed by PopArt Studio from Serbia.

Falling Into November

“Celebrate the heart of fall with cozy colors, crisp leaves, and the gentle warmth that only November brings.” — Designed by Libra Fire from Serbia.

Winter Is Here

Designed by Ricardo Gimenes from Spain.

Anbani

“Anbani means alphabet in Georgian. The letters that grow on that tree are the Georgian alphabet. It’s very unique!” — Designed by Vlad Gerasimov from Georgia.

Outer Space

“We were inspired by nature around us and the universe above us, so we created an out-of-this-world calendar. Now, let us all stop for a second and contemplate on preserving our forests, let us send birds of passage off to warmer places, and let us think to ourselves — if not on Earth, could we find a home somewhere else in outer space?” — Designed by PopArt Studio from Serbia.

Time To Give Thanks

Designed by Glynnis Owen from Australia.

A Gentleman’s November

Designed by Cedric Bloem from Belgium.

Bug

Designed by Ricardo Gimenes from Spain.

International Civil Aviation Day

“On December 7, we mark International Civil Aviation Day, celebrating those who prove day by day that the sky really is the limit. As the engine of global connectivity, civil aviation is now, more than ever, a symbol of social and economic progress and a vehicle of international understanding. This monthly calendar is our sign of gratitude to those who dedicate their lives to enabling everyone to reach their dreams.” — Designed by PopArt Studio from Serbia.

The Kind Soul

“Kindness drives humanity. Be kind. Be humble. Be humane. Be the best of yourself!” — Designed by Color Mean Creative Studio from Dubai.

November Nights On Mountains

“Those chill November nights when you see mountain tops covered with the first snow sparkling in the moonlight.” — Designed by Jovana Djokic from Serbia.

Red Leaves

Designed by Evacomics from Singapore.

Me And The Key Three

Designed by Bart Bonte from Belgium.

Moonlight Bats

“I designed some Halloween characters and then this idea came to my mind — a bat family hanging around in the moonlight. A cute and scary mood is just perfect for autumn.” — Designed by Carmen Eisendle from Germany.

Mushroom Season

“It is autumn! It is raining and thus… it is mushroom season! It is the perfect moment to go to the forest and get the best mushrooms to do the best recipe.” — Designed by Verónica Valenzuela from Spain.

Go To Japan

“November is the perfect month to go to Japan. Autumn is beautiful with its brown colors. Let’s enjoy it!” — Designed by Veronica Valenzuela from Spain.

Tempestuous November

“By the end of autumn, ferocious Poseidon will part from tinted clouds and timid breeze. After this uneven clash, the sky once more becomes pellucid just in time for imminent luminous snow.” — Designed by Ana Masnikosa from Belgrade, Serbia.

Crown Me

Designed by Ricardo Gimenes from Spain.

Deer Fall, I Love You

Designed by Maria Porter from the United States.

Don’t Let Gray Win

“Let’s take extra care of colors during the autumn months. November might be gray and rainy. Outside. Don’t let it inside. Take a good book, prepare a hot ginger tea, and cover your knees with a bright woolen plaid.” - Designed by Tartanify from France.

Little Mademoiselle

“Black-and-white drawing of a little girl.” Designed by Jelena Tšekulajeva from Estonia.

Welcome Home Dear Winter

“The smell of winter is lingering in the air. The time to be home! Winter reminds us of good food, of the warmth, the touch of a friendly hand, and a talk beside the fire. Keep calm and let us welcome winter.” — Designed by Acodez IT Solutions from India.

First Icicles Of The Coming Winter

Designed by Aleksandra Sivoronova from Latvia.

Autumn Choir

Designed by Hatchers from Ukraine / China.

Get Featured Next Month

Feeling inspired? We’ll publish the December wallpapers on November 30, so if you’d like to be part of the collection, please don’t hesitate to submit your design. We are already looking forward to it!

Accordion Icons: Which Work Best?

So what icon is the most reliable to show expansion and collapsing for accordions? Is there really any noticeable difference between carets, chevrons, arrows, and triangles?

Well, research shows that there is some difference indeed. But what’s more interesting is that split menus are harmful, why it's better to not have icons and text labels link to different actions, and why the caret is the safest icon choice. Let’s dive in!

No Icon = Opening The Page

The findings aren’t very surprising: without any icon in use, users expect that tapping on the menu item would take them directly to a new page. Users often struggle with custom icons as they don't clearly signal that they'll open an accordion. And people tend to tap fairly equally on the icon and on the label for most icons.

Many designs (like the one below) tend to slightly overcomplicate things by adding arrows and carets pointing everywhere, depending on the state of the accordion. But typically we don't need to use an arrow to indicate a link to the category.

The rule of thumb is very simple: if it’s a link, the easiest and most effective way is to simply underline it — without any arrow, caret, or other icon. Perhaps it’s not particularly exciting, but it works flawlessly every single time.

Confusing Behavior With Arrows ▶ and Split Buttons

Using a right-facing arrow icon ▶ isn’t associated with an expectation of going directly to a new page. And having the same icon pointing down ▼ doesn’t necessarily imply that an accordion is going to open on tap/click.

It’s a good idea to avoid split buttons for accordions — where the text label links directly to a page, but the icon opens the accordion. Instead, it’s much more reliable to allow users to tap on a main category and expose the menu; and to access the category page, we add a link to it inside the menu.

Plus +/− and Arrows ↓/↑ Are Understood, But Can Be Misunderstood

For accordions, we typically use +/− or arrows ↓/↑ to signal expanded and collapsed states, and typically it works well. However, both have many different interpretations. Plus + can mean anything from saving for later to adding to cart to zooming in, and can be particularly confusing for multi-level navigation, with many levels open at the same time.

Arrows ↓/↑ can mean scrolling or sliding or finding the next match, but also a jump to a particular portion of a page. Both plus and arrows are well-understood and work, but depending on the design, can be confusing — mostly because they are overloaded.

Wrapping Up

The safe choice is to use the caret/triangle pointing down ▼ by default, and change it to a caret pointing up or a caret pointing sideways ▶ on interaction. If you need an alternative, then +/- typically work well, too.

But we certainly don’t need any further icons or arrows to indicate where the links go. The same goes for split menus, which often produce more mistakes than help. Instead, we have one button or dropdown that does exactly one thing — shows all options and allows users to drill down.

And if you need a direct link, we link the title directly to the page and underline it. More often than not, simpler is better.

Editor’s Note

We hope you’ll find these wonderful projects useful — put together by wonderful creators. A friendly shout-out to everyone sharing their work with folks to use and learn from! That’s one of the reasons why we truly love the web and people building and designing it. 💚

At Smashing, we love the web. That’s why we publish articles and books, run workshops and events around everything web. We love seeing what we all can do to make the web more accessible and usable. We also love organizing and attending online events — with friendly discounts for large groups (5+ attendees) and schools and students. Interested? Just send us an email and we’ll sort it out!

Embracing Playful Imperfection With The CSS `random()` Function

In design, we love spending hours obsessing over consistency, grids, and alignment. But when I heard that the native CSS random() function landed in Safari and is rolling out in Chrome 156, I started wondering: where does randomness actually make sense on the web? Is it something we want in our design system? To find out, I did what I always do in doubt: I built a bunch of playful CodePen demos exploring organic typography, bouncing letters, splayed cards, and a punk fanzine.

As someone who loves building design systems and tinkering with CSS architecture, a big part of my day job revolves around control. We set up spacing scales, lock down typography, set up color tokens, and make sure everything aligns on a grid. Consistency is usually our bread and butter as design engineers and a proud badge of skill when creating design systems. If a card suddenly jumps 20 pixels to the left on a refresh, it’s not creative expression; it’s a bug that the project manager will log.

So when I first heard that the native random() function from the CSS Values and Units Level 5 spec was shipped in Safari, and is currently rolling out in Chrome 156 (with positive signals from Mozilla on Firefox as well), my first reaction was: that’s pretty cool!

And my second reaction was: wait... where would I actually use this without making a mess? How can I convince designers that random might be a good idea for a design system?

Because let’s be honest: why on earth would we want randomness in our stylesheets when we’ve spent the last decade trying to make the web more predictable? Even when using flexbox or fluid typography, we’re still trying to make things as aligned and uniform as possible.

The Charm Of Things Not Being 100% Straight

If you step away from the browser for a second and look at physical things around you, nothing is ever truly uniform.

Take an old letterpress print: the ink bleeds slightly into the paper grain, some letters have a microscopic tilt, and the baseline isn’t always that straight. Or think about a deck of Polaroid photos dropped on a coffee table; those photos aren’t perfect, probably not straight either. Or what about lights flickering in a street at night? That little bit of analog messiness is what makes things feel alive, organic, and human.

On the web, we’ve gotten so good at pixel perfection that sometimes our interfaces end up feeling a bit sterile. We notice this even more now with rapidly created designs by an unguided LLM; we usually end up with the same sort of design we had 10 years ago. Everything is squared off, aligned, neat. It works, but frankly, it does get a bit boring.

Randomness in CSS doesn’t have to mean throwing your design system out the window. It’s about little imperfections and playfulness. Maybe let’s even call it fun.

To see what this actually looks like in practice, I spent a few hours tinkering in CodePen. The demos might feel a bit isolated, but I’m sure that many designers could make the best of this controlled chaos. But before we look at those demos, let’s take a look at the syntax.

How The CSS random() Function Works

The random() function is specified in CSS Values and Units Module Level 5. It generates a pseudo-random value inside your CSS without needing JavaScript or a build-time Sass loop.

The formal specification looks like this:

random( <random-key>?, <min>, <max>, <step>? )

In practice, and across current browser implementations, you can just write comma-separated arguments:

/* Random angle between -3deg and 3deg */
rotate: random(-3deg, 3deg);

/* Random width between 20px and 80px in steps of 10px */
inline-size: random(20px, 80px, 10px);

/* Random animation duration */
animation-duration: random(1.5s, 3s, 0.2s);

Matching Units

It won’t be a shocker for most people, but I thought I should at least mention that your minimum and maximum bounds must share the exact same unit type.

The CSS parser needs to know what dimension it’s dealing with. You can use lengths, angles, time, percentages, or plain unitless numbers:

/* Good: both are angles */
rotate: random(-4deg, 4deg);

/* Good: both are unitless numbers */
opacity: random(0.3, 1);

/* Nope! You cannot mix units */
inline-size: random(2rem, 100px); /* Invalid */

If you ever need to combine units, you’ll have to reach for calc() inside the arguments so each side resolves properly.

Stepping And Rounding

The optional third argument is the step size. If you don’t add it, the browser picks from a continuous range. But if you provide a step, it rounds the random value to discrete increments:

/* Only produces 0px, 15px, 30px, 45px, or 60px */
top: random(0px, 60px, 15px);

This can be helpful in cases where you want things to jump around a bit, but you still want them to land on your pre-defined grid.

Caching Keys: Keeping Things In Sync

Normally, every time random() is evaluated on a property, it creates an independent random value. But there could be an example where you create a box that sets inline-size and block-size at random, but at the same time you need them to match so the element stays a perfect square.

That’s where the caching key comes in:

.card-thumbnail {
  /* Both properties share the key --square-size */
  inline-size: random(--square-size element-scoped, 60px, 120px);
  block-size: random(--square-size element-scoped, 60px, 120px);
}

In the latest spec, a bare dashed ident like --square-size shares its seed globally across every element in the document (which would make all cards identical). To keep width and height linked on a single element while giving each card its own independent size, the spec requires pairing it with the element-scoped keyword (e.g. --square-size element-scoped).

To see this in action, I created a little example. In the top row, the tiles have uncached dimensions, which distorts each tile into an unpredictable, mismatched rectangle. In the bottom row, both inline-size and block-size share --square-size, guaranteeing that each tile remains a pristine 1:1 square. Refresh the CodePen a couple of times and notice the bottom cards keeping the same randomness:

See the Pen Uncached vs cached random() [forked] by @utilitybend.

/* Uncached: width and height resolve independently, creating random rectangles */
.tile-uncached {
  inline-size: random(4.2rem, 8.5rem);
  block-size: random(4.2rem, 8.5rem);
  rotate: random(-3.5deg, 3.5deg);
}

/* Cached: shared key guarantees a clean 1:1 square */
.tile-cached {
  inline-size: random(--square-size element-scoped, 4.2rem, 8.5rem);
  block-size: random(--square-size element-scoped, 4.2rem, 8.5rem);
  rotate: random(--tilt element-scoped, -3.5deg, 3.5deg);
}
Browser Support And Progressive Enhancement

Where can you test this today?

  • WebKit / Safari: Safari was the first to land support.
  • Chrome / Edge: Shipped and rolling out right now with Chrome 156.
  • Firefox: Positive signals on the standards track, so hopefully won’t be too far behind.

Because we’re still in the rollout phase, you’ll want to wrap your experiments in @supports:

/* Baseline for all browsers */
.badge {
  rotate: 0deg;
}

/* Enhanced for browsers with random() */
@supports (rotate: random(-2deg, 2deg)) {
  .badge {
    rotate: random(-2.5deg, 2.5deg);
  }
}

The Future random-item Function

There’s also another function in the spec called random-item(). While random() handles numerical ranges, random-item() lets you pick from a list of predefined tokens or keywords:

/* Picking a random color from your palette */
background-color: random-item(--seed, oklch(75% 0.18 150), oklch(65% 0.22 350), oklch(85% 0.16 85));

This can be handy to randomise from a set of design tokens. This one does not have any browser support at the moment, but it certainly is something to look forward to.

And now for the practical part.

Demo 1: Let’s Just Randomize Letters

When I started playing with the feature, I was also doing some typography tricks with animations. So that’s where my first thought went: Typography! What if we just add a tiny bit of imperfection to a word?

Think of vintage book covers. The letters aren’t misaligned by miles, but they have small imperfections.

See the Pen Imperfection random() [forked] by @utilitybend.

Here is the CSS powering the letters:

@layer demo {
  .char {
    display: inline-block;

    /* A tiny tilt */
    rotate: random(-2.8deg, 2.8deg);

    /* A micro nudge on X and Y */
    translate: random(-1.5px, 1.5px) random(-2.8px, 2.8px);

    /* Very subtle ink variance */
    opacity: random(0.8, 1, 0.02);

    transition-property: rotate, translate, opacity;
    transition-duration: 0.3s;
    transition-timing-function:  cubic-bezier(0.34, 1.56, 0.64, 1);
  }

  /* Snap straight on hover */
  .word:hover .char {
    rotate: 0deg;
    translate: 0 0;
    opacity: 1;
  }
}

I also added a little hover effect. While you’re reading, the word feels playful. But the second you hover over it, every character snaps back.

Please Don’t Break The Screen Reader

One quick accessibility warning here: If you break a word into separate <span> elements so you can style each letter, screen readers will often read it out as individual characters: “i - m - p - e - r - f - e - c - t - i - o - n”, or pause awkwardly between each one. That’s a terrible user experience.

Always hide the visual spans from assistive tech and provide the full word:

<h1 class="word" aria-label="Imperfection">
  <span class="word-inner" aria-hidden="true">
    <span class="char">i</span>
    <span class="char">m</span>
    <span class="char">p</span>
    <span class="char">e</span>
    <span class="char">r</span>
    <span class="char">f</span>
    <span class="char">e</span>
    <span class="char">c</span>
    <span class="char">t</span>
    <span class="char">i</span>
    <span class="char">o</span>
    <span class="char">n</span>
  </span>
</h1>

Screen reader users get the clean text, and sighted users get the fun visual quirks.

Demo 2: Animating The Letters: Pure Procedural Bounce

Once I had those letters sitting there with their little tilts, I couldn’t resist: what if we animated it?

I started tinkering with a bounce keyframe. I was just goofing around, but the end result gave me a little smile. If you animate every letter with the exact same timing, you get that clean sine wave we’ve all seen before. But if every letter gets its own jump height, its own duration, and its own landing squash, suddenly the word looks like a bunch of little characters jumping around on a trampoline.

See the Pen Bouncy imperfection with CSS random() [forked] by @utilitybend.

Here is how the bounce parameters are wired up:

@layer demo {
  .char {
    display: inline-block;
    transform-origin: center bottom;

    /* Procedural bounce variables */
    --jump: random(element-scoped, -35px, -55px, 2px);
    --tilt: random(element-scoped, -8deg, 8deg, 0.5deg);
    --dur: random(element-scoped, 1s, 1.2s, 0.1s);
    --delay: random(element-scoped, -3s, 0s, 0.1s);
    --rebound-squash: random(element-scoped, 1.08, 1.18, 0.02);

    animation: letter-bounce var(--dur) linear var(--delay) infinite;
  }

  @keyframes letter-bounce {
    /* apex */
    0% {
      translate: 0 var(--jump);
      rotate: var(--tilt);
      scale: 1 1;
      animation-timing-function: cubic-bezier(0.65, 0.05, 0.85, 0.35);
    }

    /* touchdown */
    44% {
      translate: 0 0;
      rotate: calc(var(--tilt) * 0.2);
      scale: 0.96 1.05;
      animation-timing-function: ease-out;
    }

    /* squash */
    52% {
      translate: 0 0;
      rotate: 0deg;
      scale: var(--rebound-squash) calc(2 - var(--rebound-squash));
      animation-timing-function: cubic-bezier(0.2, 0.8, 0.2, 1);
    }

    /* back up */
    62% {
      translate: 0 calc(var(--jump) * 0.2);
      rotate: calc(var(--tilt) * -0.4);
      scale: 0.98 1.03;
      animation-timing-function: cubic-bezier(0.15, 0.85, 0.35, 1);
    }

    100% {
      translate: 0 var(--jump);
      rotate: var(--tilt);
      scale: 1 1;
    }
  }
}

Notice the negative animation delay (--delay: random(-3s, 0s)).

If you set a positive delay, the letters sit frozen on page load, waiting for their timers to expire before jumping. By using a negative delay, the browser pretends the animation has already been running for a few seconds. The moment the page loads, every letter is already bouncing at its own rhythm.

Demo 3: Tilting Cards And Dynamic Shadows

We’ve built cards. Lots of cards. So many cards... Portfolio grids, blog summaries, feature lists. And most of the time, they sit in three or four neat, boring columns.

For dashboards, that’s exactly what you want. But if you’re building a lifestyle portfolio, a children’s website, or a collection of vacation photos, we can be a bit more playful. In the following example, I did just that:

See the Pen Random card tilt [forked] by @utilitybend.

Here’s how I put that together:

@layer demo {
  .card {
    /* A gentle random tilt and vertical shift */
    --tilt: random(-3.5deg, 3.5deg);
    --shift-y: random(-6px, 6px);

    rotate: var(--tilt);
    translate: 0 var(--shift-y);

    /* Shadow follows the tilt angle! */
    box-shadow:
      calc(var(--tilt) * 1.5)
      calc(10px + abs(var(--tilt) * 1px))
      28px
      oklch(20% 0.02 260 / 0.07);

    transition:
      rotate 0.4s cubic-bezier(0.2, 0.8, 0.2, 1),
      translate 0.4s cubic-bezier(0.2, 0.8, 0.2, 1),
      box-shadow 0.4s ease;

    /* Straighten up on hover or keyboard focus */
    &:hover,
    &:has(.button:focus-visible) {
      rotate: 0deg;
      translate: 0 -10px;
      z-index: 10;
      box-shadow:
        0 20px 44px oklch(20% 0.02 260 / 0.12),
        0 2px 6px oklch(20% 0.02 260 / 0.04);
    }
  }
}

In the example, playing around with the shadow was a fun experiment. I will probably try more effects with that in the future.

Demo 4: The Splayed Deck With sibling-index And scroll

Here is where modern CSS features start getting really interesting. In the previous demo with tilting cards, we used pure randomness. But what if you have a stack of cards that needs to fan out across the screen as you scroll?

In this example, I decided to use math for the structure and randomness for the human imperfection.

See the Pen Scroll drivin animations with random() tilted cards [forked] by @utilitybend.

Here is the setup:

@layer demo {
  .deck-card {
    position: absolute;

    /* Mathematical fan base via sibling-index() (centered around middle card) */
    --elevation: sibling-index();
    --base-rot: calc((sibling-index() - (sibling-count() + 1) / 2) * 12deg);
    --base-x: calc((sibling-index() - (sibling-count() + 1) / 2) * 60px);

    --jitter-rot: random(-3.5deg, 3.5deg);
    --jitter-y: random(-12px, 12px);
    --jitter-x: random(-8px, 8px);

    transform-origin: center 130%;

    /* SDA */
    animation: splay-fan linear both;
    animation-timeline: scroll(root);
    animation-range: 0% 80%;

    transition: scale 0.3s cubic-bezier(0.2, 0.8, 0.2, 1);

    &:hover {
      scale: 1.05;
      /* Hovered item on top */
      z-index: calc(sibling-count() + 1);     }
  }

  @keyframes splay-fan {
    from {
      rotate: 0deg;
      translate: 0 0;
      box-shadow:
        0 1px 3px oklch(20% 0.02 260 / 0.1),
        0 2px 8px oklch(20% 0.02 260 / 0.07);
    }
    to {
      rotate: calc(var(--base-rot) + var(--jitter-rot));
      translate: calc(var(--base-x) + var(--jitter-x)) var(--jitter-y);
      /* Splayed:
          1. Sharp inter-card contact edge shadow
          2. Elevated atmospheric shadow scaled realistically by sibling-index() */
      box-shadow:
        0
        calc(1px + var(--elevation) * 0.6px)
        4px
        oklch(20% 0.02 260 / 0.1),
        calc(var(--base-x) * 0.15)
        calc(10px + var(--elevation) * 5px)
        calc(18px + var(--elevation) * 7px)
        oklch(20% 0.02 260 / 0.13);
    }
  }
}

Look at how cleanly this works:

  • sibling-index() calculates the mathematical fan so cards spread out evenly around the center card, and scales --elevation so cards higher in the stack cast wider shadows.
  • calc((sibling-index() - (sibling-count() + 1) / 2) * 12deg); makes sure the amount of cards doesn’t matter; they each will rotate the same 12deg amount.
  • random() adds the slight wobble you'd get if a person dealt the cards by hand.
  • animation-timeline: scroll(root) ties the entire fan and shadow transition to the scrollbar.
Demo 5: Random Velocity

If you’ve ever looked at brutalist or high-end fashion websites, you’ve probably seen horizontal marquee text drifting across the screen as you scroll down the page.

Usually, you see developers creating classes like .drift-slow, .drift-fast, .drift-reverse, or using a hefty JavaScript scroll listener to compute transforms.

With random() and a tiny bit of math, we can get procedural drift speeds in just a few lines:

See the Pen Random() velocity scroll animation [forked] by @utilitybend.

Here is the CSS:

@layer demo {
  .drift-line {
    white-space: nowrap;

    /* Alternate direction between rows using math parity */
    --direction: calc(pow(-1, sibling-index()));

    /* Velocity distance */
    --travel: random(15%, 44%);

    /* Tied to page scroll */
    animation: tectonic-glide linear both;
    animation-timeline: scroll(root);
    animation-range: entry 0% cover 100%;
  }

  @keyframes tectonic-glide {
    from {
      translate: calc(var(--direction) * -1 * var(--travel)) 0;
    }
    to {
      translate: calc(var(--direction) * var(--travel)) 0;
    }
  }
}

calc(pow(-1, sibling-index())) gives us alternating directions (1, -1, 1, -1), and random(15%, 44%) decides how fast each row travels. As you scroll, each typographic line moves at its own tempo.

Demo 6: Blurry Randomness

I love photography, and one of my favorite things about prime lenses is shallow depth of field. When you shoot at a wide aperture like f/1.7, only whatever is right on your focal plane stays sharp. Everything else melts away into soft bokeh. Yep, photography is all about that bokeh!

By combining random() with filter: blur(), opacity, and scale, we can recreate that lens feel:

See the Pen All about that random() bokeh [forked] by @utilitybend.

Here’s the snippet:

@layer demo {
  .focal-item {

    /* Random optical blur, opacity, and scale */
    filter: blur(random(0px, 8px, 1px));
    opacity: random(0.25, 1, 0.05);
    scale: random(0.85, 1.25, 0.05);

    transition:
      filter 0.4s cubic-bezier(0.2, 0.8, 0.2, 1),
      opacity 0.4s ease,
      scale 0.4s cubic-bezier(0.34, 1.56, 0.64, 1);

    /* Rack-focus on hover */
    &:hover, &:focus {
      filter: blur(0px);
      opacity: 1;
      scale: 1.15;
    }
  }
}

Some words land at blur(0px) with full opacity right in front of your eyes. Others blur out to 6px or 8px and fade into the background. And when you hover over any blurry item in the back, it rack-focuses right into sharpness. It’s a great little effect for decorative hero sections or tag clouds.

Where Randomness Makes Sense (And Where It Doesn’t)

Now that we’ve played with the wild side, let’s talk about where this actually belongs in our daily work.

Good Use Cases

  • Subtle micro-imperfection on decorative UI: Tilting polaroids, slight angles on sticky notes, or typographic hero titles.
  • Desynchronizing ambient loops: Status beacons, gentle floating badges, or background particle grids where perfect unison looks robotic.
  • Generative backgrounds: Star fields, confetti celebrations, floating bokeh circles, or texture grain.
  • Editorial art direction: Magazine spreads, event flyers, brutalist layouts, and playful landing pages.
  • Layering on top of math: Using sibling-index() for the structural grid and adding small random offsets for human warmth.

Where You Should Avoid It

  • Core layouts and grids: Don’t randomize column gutters, form field widths, or container padding. People need predictable layout geometry to navigate.
  • Body copy: Don’t touch font sizes, line heights, or letter spacing on long-form paragraphs. Reading fatigue is real.
  • Interactive targets: Don’t leave small buttons or links tilted or shifted without resetting them on hover and focus. If a user has to chase a moving or crooked button, you’ve failed them.

But! I am happy to be proven wrong here. I encourage you to challenge the status quo and experiment with this.

Always Respect prefers-reduced-motion

Any time you use animations, you have to respect user preferences for reduced motion:

@media (prefers-reduced-motion: reduce) {
  .char {
    animation: none;
    rotate: 0deg;
    translate: 0 0;
  }
}

If someone prefers reduced motion, it could also be a good idea to flatten the angles, not just the animations. I can imagine that a lot of random angles can also upset people while scrolling. Design should be fun, but never at the cost of accessibility.

Wrapping My Head Around random()

Tinkering with random() over the last couple of days was a lot of fun. I’m still not sure if I’ll be able to convince my designer friends, but what I do know is that it brings a bit of joy.

Whenever we wanted a bit of organic randomness on the web, we had to make compromises: either pull in a JavaScript animation library, or write huge preprocessor loops that spit out hundreds of lines of static CSS. Having this built into the browser engine with zero JavaScript overhead is such a welcome addition.

We spent the last decade mastering consistency, tokens, and design systems. Now that we have that foundation in place, maybe it’s time to let a little bit of playful messiness back onto the web.

I really believe that the web is supposed to be fun.

Never mind the defaults; here is CSS random().

See the Pen Never mind the defaults, here is css random() [forked] by @utilitybend.

Is Your Organization Messing Up AI Adoption?

The way I see most organizations roll out AI feels more like a farce than a strategy. If it were turned into a movie, reviewers would say it was unbelievable. Nobody could be that stupid.

Yet here we are. And what makes it all the more frustrating is that we have been here before.

Back in 2014, I wrote a book for Smashing Magazine called Digital Adaptation, looking at the mistakes being made in how organizations were approaching digital transformation and what they should be doing instead. The similarities between then and now are striking.

So in this post, I want to look back at Digital Adaptation and see how the lessons in that book apply to the AI era and what we can learn from the past to help us navigate the challenges of AI today.

The biggest mistake, both then and now, is approaching each as a technological challenge.

It’s About People, Not Technology

Sure, both digital transformation and AI are technological advances, and yes, some level of technological implementation is required. But that is the tip of a very large iceberg.

Back in the midst of the digital transformation era, IT departments were rolling out CMSs, CRM systems, intranets, and so on. Meanwhile, on the customer-facing side, organizations were rolling out websites, apps, and personalization. But they were putting almost no emphasis on how people were going to use these systems.

Internal systems were hard to use, and customers either didn’t care what was being built or wanted something else entirely.

The same is happening with AI. Senior management are buying into the hype, and IT teams are rolling out Copilot Studio licenses company-wide and considering the job done. Sure, there is a bit of organization-wide generic training, but that’s about it.

Just like before, staff are left wondering what to do with these new systems and feeling under pressure to use them and deliver results.

Organizations need to recognize that AI is a cultural shift as much as a technology, and that shift has enormous implications for their staff.

After all, this time around, it is even worse, because this time, staff fear for their jobs. They have read the same headlines that you have, and no amount of promises from senior management is going to make them feel any better.

Why Would Staff Want To Adopt AI?

I mean, think about it from a staff member’s point of view. AI offers them very little personally, even setting aside the fact that management may be intending to use it to replace them.

The main reason senior management are excited about AI is that it provides additional productivity. People can do more in less time. But that does not benefit staff. They are still required to work 9 to 5, but now they are expected to do more in the same time. They don’t get any time back, and they don’t get paid more, so why would they embrace AI?

So before asking staff to embrace AI, organizations need to ask themselves how they intend to motivate them to do so.

One strategy is to help staff identify the parts of their job they hate and how AI can help them do those tasks more quickly and less painfully. People tend to be a lot more receptive to change when it is presented as an opportunity to improve their working lives.

But, that should just be the beginning. Organizations may need to consider providing incentives for staff to adopt AI in terms of career progression, compensation, or shorter working hours.

Staff Need Time And Support To Adopt AI

Also, adopting AI is not a simple task. It involves challenging every working practice they have built up over (in some cases) decades. All of that procedural knowledge has to be rebuilt. That is a lot to ask of anybody in even the best of circumstances, and most employees do not find themselves in the best of circumstances.

Most are overworked and struggling to stay on top of their to-do lists. They don’t have time to sit down, learn a new tool, and figure out how it fits into their workflow.

That doesn’t just take time. It also takes a lot of consideration and experimentation. It is not enough to just send a member of staff on a training course and expect them to be able to use AI to its full potential.

At a minimum, staff need training specific to their roles, such as the AI training I provide to UX teams. But organizations should be going even further.

They need to develop sophisticated training programs that help staff from different departments understand how to use AI in their specific roles. They need ongoing support and the time to experiment with AI to find the best ways to use it.

But formal training will only take you so far. In my experience, the most effective support comes from colleagues, which is why I would start with the enthusiasts rather than the resisters. Every organization has a handful of people who are already experimenting with AI, often without anybody asking them to. Bring those people together, give them the time and space to share what is working for them, and let their enthusiasm spread to everyone else.

I saw this work during the digital transformation era too. In Digital Adaptation, I described an internal conference where staff showed their colleagues what they had built, and it did more for adoption than any memo from the top ever could. People are far more likely to try something when they see a colleague in a similar role using it successfully than when they are told to by senior management.

Rather than trying to win over the most resistant staff first, organizations should find the people already experimenting with AI, give them time to share what they have learned, and let social proof do the heavy lifting.

Unfortunately, experimentation comes with a big downside… mistakes will be made.

It Needs To Be Safe To Fail

Many organizations have, to be frank, a culture of fear where mistakes are seen as a sign of incompetence. However, by its very nature, learning a new tool like AI will involve making mistakes, and this can be a massive barrier to adoption.

I saw this during the era of digital transformation. Senior management would demand digital transformation and were confused when it didn’t happen.

What they didn’t realize was that they were sending mixed messages to staff. Sure, they were asking for digital transformation, but they were still demanding that the same key performance indicators (KPIs) be met, and they still pointed out any mistakes in their annual reviews.

There was no space to fail, as the pressure to deliver was relentless.

This time around, it seems to be even worse. I hear horror stories of staff being reprimanded for using too many tokens just weeks after being told to adopt AI. Or staff being lectured so much about what they should or should not do with AI that they are afraid to try anything. It is safer to just do what they have always done.

If management want staff to adopt AI, then they need to make staff feel safe to experiment. They need to adjust KPIs, change how staff are reviewed, and relax some of the governance while staff are learning.
Handle Governance With Care

Look, I get it. AI cannot be rolled out without some governance in place, but again, this is an area that organizations have typically handled poorly.

In the midst of digital transformation, governance would either be non-existent, or it would be so strict that it would stifle innovation, and unfortunately, I see the same pattern emerging with AI adoption.

Staff need some governance to help them know where they stand. It helps them understand what is expected of them and what they can and cannot do.

But too often organizations have been so strict that it is easier not to do anything at all. Pages of instructions about what people should and should not share with AI create that sense of fear that I mentioned earlier.

Organizations need a short set of principles that would fit on a handful of posters, similar to gov.uk’s design principles. Beyond that, they need to demonstrate a degree of trust in their staff to use common sense.

Of course, mistakes will get made, but that is the cost of change, and so organizations need to accept that and do what they can to mitigate that in how they roll out the technology.

Adaptive Technological Rollout

That said, organizations will need to be careful in how they roll out AI from an IT perspective. Once again, it is easy to lock everything down and stifle the adoption of AI.

Again, this is something I highlighted back in 2014 with digital transformation. Overstretched IT teams would pick a set of technologies and roll them out organization-wide, often with little or no consultation with the individuals who would be using them. Anything outside of that set of technologies had to go through a complex approval process, normally involving a steering committee. The result was a glacial pace of change that was one of the major contributing factors to the failure rate of digital transformation projects.

Today we are seeing the same thing. IT teams are opting into a tool like Copilot and calling it a day, but that often falls massively short.

Take, for example, a UX team I am working with at the moment. Management is pushing hard for AI adoption, and the team is excited about the potential of creating an AI-powered research repository and even AI personas. It sounds like a wonderful case study in AI adoption, with enthusiastic management, an excited team, and innovative ideas.

Unfortunately, the reality is that nothing is happening because Copilot cannot deliver on the team’s vision, and so they are currently bogged down in bureaucracy as they try to persuade the AI steering group that they need to use a different toolset. Understandably, the team’s enthusiasm is waning. Why bother?

And that team is one of the more patient ones. In many organizations, staff are not waiting for the steering group at all. Just as we saw shadow IT during the digital transformation era, with people signing up for Dropbox and Google Docs because the official tools could not do what they needed, we are now seeing shadow AI. When the in-house AI tool will not let people do their jobs, they open a personal ChatGPT or Claude account on their phone or home laptop and get on with it.

That is far more dangerous than the problem the restrictions were meant to prevent. Company data ends up in tools the organization has no control over, with no oversight and no record of what has been shared. In trying to lock everything down, organizations end up pushing the risk somewhere they cannot see it.

The instinctive reaction is to clamp down with stricter policies, blocked websites, and warnings about disciplinary action. But that rarely works, and it drives the behavior further underground. Shadow AI is a symptom, and a useful one, because it shows exactly where the official tools are falling short.

Instead of trying to stamp out shadow AI, organizations should learn from it. Talk to staff about what they are using personal accounts for and what they feel they cannot do with the AI they have been given, then use that to shape what gets rolled out next.

Look, I understand the cost of a messy, out-of-control tech stack. It is not ideal. However, in the early days of adoption, we may have to live with a bit of chaos while people explore the edges of what is possible and work out common use cases.

Organizations need to allow staff to explore different uses of AI and even different AI apps to find what suits their specific needs in their specific roles. They can always start locking things down later as the real organizational needs become clearer.

A Dangerous Time

I admit all of this feels dangerous to some organizations. They want to control the AI adoption process centrally and make sure nothing goes wrong. I understand that. But change comes with a degree of risk, and the risk of moving too slowly is greater than the risk of moving too fast.

However, a bigger danger still is when organizations see this as a technological challenge and overlook the human side of things. AI adoption is not simply about rolling out new technology. Just like digital transformation, it is about people, culture, and change management. The sooner organizations realize the scope of what they are dealing with, the better.

A Practical Guide To Naming Things

Naming is hard. The language we use shapes the way we think about things, but also the conversation we have about it. That’s why we have so much confusion about colors, icons, UI components, features — and that’s why we struggle to name design tokens, HTML classes, and variables.

Sometimes, the names we choose are too generic, so it’s difficult to understand what exactly is meant. And sometimes they are too specific, leaving little room for flexibility and reuse. How do we choose the right names? And which naming conventions work best? Let’s take a closer look.

How To Name Things

If you’re looking for some inspiration for naming HTML classes, CSS properties, or JavaScript functions, Classnames is a wonderful resource jam-packed with ideas that get you thinking outside the box.

The site provides thematically grouped lists of words perfect for naming. You’ll find terms to describe different kinds of behavior, likeness between things, order, grouping, and association, but also themed collections of words that wouldn’t instantly come to one’s mind when it comes to code, among them words from nature, art, theater, music, architecture, fashion, and publishing.

How To Name Colors

How would you choose the right name for a given color? Fortunately, David Aerne maintains a tremendous repository of color names, currently with 30355 unique color names, sourced from various references and 1000s of user contributions.

Of course, the repository comes with a color picker and name search and plenty of other color pickers as well. Tremendous work, which is also a fantastic reference to keep nearby.

How To Name Layers and Groups

What makes a good name? Javier Cuello summarized a set of naming best practices that help you name your layers, groups, and components in a consistent and scalable way.

As Javier points out, a good name has a logical structure, is short, meaningful, known by everyone, and not related to visual properties. He shares do’s and don’ts to illustrate how to achieve that and also takes a closer look at all the fine little details you need to consider when naming sizes, colors, groups, layers, and components.

How To Name Design Tokens

How to build a flexible design token taxonomy that works across different products? That was the challenge that the team at Intuit faced. The parent company of products such as Mailchimp, QuickBooks, TurboTax, and Mint developed a flexible token system that goes beyond the brand theme to serve as the foundational system for a wide array of products.

Nate Baldwin wrote a case study in which he shares valuable insights into the making of Intuit’s design token taxonomy. It dives deeper into the pain points of the old taxonomy system, the criteria they defined for the new system, and how it was created. Lots of takeaways for building your own robust and flexible token taxonomy are guaranteed.

Frequent Names For UI Components

Looking at what other people call similar things is a great way to start when you’re struggling with naming. And what better source could there be than other design systems? Before you end up in the design system rabbit hole, Iain Bean did the research for you and created the Component Gallery.

It’s a collection that includes plenty of examples for more than 50 UI components — from accordion to visually hidden — and also lists other names that the UI components go by. A fantastic resource, and not only with regard to naming.

Bonus: Name That UI, a visual dictionary of common UI components.
How To Name New Features

Features often have low adoption due to poor discoverability. Feature adoption needs time — first the feature must be discovered, then understood, then tried, learned, and eventually built into existing workflow. Erin Gannon has written a helpful practical guide on how to make sure all of it happens.

Good names are driven by user needs and problems. They should signal the value or outcome of a feature (the job-to-be-done), and — most importantly! — tap into the user’s own language. So ask people to explain a feature in their own words and then use the words they use.

How To Name Variables (Taxonomy Map)

A wonderful example of naming guidelines for a complex multi-brand, multi-themed design system comes from the Vodafone UK Design System team. Their Variables Taxonomy Map breaks down the anatomy and categorization of a design token into a well-orchestrated system of collections.

The map illustrates four collections required to support the system and connections between tokens — from brand and primitives to semantics and pages. It builds on top of Nathan Curtis’ work on naming design tokens and enables everyone to gather insight about where a token is used and what it represents, just from its name.

If you want to explore more approaches to naming design tokens, I’ve put together a list of useful Figma kits and resources that are worth checking out.

Design Token Naming Guide + Inventory

Romina Kavcic created a helpful little tool for naming design tokens — from learning how they work and how to name them well to configuring your own naming structure with components, categories, states, and roles.

Bonus: The Design Token Names Inventory spreadsheet, with a simple structure with four levels to give you a bird’s-eye view of all your design tokens. You can easily add rows, themes, and modes without losing track, and filter your tokens.
Naming Products or Services

If you are looking for the right name for your product or service, Onym is a fantastic open-source repository that organizes tools and resources for finding names for brainstorming, vetting, guides, sprints, etymologies — all the way to cautionary tales and agencies that name things, as well as useful books to take a look at.

Useful Bookmarks for Naming Things

A quick-reference list of tools and guides for naming just about... well, anything, in one place:

Wrapping Up

The right name is the one that’s well-understood and used by the team and users. So much time is wasted speaking about the very same thing but in different dialects — the designer’s dialect, the developer’s dialect, the product manager’s dialect, and the user’s dialect. That’s what often causes frustration and confusion.

So if you see low adoption, it might be merely because of the name. And pay attention to potential naming conflicts and put them in a backlog of things to address later. It’s one of those fine little details that can reduce frustration and confusion and help teams work together better.

Editor’s Note

We hope you’ll find these wonderful projects useful — put together by wonderful creators. A friendly shout-out to everyone sharing their work with folks to use and learn from! That’s one of the reasons why we truly love the web and people building and designing it. 💚

At Smashing, we love the web. That’s why we publish articles and books, run workshops and events around everything web. We love seeing what we all can do to make the web more accessible and usable. We also love organizing and attending online events — with friendly discounts for large groups (5+ attendees) and schools and students. Interested? Just send us an email and we’ll sort it out!

Under Autumn’s Spell (October 2026 Wallpapers Edition)

Misty mornings, leaves shining in bright red, yellow, and orange hues, and spooky creatures making an appearance — October has a very special charm. So, how about some new desktop wallpapers to celebrate October’s beauty, and the upcoming Halloween season, of course? Well, we’ve got you covered.

Just like it has been a monthly tradition here at Smashing Magazine for more than 15 years already, the wallpapers in this post were created by artists and designers from across the globe. All of them come in a variety of screen resolutions and can be downloaded for free. A huge thank-you to everyone who shared their designs with us — you are truly smashing!

Now, before you pick your favorite for the month, did you know that you can also get featured in one of our upcoming wallpapers posts? We are always looking for creative talent, so please don’t hesitate to join in. We’d love to see what you come up with!

  • You can click on every image to see a larger preview.
  • We respect and carefully consider the ideas and motivation behind each and every artist’s work. This is why we give all artists the full freedom to explore their creativity and express emotions and experience through their works. This is also why the themes of the wallpapers weren’t anyhow influenced by us but rather designed from scratch by the artists themselves.
A Night Of Universal Magic And Joy

“From candlelit streets in Europe to vibrant festivals across the Americas, Halloween has become a global celebration that unites people of all ages. It is a magical night where children step into the shoes of their favorite heroes for candy-filled adventures, while adults rediscover the pure, playful excitement of childhood. Across cultures and continents, glowing pumpkins and festive costumes light up the autumn dark, bringing neighbors together, sparking laughter, and proving that joy knows no age limit.” — Designed by PopArt Studio from Novi Sad, Serbia.

Voodoo You

Designed by Ricardo Gimenes from Spain.

Hanging

Designed by Ricardo Gimenes from Spain.

Under The Floodlights

“October football begins under the lights. This geometric illustration captures the quiet moment before kickoff: an empty pitch, warm floodlights, and a dark autumn sky. A few fallen leaves hint at the season, while the open composition leaves room for the everyday things on your desktop.” — Designed by Football Charts from Serbia.

Coffee Weather

“October is here, which means colder mornings, warmer clothes, and coffee that somehow tastes better outside. A small autumn scene for one of the coziest months of the year.” — Designed by Ginger IT Solutions from Serbia.

Midnight Mischief

Designed by Libra Fire from Serbia.

Magical October

“‘I’m so glad I live in a world where there are Octobers.’ (L.M. Montgomery, Anne of Green Gables)” — Designed by Lívi Lénárt from Hungary.

The Night Drive

Designed by Vlad Gerasimov from Georgia.

Bird Migration Portal

“When I was young, I had a bird’s nest not so far from my room window. I watched the birds almost every day, because those swallows always left their nests in October. As a child, I dreamt that they all flew together to a nicer place, where they were not so cold.” — Designed by Eline Claeys from Belgium.

The Crow And The Ghosts

“If my heart were a season, it would be autumn.” — Designed by Lívia Lénárt from Hungary.

Spooky Town

Designed by Xenia Latii from Germany.

Hanlu

“The term ‘Hanlu’ literally translates as ‘Cold Dew.’ The cold dew brings brisk mornings and evenings. Eventually the briskness will turn cold, as winter is coming soon. And chrysanthemum is the iconic flower of Cold Dew.” — Designed by Hong, ZI-Qing from Taiwan.

Ghostbusters

Designed by Ricardo Gimenes from Spain.

Hello Autumn

“Did you know that squirrels don’t just eat nuts? They really like to eat fruit, too. Since apples are the seasonal fruit of October, I decided to combine both things into a beautiful image.” — Designed by Erin Troch from Belgium.

Transitions

“To me, October is a transitional month. We gradually slide from summer to autumn. That’s why I chose to use a lot of gradients. I also wanted to work with simple shapes, because I think of October as the ‘back to nature/back to basics month’.” — Designed by Jelle Denturck from Belgium.

AI

Designed by Ricardo Gimenes from Spain.

First Scarf And The Beach

“When I was little, my parents always took me and my sister for a walk at the beach in Nieuwpoort. We didn't really do those beach walks in the summer but always when the sky started to turn gray and the days became colder. My sister and I always took out our warmest scarfs and played in the sand while my parents walked behind us. I really loved those Saturday or Sunday mornings where we were all together. I think October (when it’s not raining) is the perfect month to go to the beach for ‘uitwaaien’ (to blow out), to walk in the wind and take a break and clear your head, relieve the stress or forget one’s problems.” — Designed by Gwen Bogaert from Belgium.

Shades Of Gold

“We are about to experience the magical imagery of nature, with all the yellows, ochers, oranges, and reds coming our way this fall. With all the subtle sunrises and the burning sunsets before us, we feel so joyful that we are going to shout it out to the world from the top of the mountains.” — Designed by PopArt Studio from Serbia.

Tea And Cookies

“As it gets colder outside, all I want to do is stay inside with a big pot of tea, eat cookies, and read or watch a movie, wrapped in a blanket. Is it just me?” — Designed by Miruna Sfia from Romania.

Autumn Deer

Designed by Amy Hamilton from Canada.

Discovering The Universe

“Autumn is the best moment for discovering the universe. I am looking for a new galaxy or maybe… a UFO!” — Designed by Verónica Valenzuela from Spain.

King Of The Pirates

Designed by Ricardo Gimenes from Spain.

Autumn In The Forest

“Autumn is a wonderful time to go for walks in the forest!” — Designed by Hilda Rytteke from Sweden.

Autumn Gate

“The days are colder, but the colors are warmer, and with every step we go further, new earthly architecture reveals itself, making the best of winters’ dawn.” — Designed by Ana Masnikosa from Belgrade, Serbia.

Game Night And Hot Chocolate

“To me, October is all about cozy evenings with hot chocolate, freshly baked cookies, and a game night with friends or family.” — Designed by Lieselot Geirnaert from Belgium.

A Very Pug-o-ween

“The best part of October is undoubtedly Halloween. And the best part of Halloween is dog owners who never pass up an o-paw-tunity to dress up their pups as something a-dog-able. Why design pugs specifically in costumes? Because no matter how you look at it, pugs are cute in whatever costume you put them in for trick or treating. There’s something about their wrinkly snorting snoots that makes us giggle, and we hope our backgrounds make you smile all month.” — Designed by Trillion from Summit, NJ.

Roger That Rogue Rover

“The story is a mash-up of retro science fiction and zombie infection. What would happen if a Mars rover came into contact with an unknown Martian material and got infected with a virus? What if it reversed its intended purpose of research and exploration? Instead choosing a life of chaos and evil. What if they all ran rogue on Mars? Would humans ever dare to voyage to the red planet?” Designed by Frank Candamil from the United States.

Halloween 2040

Designed by Ricardo Gimenes from Spain.

Dope Code

“October is the month when the weather in Poland starts to get colder, and it gets very rainy, too. You can’t always spend your free time outside, so it’s the perfect opportunity to get some hot coffee and work on your next cool web project!” — Designed by Robert Brodziak from Poland.

Happy Fall!

“Fall is my favorite season!” — Designed by Thuy Truong from the United States.

Get Featured Next Month

Feeling inspired? We’ll publish the November wallpapers on October 31, so if you’d like to be part of the collection, please don’t hesitate to submit your design. We are already looking forward to it!

Stop Treating CSS Container Queries Like Traditional Media Queries

To be completely honest with you, I missed the news when CSS Container Queries first shipped. And when I finally heard about it, my very first thought was, “Why exactly do I need this when media queries already exist?”

I’m not proud of that reaction, knowing what I know now, but it was comforting to know that I wasn’t alone. In fact, there are legions of us out there.

What baffles me is that container queries aren’t a new feature, as it currently sits at around 94% browser support. And yet, very few people are actually using it. According to the State of CSS survey, 86% of developers are aware of container queries, but only 41.4% actually use them. Surveys can be biased and not completely representative of our entire field, but this one is certainly the best indicator we’ve got.

Kevin Powell also talked about this at SmashingConf Amsterdam 2026: Container Queries adoption has been terrible. And that is so strange to me, knowing that the ability for components to adapt to the size of their outer container has been at the top of so many CSS wishlists over the years.

I’m not particularly interested in how many people are using container queries as much as in how they are using them. I can’t account for everyone, but from what I’ve seen — including in my own early attempts — many of us are using them wrong.

The bottom line is that incorrect use comes down to the same impression I had when learning about them: they absolutely look just like media queries at first glance. And since they look similar, it’s easy to assume they serve similar purposes and work the same way.

They don’t.

Note: I should state up front that what I’m focusing on in this article is using container size queries, i.e., a responsive design technique for responding to the size of a particular container. There are also container style queries that respond to a container’s computed styles (and are experimental at the time of this writing). You can catch up on those in Juan Diego’s piece here on Smashing Magazine where he examines their possible use cases.

Media Queries Look Outward

The viewport is a proxy. It always has been. Media queries are what gave us the illusion that screen width alone is responsible for how responsive apps adapt to their environment.

Ask yourself this: When you write @media, what are you asking the browser?

@media (min-width: 1024px) {
  .card {
    display: flex;
  }

I, like most developers, am asking the browser: How wide is the screen right now? That’s it.

Media queries answer that beautifully, but what happens when this .card component is placed in a grid cell that’s 300px wide on a 1920px desktop screen?

The media query doesn’t care; it does its job. The viewport is still 1920px, so min-width: 1024px fires and the matched query styles are applied, even though the card only has 300px of space to work with. Eventually, everything in the card deforms, overflows, or cramps up.

“Media queries are dumb. Not dumb in terms of the concept, but dumb in that they don’t know very much. In fact, most people assume that they know more than they do.”

— Kevin Powell

It’s common to think of responsive design purely as a system for updating complete page layouts, like going from two columns on a large screen to a single column on a small screen.

Container Queries Look Inward

Container queries are smarter than that. They make responsive layouts more reliant on what’s happening inside a component rather than on the outer context that has no insight into a component’s contents. It is more like: “How much space is available for me in this specific spot, right now?”

Here is the same card code example we looked at in the last section, but with a container query:

.card-wrapper {
  container-name: card;
  container-type: inline-size;
}

@container card (min-width: 450px) {
  .card {
    display: flex;
    flex-direction: row;
  }
}

This changes everything. The card isn’t influenced by the viewport; its only concern is whether the .card component’s parent wrapper has at least 450px of inline (i.e., horizontal in a left-to-right writing mode) space. If that condition is true, the component goes horizontal; if not, it goes to its default block display.

The logic works like this:

  1. When there’s enough room, both items (.flex-item) sit side-by-side, each exactly half the parent container’s width.
  2. When there is limited space, the second item wraps to the next line.
  3. Because flex-grow is active on each item, the wrapped items stretch to fill most of the parent’s width.
  4. If the item is a container itself, it detects the sudden width expansion and fires.
/* The flex parent */
.flex-layout {
  display: flex;
  flex-wrap: wrap;
}

/* Register a flex item as a container */
.flex-item {
  container-type: inline-size;
  flex: 1 1 390px; /* Grow to fill space, wrap at 390px */
}

/* Default Card Styles (narrow / side-by-side) */
.card {
  display: flex;
  flex-direction: column;
  background: #f4f4f4;
}

/* Once there's enough room for a full row */
@container (min-width: 600px) {
  .card {
    flex-direction: row;
    align-items: center;
    background: #e2f0d9;
  }
}

This works. As the parent size shrinks and the cards wrap to two lines, the card item expands, the container query fires, and applies the necessary styles.

Conclusion

At the end of the day, the core reason why container queries look incredibly similar to media queries is simply familiarity. They’re not exactly “new”, but they are way less understood and adopted than media queries. But media queries have plenty of their own limitations; otherwise, we wouldn’t need container queries to fill those gaps.

What we have is a more effective feature for detecting when a specific component’s context changes and a means for adjusting styles based on its content, as it should be when that component can exist in multiple contexts.

Building A UX ROI Case That Survives The Boardroom

Sooner or later, a CFO looks at your wireframes and asks what any of it actually does for the bottom line. Storyboards don’t answer that question, and the era when a 5-minute pitch could answer it ended, unfortunately, a while ago.

These days, if you want to win budget, buy-in, and backing for UX, the design has to be provably good for the business, not only for the people using it.

And proving that takes more than taping a dollar sign to a redesign. You have to understand how your organization defines value in the first place, how it measures that value, and how a credible line gets drawn between a design initiative and an outcome leadership already cares about.

Rather than scatter tips, this article follows one worked example the whole way through. Meridian is a mid-size B2B SaaS company, and it is entirely made up — that label matters, so it gets repeated where it counts. Its onboarding redesign carries the same figures from goal-setting through cost accounting, causal testing, and the final ROI number, because a framework only becomes tangible when the numbers connect. Every step is one you can rerun inside your own organization.

Why ROI Matters More Than Ever in UX Conversations

Companies now want clarity on what every dollar buys, and “delightful user experiences” stopped clearing that bar some time ago. I still remember a former colleague celebrating a $1 million redesign he’d gotten greenlit mostly on the strength of a couple of three.js tricks. Try that pitch in front of a finance team today and see how far the particles get you.

Executives don’t hate UX, they just hate vagueness. A pitch built on “users will find it easier” loses, every time, to the department promising 12% more sales in Q3. The difference is the one between a streamlined checkout flow that reduced cart abandonment with completed purchases up 22%, and the same work rewarded with “the QA testers like it.” One of those goes on your resume. The rest of this article is about earning the first version, with Meridian’s numbers doing the work.

When Business Goals And KPIs Don’t Exist Yet

Most writing about UX ROI makes a convenient assumption: that the organization already owns clean business goals and KPIs for you to hook your work onto. Real companies are messier than that. Plenty run on ambitions like “grow faster” or “improve the customer journey” that nobody ever broke into anything measurable, and an ROI case built on that ambiguity sounds impressive right up until somebody scrutinizes it.

So the first job is often to help the organization define what success even looks like. Interview stakeholders across departments — what does product consider a good quarter, where does customer success watch users struggle, where do sales deals stall — and listen for the themes that keep resurfacing across conversations, because those recurring themes are the company’s latent business objectives. A useful forcing function is the OKR model (Objectives and Key Results), which doesn’t tolerate vagueness.

At Meridian, the stated ambition was “improve the rate of new users’ adoption of the platform,” which you can neither design toward nor measure against. Interviews turned up the real shape of the problem. Trial users needed a median of 14 days to reach first value, most churned before getting there, and onboarding questions were burying the support queue. Out of that came an OKR with actual edges: reduce median time-to-first-value from 14 days to 7 with the use of a guided setup flow, and lift trial-to-paid conversion from 8% to 9.5%.

One warning about formalizing KPIs: Impose them from inside the UX team and leadership will suspect you’ve rigged the field in your own favor, so co-create them with whoever owns the outcome — though never at the price of accepting targets that set your team up for an uncomfortable situation. Meridian’s head of product agreed that setup-completion rate was a fair proxy for onboarding usability, and customer success signed off on time-to-first-value, a number already sitting on their own dashboard.

A KPI ladder that ends at a metric somebody already watches buys you credibility before any design work starts.
Quantifying The Full Cost Of The Investment

ROI has a denominator, and the denominator is where most UX teams go wrong. You can’t calculate a return without strategic financial planning, yet cost usually gets counted as designer salaries or consulting hours and nothing else. A finance team will find the rest whether or not you counted it, so count it first.

Direct costs are the visible ones. Meridian’s redesign ran $45,000 in design and research labor plus another $8,000 in tooling and participant incentives. Licenses for Figma, UserTesting, Hotjar, analytics platforms, research incentive spend — all of it belongs in the total, and that’s before the inevitable instances of vendor lock-in every UX team eventually faces. Engineering sits in the same column, because a UX redesign doesn’t stop at the mockup. Building the guided setup took two frontend sprints plus a QA pass, $38,000 worth, and the project generated about $4,000 of coordination overhead along the way in new syncs and shared dashboards.

The line item nearly everyone misses, and the one worth stealing from this article if you steal nothing else, is stakeholder time. Workshops, design reviews, and feedback sessions all pull senior people away from their primary work. A VP of Product spending four hours a week in UX reviews is a VP not spending those hours on roadmap planning or partner negotiations. Log the attendance — who came, for how long, at what seniority — and price it at fully loaded cost, meaning salary plus benefits divided by productive hours. A quarter’s worth of workshops, reviews, and interviews at Meridian priced out at $22,000.

Add it all up: $45,000 in design labor, $8,000 in tooling, $38,000 in engineering, $22,000 in stakeholder time, $4,000 in coordination. The investment is $117,000. Saying that number out loud beats saying “we spent $45K on design,” precisely because it already includes everything a finance team would have dug up on its own.

Proving Causation, Not Just Correlation

Most UX ROI pitches die right here. Conversions rose after the redesign, sure — and the CFO wants to know how you ruled out the new pricing, the seasonal traffic bump, and the marketing campaign that shipped the same week. Without a convincing answer, your entire ROI story crumbles.

After all these years, the gold standard for proving causation is still A/B testing: run the old experience against the new one on an even traffic split until the sample means something.

Onboarding happens to suit a phased rollout, which is why Meridian could do this cleanly. For eight weeks, half of new trial signups received the redesigned guided setup while half stayed on the legacy flow. Control converted to paid at 8.0%. The variant came in at 9.4%. With roughly 6,100 trials inside the window, the difference was statistically significant, but a 1.4-point gap on a single test is still the kind of result that deserves a second look before anyone builds a budget on it, which is one reason the team held back on attribution below. Where a split isn’t feasible — a change too structural, a user base too small — fall back to a time series instead. Measure steadily for weeks before the change, implement, then keep measuring against the baseline you established.

Documenting whatever else happens around the same time as your UX change is the unglamorous half of causation.

A pricing-page test from Meridian’s marketing team overlapped weeks five through eight of the rollout. The UX team noted it, confirmed it hit both cohorts evenly, and still chose to attribute only 70% of the observed lift to the redesign in the final math. There is no formula that produces that number; treat it as an illustrative assumption for this example.

The team asked how much of the lift could plausibly belong to the pricing test if it had helped one cohort slightly more than the other, settled on a ceiling of about a third, and rounded the redesign’s share down to 70%. Your figure will differ. What matters is that it is written down and argued for before the results arrive, not fitted to them afterwards. That restraint is worth money in a skeptical room. “We attribute roughly 70% of the lift to the onboarding change, with the remainder likely influenced by concurrent pricing work” survives cross-examination; claiming everything does not. Cohort analysis then backed the number up, since the lift held across acquisition channels and tenure bands, and at that point the skeptics had very little left to work with.

Leading and lagging indicators belong on the same slide, because each covers the other’s weakness. Meridian’s leading indicators moved first — setup completion climbed from 62% to 89%, median time-to-first-value dropped from 14 days to 6.5 — and the lagging trial-to-paid number followed. Mechanism first, business outcome second. Presented together, they form a causal chain that’s harder to poke holes in than either one alone.

The ROI Calculation, End to End

So what did Meridian actually earn? The company sees about 40,000 trial signups a year. Lifting conversion from 8.0% to 9.4% adds roughly 560 paying customers annually, and at an average of $1,800 in annual recurring revenue per account, those customers represent about $1,008,000 in new ARR. Applying the conservative 70% attribution from the causal work trims the defensible figure to roughly $706,000.

Set that against the full $117,000 investment and the first-year ROI lands near 5:1, with payback arriving in roughly two months. There’s a second line, too. Onboarding-related support tickets dropped about 30%, some 3,600 fewer tickets a year, worth another $54,000 annually at $15 per resolved ticket. Keep it as its own line rather than folding it into one swollen headline number. The case reads as more honest that way and loses none of its force.

Three assumptions carry that result, and each belongs on the slide next to it. The 40,000 signups and the $1,800 average ARR are the prior year’s actuals held flat, so a growth or pricing change moves the outcome in either direction. The 70% attribution is the illustrative assumption from the causal work, not a measured quantity. And the two-month payback counts new ARR as it lands rather than revenue recognized net of churn, which flatters the timeline; on a net basis the payback stretches to roughly a quarter. State those three plainly and a finance team can adapt the example to its own numbers. Hide them and the whole thing starts to look like marketing math, however careful the experiment was.

What persuades in the final presentation is not sophistication. Open with the baseline: what stalled trials and support volume were already costing. Show the delta in terms leadership reads fluently, metrics like conversion rate uplift chief among them. A chart of setup completion climbing from 62% to 89% will beat a paragraph of UX jargon, and a translation like “each abandoned setup costs us 0.3 support tickets” beats the chart. Above all, keep every figure identical from the first slide to the last. A room full of finance people forgives many things, but never numbers that wobble between slides.

Tailoring The Case To Whoever Holds The Purse Strings

Budget decisions come out of coalitions. A CFO may hold the final say when adding AI to the checkout process, but marketing, product, and customer success all lean on that decision, and each means something different by “value.”

A CFO hears cost, revenue, and risk. A CMO hears conversion and acquisition cost, since UX is a lever for increasing marketing ROI. Product counts support tickets; customer success thinks in retention. The underlying numbers never change; only the framing rotates, and a CFO wants a projection, not a moodboard. Meridian’s CFO slide read “the onboarding redesign protects roughly $706,000 in new ARR a year against a $117,000 investment,” while the CMO version led with what a 9.4% trial conversion does to blended acquisition cost.

Beyond the Dollar Sign: Qualitative and Non-Financial Metrics

Some UX outcomes never translate cleanly into revenue, and pretending they do weakens the parts of your case that are solid.

The trick with qualitative evidence is collecting it rigorously enough that nobody can wave it off as anecdote.

Scores like Net Promoter Score (NPS), CSAT, and Customer Effort Score already sit inside most reporting cadences, which makes them cheap to borrow. Tie your work to their movement, and segment wherever the data allows.

Meridian could say that NPS among trial users on the redesigned onboarding was 51 against 34 for the legacy flow, which lands far harder than any blended average. Verbatim feedback from surveys, support transcripts, and app store reviews adds the emotional weight the scores lack. Internal tools deserve the same discipline, since employee experience is increasingly recognized as a business driver — a dashboard redesign that hands account managers 45 minutes a day back is a productivity gain, a satisfaction gain, and a retention lever all in one.

Brand perception resists direct measurement but leaves tracks in repeat visits, organic referrals, and social sentiment. It carries extra weight in trust-sensitive industries like finance or healthcare, and it forms fast, given that UX design influences the first impressions of a whopping 94% of customers.

Whatever you collect, systematize the collecting. Run pre- and post-surveys with consistent question sets, use structured usability testing with task-based scoring, and put the qualitative right next to the quantitative when you present.

“Setup completion rose from 62% to 89%, and in post-test interviews 8 of 10 participants called the new flow intuitive, against 3 of 10 for the old one” — a pairing like that is much harder to dismiss than either half on its own.
Making the Case Stick

UX loses the budget battle unless it’s mapped to company-wide objectives, so phrase the proposal in the words of this year’s board presentation.

Nobody at Meridian pitched “simplify the onboarding UI”; the pitch was a redesigned trial experience worth 1.4 points of upgrade rate, roughly $1M in annual recurring revenue before attribution. Bring evidence in both registers, since that is what social proof is for: the case, clearly labeled, plus screenshots, impact graphs, and user quotes. Find internal allies who can repeat the ROI narrative in rooms you’ll never enter, and write the playbook down, because repeatable ROI is what earns recurring investment.

Resources for Going Deeper

This topic has been explored extensively by researchers, practitioners, and consultancies. Here’s a curated set of resources worth studying if you want to build a stronger ROI practice around UX.

  • “Measuring the User Experience” by Tom Tullis and Bill Albert is the definitive guide to UX metrics. It covers everything from task-based measurements to survey design to statistical analysis, and it’s written for practitioners, not academics.
  • Jared Spool’s “The $300 Million Button” case study is a classic example of how a single UX change (removing a mandatory registration step) generated massive revenue uplift. It’s a story every UX professional should have in their back pocket.
  • Forrester’s research on UX ROI provides enterprise-focused frameworks for building business cases around experience design, including their widely cited finding that every dollar invested in UX returns $100.
  • “UX Strategy” by Jaime Levy bridges the gap between design thinking and business strategy, offering practical tools for aligning UX initiatives with organizational goals and market positioning.
  • The Design Value Index by the Design Management Institute tracks publicly traded companies that invest heavily in design against the S&P 500. The data consistently shows that design-led companies outperform the index by significant margins, and it’s a powerful data point for executive presentations.
  • Google’s HEART framework provides a structured approach to selecting UX metrics at scale. HEART stands for Happiness, Engagement, Adoption, Retention, and Task success, and it’s particularly useful for teams that struggle to decide which metrics to track.
Conclusion

A seat at the table never comes from beauty or novelty. It comes from measurable, defensible impact, which means UX leaders have to trade the artist’s posture for the strategist’s. Speak in outcomes rather than outputs. Connect pixels to profit.

When someone challenges the numbers, don’t flinch. Show the controlled experiment, the cohort analysis, and the before-and-after metrics, every figure holding steady from the first slide to the last, the way Meridian’s did, with the customer quotes and the employee-satisfaction data sitting right beside the revenue impact. Prove the work does more than delight users, and be ready to defend the ratio line by line. That’s when the CFO leans in, and that’s when design stops being optional.

The Death Of The Button: Why The Best Interface Is No Interface

Ever since the commercialisation of the Graphical User Interface pioneered by systems like the Xerox Star and popularised by the original Apple Macintosh, software has relied heavily on point-and-click interactions. If you wanted to book a trip, buy a pair of shoes, or research a health symptom, you were expected to navigate a labyrinth of user interfaces. You click menus, adjust range sliders, fill out multi-step forms, deal with cookie pop-ups, and open dozens of browser tabs just to cross-reference basic information. We have become accustomed to spending more time managing the software rather than actually achieving our goals.

That contract is officially changing. Driven by advances in artificial intelligence and large language models, a new generation of web tools is pioneering a radical philosophy: Intent-Driven Design. Rather than expecting our users to learn complex menus and click through elaborate sales funnels, these platforms operate by capturing high-level human goals and silently executing the grunt work in the background.

This vision builds on long-standing HCI concepts like Golden Krishna’s “The Best Interface Is No Interface” and Don Norman’s principles of human-centered design.

The ultimate goal of modern web design is no longer to build prettier buttons or flashy animations; it is to eliminate the interface entirely.

Well, at least what we understand based on our current experience.

It is essential for UX designers to understand the changes we’re witnessing and even re-evaluate our role, shifting our focus from designing visible interfaces to guiding transparent, intent-driven AI experiences.

The Death Of The “10-click” Process

To understand where web design is going, we first have to look at the friction we have accepted as “normal” for decades.

Consider the traditional workflow of buying a flight online. The user experience is intentionally hyper-interactive:

  1. Navigate to a travel aggregator or airline website.
  2. Select “Round Trip” from a dropdown menu.
  3. Type the origin city and wait for auto-complete.
  4. Type the destination city and wait for auto-complete.
  5. Click a calendar modal, toggle through months, and select departure and return dates.
  6. Choose the number of passengers and cabin class.
  7. Click “Search” and wait for the results page to load.
  8. Filter by price, layover duration, departure time, and airline.
  9. Sort the results and scan through dozens of individual options.
  10. Click through a three-page checkout funnel dodging upsells for rental cars and travel insurance.

This is a classic point-and-click UI paradigm. The computer acts as a passive container of data, and the human acts as the orchestrator, manually inputting parameters, interpreting raw outputs, and executing each micro-step along the way.

Intent-driven design flips this dynamic entirely. Instead of forcing you to navigate the mechanical steps of how to find a flight, the interface asks a simple question: What are you trying to accomplish?

When you express a goal, such as “Find me a non-stop flight to Chicago next weekend under $300 that arrives before 5 PM”, the software reads your intent, executes the multi-step search query behind the scenes, compares the options, and presents a single actionable resolution. The ten clicks dissolve into one clear intent outcome.

Three Web Platform Examples Replacing Buttons With Intent

This shift isn’t a theoretical vision of the distant future. Some of the world’s most accessible websites allow you to experience intent-capturing systems already.

1. Perplexity AI: Search Without The Open Tabs

Traditional search engines like Google were built as directories. You typed a keyword, and the interface rewarded you with ten blue links. The actual work of opening five tabs, skimming long articles, dodging ads, and manually assembling an answer was left to you. Although this is now changing, with AI content appearing first when you search on Google.

Perplexity AI allows anyone to perform instant intent-based searches. Instead of forcing you to click into multiple tabs, the interface synthesises the perfect result for your context.

  • The interaction: You ask a complex question in plain English: “Compare the top three budget laptops for a computer science student, focusing on battery life and keyboard quality.”
  • The invisible work: In under two seconds, the platform searches the web, reads dozens of articles, evaluates hardware specifications, and cross-references user reviews.

  • The result: (See screen above) Instead of throwing web pages at you, Perplexity dynamically generates a single custom answer complete with formatted comparison tables, pros and cons lists, and concise inline citations. You get the outcome of thirty clicks in just one.

2. Vercel v0: Web Design Without Dragging And Dropping

For years, creating a website meant using visual builders like Figma or drag-and-drop web editors. As designers, we spent hours manually drawing rectangles, picking hexadecimal colour codes, adjusting padding values, and sometimes writing CSS code.

Vercel v0 lets anyone test its generative interface builder right from the home page without signing in.

  • The Interaction: A user types a descriptive goal into the input prompt: “Create a modern dark-mode dashboard for a subscription SaaS app showing monthly revenue, active users, and a customer churn chart.”
  • The invisible work: The underlying AI understands layout principles, accessibility guidelines, UI component libraries, and responsiveness. It writes clean HTML, Tailwind CSS, and React code in real time.
  • The result: Rather than spending an afternoon manipulating elements, the user receives a fully functional, pixel-perfect user interface in seconds! The traditional visual design tool disappears, replaced by raw human intent.

3. Goblin.tools: Breaking Down Overwhelming Tasks

Many traditional productivity tools require you to manually construct task lists, drag items across Kanban boards, and assign micro-deadlines. Goblin.tools is a free, single-page suite of single-task AI tools designed specifically for neurodivergent users or anyone feeling overwhelmed, requiring zero sign-ups or configuration.

  • The interaction: You enter a vague, intimidating goal into the Magic Todo tool, such as “Prepare for a job interview”.
  • The invisible work: Instead of forcing you to plan every step, the system analyses the cognitive load of the goal and automatically breaks it down into small, actionable sub-tasks adjusted to your preferred level of detail.
  • The result: The interface eliminates the stressful task-planning phase and presents a clean checklist tailored to your exact goal.

The Core Pillars Of Intent-driven Web Design

When you remove traditional menus, sidebars, and forms, how do you keep a website usable? Designers pioneering this space rely on three core pillars:

Pillar Traditional UX approach Intent-driven UX approach
User input Micro-actions (Clicks, dropdowns, toggles) 1. High-level goals (Natural language, context, habits)
Interface state Static layouts (Everyone sees the same page) 2. Generative UI (Layouts created dynamically on the fly)
Task execution Manual execution by the user 3. Autonomous execution by background AI agents

1. High-level Goals

An invisible interface doesn’t always wait for you to type a command — it leverages context to anticipate user needs. Guided by industry standards like Apple’s Human Interface Guidelines on Contextual & Ambient Design, modern systems read environmental metadata, such as device state, location, and past interaction patterns, to trigger proactive actions.

For example:

  • Time and location: A food delivery web app prioritising your saved home address and dinner items automatically at 6:30 PM on a weekday.
  • Cross-app history: A calendar application noticing an email about an upcoming appointment and surfacing a one-click “Add to Schedule” card without forcing you to copy and paste event details manually.

2. Generative UI

In traditional web design, every user sees the exact same layout. An e-commerce store shows the same navigation bar whether you are a first-time visitor looking for customer support or a returning customer tracking a package.

As highlighted in the Nielsen Norman Group’s analysis on AI as a new UX paradigm, computing is shifting from command-based interaction to outcome-specification. This enables Generative UI, where interfaces are rendered dynamically on the fly based on what you are trying to do in that exact moment. For example, platforms like Vercel v0 demonstrate how raw intent can instantly render functional code components without manual layout building. If you express a desire to compute complex financial data, the interface generates a dynamic calculator widget on demand, receding once your goal is completed.

3. Execution by AI Agents

Traditional interfaces are obsessed with prevention, constantly peppering users with confirmation pop-ups (“Are you sure you want to delete this file?”).

Intent-driven interfaces adapt Jakob Nielsen’s 10 Usability Heuristics on User Control and Error Recovery by shifting the safety net from prevention to easy reversibility. Because autonomous agents take actions on your behalf, products prioritise frictionless rollback mechanisms. A prominent “Undo” button, simple revision prompts (“Make this summary shorter”), and transparent audit logs replace intrusive warning modals.

The Hidden Risks

While removing interface friction is liberating, stripping away visual controls introduces significant product design challenges. When software acts on inferred intent rather than direct point-and-click commands, designers must navigate critical ethical and technical pitfalls.

The Illusion Of Control

When a website makes decisions for you, it can quickly feel patronising or invasive. As explored by the Stanford Human-Computer Interaction (HCI) Group, automation must maintain clear boundaries to prevent user frustration. Furthermore, ethical frameworks from the Center for Humane Technology emphasise that product designers must guard against manipulative defaults.

Designers must strike a delicate balance: automate routine execution, but explicitly prompt the user for high-stakes confirmations (such as financial transactions, publishing public content, or altering privacy settings).

The Black Box Problem

In a traditional UI, if you get an unexpected result, you can usually diagnose the issue — perhaps you checked the wrong filter box or selected an incorrect date.

With an intent-driven interface, troubleshooting becomes harder. To address this “black box” challenge, the Google PAIR (People + AI Research) Guidebook advocates for transparent feedback loops. The system must explicitly state its interpretation (“Searching for non-stop flights to Chicago under $300...”) so users can calibrate trust and correct misinterpretations instantly.

From A UX Perspective

As a UX designer, always being curious to understand how our design approach is changing in the world of AI, I find it essential that we re-evaluate the foundational elements of our craft.

Rather than designing static buttons and rigid forms, we need to learn to map and present dynamic, generative UI components that adapt on the fly to user intent.

By mastering these evolving patterns, like ambient feedback, inline prompts, and transparent AI status indicators, we can ensure that screenless, agent-driven tools remain intuitive, ethical, and deeply human-centered.

Conclusion
The ultimate goal: The best design is no design.

For decades, the digital industry has evaluated software success through engagement metrics like time spent in app, click-through rates, and page views per session. Websites were deliberately engineered to maximise visual engagement and interaction volume.

The philosophy behind Golden Krishna’s seminal book The Best Interface Is No Interface, aligned with the broader Center for Humane Technology’s Time Well Spent movement, turns these metrics on their head. The ultimate test of a modern digital product is no longer how visually captivating its buttons are, but rather: How effectively did this software solve the problem and get out of the user’s way?,

We are entering an era where web applications will no longer be measured by the beauty of their interfaces, but by their ability to render those complex interfaces completely obsolete. The future of the web isn’t more interaction — it is seamless, invisible completion.

The Many Faces Of September (2026 Wallpapers Edition)

For more than 15 years already, our monthly wallpapers series has been the perfect opportunity for creatives of all backgrounds to put their skills to the test. You don’t have to meet stakeholder or client requirements; for a change, it’s just you, exploring your ideas and bringing them to life in your own, unique style. Since we first embarked on this wallpapers journey, so many talented folks from all across the globe have accepted the challenge, and this September is no exception.

Created with love by the community for the community, all the wallpapers in this collection come in a variety of screen resolutions and can be downloaded for free. A huge thank-you to everyone who tickled their creativity and shared their designs with us — this post wouldn’t be possible without your kind support!

If you’d also like to be featured in one of our upcoming wallpapers posts, please don’t hesitate to join in. We can’t wait to see your story come to life! Happy September!

  • You can click on every image to see a larger preview.
  • We respect and carefully consider the ideas and motivation behind each and every artist’s work. This is why we give all artists the full freedom to explore their creativity and express emotions and experience through their works. This is also why the themes of the wallpapers weren’t anyhow influenced by us but rather designed from scratch by the artists themselves.
Welcome Autumn

“That crisp, golden shift in the air when the first fallen leaves begin to blanket the streets of Novi Sad always brings a quiet transition into a slower rhythm. The goal was to capture that cozy, enveloping feeling of the changing seasons through a simple illustration, the way a woodland canopy naturally forms an archway, framing the workspace in rich amber, rust, and deep burgundy.” — Designed by Popart Studio from Serbia.

September On Repeat

Designed by Ricardo Gimenes from Spain.

A Stream Of Consciousness

Designed by Ricardo Gimenes from Spain.

Autumn Rains

“This autumn, we expect to see a lot of rainy days and blues, so we wanted to change the paradigm and wish a warm welcome to the new season. After all, if you come to think of it: rain is not so bad if you have an umbrella and a raincoat. Come autumn, we welcome you!” — Designed by PopArt Studio from Serbia.

Funny Cats

“Cats are beautiful animals. They’re quiet, clean, and warm. They’re funny and can become an endless source of love and entertainment. Here for the cats!” — Designed by UrbanUI from India.

Terrazzo

“With the end of summer and fall coming soon, I created this terrazzo pattern wallpaper to brighten up your desktop. Enjoy the month!” — Designed by Melissa Bogemans from Belgium.

Summer Ending

“As summer comes to an end, all the creatures pull back to their hiding places, searching for warmth within themselves and dreaming of neverending adventures under the tinted sky of closing dog days.” — Designed by Ana Masnikosa from Belgrade, Serbia.

Cacti Everywhere

“Seasons come and go, but our brave cactuses still stand. Summer is almost over and autumn is coming, but the beloved plants don’t care.” — Designed by Lívia Lénárt from Hungary.

Flower Soul

“The earth has music for those who listen. Take a break and relax and while you drive out the stress, catch a glimpse of the beautiful nature around you. Can you hear the rhythm of the breeze blowing, the flowers singing, and the butterflies fluttering to cheer you up? We dedicate flowers which symbolize happiness and love to one and all.” — Designed by Krishnankutty from India.

Stay Or Leave?

Designed by Ricardo Gimenes from Spain.

Listen Closer… The Mushrooms Are Growing

“It’s this time of the year when children go to school and grown-ups go to collect mushrooms.” — Designed by Igor Izhik from Canada.

Who

Designed by Ricardo Gimenes from Spain.

Hungry

Designed by Elise Vanoorbeek from Belgium.

Maryland Pride

“As summer comes to a close, so does the end of blue crab season in Maryland. Blue crabs have been a regional delicacy since the 1700s and have become Maryland’s most valuable fishing industry, adding millions of dollars to the Maryland economy each year. The blue crab has contributed so much to the state’s regional culture and economy, in 1989 it was named the State Crustacean, cementing its importance in Maryland history.” — Designed by The Hannon Group from Washington DC.

Lucha Libre

“This month is Mexico’s independence day and I decided to illustrate one of the things Mexico’s best known for: the Lucha Libre.” — Designed by Maria Keller from Mexico.

A Cozy Evening

“The leaves are changing their colors now, but the nights are still warm. There’s something different tonight… do you feel it? It’s like the air tastes like a soft marshmallow and you’re sitting by a warm fire in the middle of the forest, while the nature that surrounds you is transforming. It’s ok, small changes are normal and all you can do is sit back, look at the stars, and embrace the world that evolves around you.” — Designed by Creative Pinky from the Netherlands.

Go Bananas

Designed by Ricardo Gimenes from Spain.

Summer Is Leaving

“It is inevitable. Summer is leaving silently. Let us think of ways to make the most of what is left of the beloved season.” — Designed by Bootstrap Dashboards from India.

Still In Vacation Mood

“It’s officially the end of summer and I’m still in vacation mood, dreaming about all the amazing places I’ve seen. This illustration is inspired by a small town in France, on the Atlantic coast, right by the beach.” — Designed by Miruna Sfia from Romania.

Rainy Flowers

Designed by Teodora Vasileva from Bulgaria.

Colors Of September

“I love September. Its colors and smells.” — Designed by Juliagav from Ukraine.

Finding Jaguar

“Nature and our planet have given us life, enabled us to enjoy the most wonderful place known to us in the universe. People have given themselves the right to master something they do not fully understand. We dedicate this September calendar to a true nature lover, Vedran Badjun from Dalmatia, Croatia, who inspires us to love our planet, live in harmony with it and appreciate all that it has to offer. Amazon, Siberia, and every tree or animal on the planet are treasures we lose every day. Let’s change that!” — Designed by PopArt Studio from Serbia.

Early Autumn

“September is usually considered as early autumn, so I decided to draw some trees and leaves. However, nobody likes that summer is coming to an end, that’s why I kept summerish colors and style.” — Designed by Kat Gluszek from Germany.

Bear Time

Designed by Bojana Stojanovic from Serbia.

National Video Games Day Delight

“September 12th brings us National Video Games Day. US-based video game players love this day and celebrate with huge gaming tournaments. What was once a 2D experience in the home is now a global phenomenon with players playing against each other across statelines and national borders via the internet. National Video Games Day gives gamers the perfect chance to celebrate and socialize! So grab your controller, join online, and let the games begin!” — Designed by Ever Increasing Circles from the United Kingdom.

September Vibes

“On September 1st, the first day of school in our country, schoolchildren across Serbia would write about what autumn feels like in their neighborhood. Usually, it’s the imagery of fallen leaves rustling under the feet, foggy and chilly mornings with the sun breaking between the murky clouds, a muffled sound of a chainsaw cutting firewood somewhere in the distance, the smells of fruits and vegetables being prepared for home canning. Autumn is the season of serenity, quietness, and reflection.” - Designed by PopArt Studio from Serbia.

Geometric Autumn

“I designed this wallpaper to remind everyone that autumn is here.” — Designed by Advanced Web Ranking from Romania.

Long Live Summer

“While September’s Autumnal Equinox technically signifies the end of the summer season, this wallpaper is for all those summer lovers, like me, who don’t want the sunshine, warm weather, and lazy days to end.” — Designed by Vicki Grunewald from Washington.

No More Inflatable Flamingos

“Summer is officially over and we will no longer need our inflatable flamingos. Now, we’ll need umbrellas. And some flamingos will need an umbrella too!" - Designed by Marina Bošnjak from Croatia.

Never Stop Exploring

Designed by Ricardo Gimenes from Spain.

Get Featured Next Month

Feeling inspired? We’ll publish the October wallpapers on September 30, so if you’d like to be part of the collection, please don’t hesitate to submit your design. We are already looking forward to it!

Rethinking Data Visualisation: A UX Approach To Dashboards That Actually Drives Decisions

In organisations today, data has never been more available. Dashboards and performance decks exist for almost every function — sales, product, marketing, operations — and the tools to build them have never been more accessible. And yet, in weekly standups and quarterly reviews, the same thing happens constantly: someone shares the numbers, the room nods, and the meeting ends without a decision or clear direction.

When that happens, the data usually takes the blame. The numbers weren’t granular enough, the dataset wasn’t complete, we need more information before we can act. But the data is almost never the problem. The reality is that nobody designed it to deliver insights. The chart was built from what was available, not from the question that needed answering. The audience was assumed rather than understood, and what should actually change as a result of seeing this data — that question — was never asked at all.

Data visualisation and UX are solving the same underlying problem: both are trying to move the right information to the right person in a way that changes something. The vocabulary is different, but the underlying challenge is identical, and the moment you start treating them as complementary disciplines is the moment dashboards stop being a passive collection of charts and start doing something functional.

For designers who work with data, analysts who present to non-technical audiences, and marketers who need their numbers to do more than sit in a slide, this read is for you.

The Chart Was Never The Whole Story

In 1973, the statistician Francis Anscombe (PDF) published a paper that made a quiet but clarifying point. He constructed four datasets that are statistically identical: same mean, same variance, same correlation coefficient, and same regression line. Run the numbers on any of them, and they are identical. Plot them, and they could not be more different.

Anscombe’s lesson to statisticians was about diagnosis: visualisation reveals the operational truth that raw numbers conceal.

But visualisation isn’t just diagnostic; it is also communicative. The form you choose is where understanding either emerges or gets lost in the noise. Does your audience walk away with numbers, or with a story they’ll quote and talk about?

One of the most striking examples is Visual Capitalist’s History of Pandemics. Instead of burying the reader in a massive data table of casualty counts, it maps the death toll of major historical pandemics using a proportional bubble layout on a single timeline.

Before your brain reads a single number, your visual system grasps the sheer scale of the Black Death relative to everything else on the page. The right visualisation does not just plot the data but makes the story impossible to miss.

Edward Tufte codified a foundational principle for the craft with his data-ink ratio: every mark on a chart should serve the data, not decorate it. It remains a widely used framework in data visualisation, anchored in the assumption that clarity and visual hygiene are the goal.

For a chart in isolation, that holds. But a chart is never read in isolation: it’s read by a person, in a specific context, under specific pressure. Strip a chart down to its cleanest form, and you might be removing the exact layer of context a decision-maker needs. Simplicity isn’t the goal in itself; appropriate complexity is.

Data is a message, and the right amount of signal depends entirely on who’s receiving it.

Which leads to the core principle of data UX: roughly 80% of the work that determines whether a dashboard succeeds happens before you ever draw a chart.

That dependency is the thread the rest of this piece pulls on.

The 80% That Happens Before The Chart

The high-leverage 80% almost never happens on screen. It happens upstream: before a tool is opened, before a dataset is pulled, before a single design choice is made. It comes down to three questions, and once they become habitual, they change what you notice, what you ask, and what you push back on at the outset of every project.

  1. Context: What are we trying to show with this data?
    This is where you define what the visualisations actually need to serve before you touch any raw data. Writing down the precise operational questions, specifically enough to determine what gets pulled and what gets filtered, is what produces a dashboard that helps with decision-making.
  2. Audience: Who is this for, and how do they think?
    This is the empathy step. Knowing who’s in the room, what they’re accountable for, and how they engage with data determines how much complexity the visualisation can carry, and how it should be presented.
  3. Insight: What should change once this data lands?
    A decision, a new direction, a shift in understanding. If the intended strategic outcome isn’t clear during the design phase, it will remain invisible once the dashboard goes live.
Context: What Are We Trying To Show With This Data?

Most data-heavy projects start backward: teams pull whatever metrics their internal analytics tools already track and build visualisations around them, while the question the data was supposed to answer either gets assumed or never gets asked. This happens simply because we anchor on the data in front of us as the boundary of what’s possible.

Defining a goal first sounds obvious, but in practice, it rarely happens with the necessary clarity. “Show me how the product is performing” is not a goal; “Identify which features drive retention among users who signed up in Q1” is, as it includes three things the first doesn’t: a metric, a population, and an implied action. That specificity is what converts an open-ended exploration into a constrained, answerable design problem. Which one you start from determines everything that follows: what you include, what comparisons matter, and what you leave out entirely.

Starting with available data produces a dashboard that answers no particular question, because it was never built for one — every number is present, none of them pointed anywhere. Starting with the operational question does the reverse: every element on the screen earns its place, because each one is there to help answer it.

For example, consider a UX team trying to fix a leaky checkout flow for an e-commerce website. A data-first approach pulls everything available, from clicks to scroll depth and device types, yielding a massive dashboard that leaves everyone asking, “Okay, but what do we actually change?” A context-first approach starts with a constraint: “At which step of the checkout do users drop off?” By filtering out 90% of the noise, the team builds a simple funnel chart, instantly spots a bottleneck on the payment screen, and knows exactly what to redesign.

Audience: Who Is This For, And How Do They Think?

Designing for an audience comes down to two things: accountability and familiarity.

Familiarity is about data literacy. Do they read charts instinctively, or does a complex visualisation create friction? Handing a dense, multi-layered dashboard to a Head of Sales and a senior analyst is like giving the same map to someone who navigates by landmarks and someone who reads grid coordinates. The data is accurate, but it is only functional for one of them.

Accountability dictates how that complexity must be presented. A chart showing a 12% decline carries vastly different weight for the executive responsible for that number versus the analyst simply reporting it. Understanding your audience means grasping this relationship; data is never processed neutrally when your performance is on the line.

Together, familiarity and accountability decide one practical thing: how much you can put in front of someone.

In data visualisation, simplicity is not a fixed virtue — the right level of it is contingent on who is reading, and what they need to do.

An analyst relies on a high-density environment to conduct diagnostic discovery. By isolating individual behaviour nodes and mapping out raw user flows, they interrogate the data at its atomic level to uncover the hidden insights and underperforming spend that will shape future campaigns.

An executive, by contrast, requires a highly synthesised translation of that data to immediately identify what is driving commercial growth. Tailoring a dashboard to your audience means adjusting the density dial, delivering maximum signal with appropriate complexity for the specific brain in the room.

Insight: What Should Change Once This Data Lands?

Most data projects operate on the comfortable assumption that if a chart is accurate and clear, the insight will take care of itself. In reality, information and insight are entirely different states. Information is what the data shows, whereas insight is the specific decision, shift in understanding, or course correction someone makes as a result of seeing it. If the intended business change isn’t defined before the design begins, a dashboard will default to passive reporting rather than driving action.

Marketing and engineering teams experience the danger of this gap whenever a core business metric suddenly plummets.

A dashboard built for information simply sounds the alarm, showing a chart that tracks a sharp 15% drop in booking rates. Because the data lacks depth, leadership defaults to panic: they immediately call the UX design team, assuming the app is broken or the checkout flow is flawed. Because the data doesn’t pinpoint the core of the problem, it triggers a costly, misplaced fire drill.

A dashboard built for insight isolates the variables required to make an informed decision. Instead of a single, flat booking metric, the visualisation maps the drop against traffic sources and campaign launches — instantly revealing that while app performance and core user conversion are perfectly stable, the sitewide rate was artificially diluted by a massive influx of low-intent click traffic from a newly scaled campaign. The team doesn’t waste time redesigning a functioning app; they get the exact insight needed to pause the underperforming marketing campaign and adjust their acquisition strategy.

Every visualisation implies a next step, even if that step is “nothing needs to change right now.” The question is whether the design makes that implication clear enough for the viewer to recognise it.

From Questions To Dashboard: A Project Walk-through

My aha moment in data visualisation happened during a project for a client-facing B2B SaaS platform focused on enterprise talent management and competency tracking in Pegasystems skills. The platform captured a massive footprint of daily telemetry, and the brief arrived open-ended: “We have an immense archive of user activity, now we need to present it to enterprise teams.”

We could very easily have charted everything that was captured, but we wouldn’t be doing end users any favours if they just ended up looking at a data graveyard. My responsibility immediately moved beyond pure interface craftsmanship; it became about architecting a highly practical tool for real people who would open this dashboard routinely and need it to tell them an honest, immediate story about their workflows.

Here is how the project actually went.

Context

The client believed this massive pool of data could help their users perform better, and wanted an interface that finally enabled that growth. Translating that broad ambition into tangible visualisations required defining the practical mechanics of performance. What variables indicate advancement vs passive usage? What does “perform better” actually mean? How do you measure it?

An obvious candidate was time spent by product. Every platform tracks it. It is easy to show, and it feels meaningful. But time spent is a proxy; it tells you someone was there, not whether they got anything out of it.

The more meaningful signals were competency scores by area, certification completion rates, and historical performance trajectories. Integrating time-spent data alongside these performance metrics added a useful layer of interpretation, helping us surface which modules users were underutilising and whether that directly correlated with lagging scores. Time spent became a supporting signal in the larger story.

The second question was about the appropriate level of granularity. An identical metric carries completely different weight depending on who is looking at it. An individual contributor tracking their own completion rate needs to know if they are pacing correctly, whereas a manager reviewing a team aggregate needs to know precisely who requires immediate support. This distinction shaped every subsequent data-exposure and filtering decision. Defining that structural story early determined exactly what to show, and to whom.

Audience

The most straightforward approach to this design would have been predictable: use the same charts, but offer an individual view and an aggregated team view. Far too many dashboards rely on this shortcut, subtly tweaking the scale of identical data visualisations and labelling it “personalisation.”

An authentic analysis of the audience reveals a much deeper rift. Frontline team leads and individual contributors required distinct narrative structures and design principles.

Having used e-learning platforms myself, I remember the frustration of opening a tool without a clear sense of my current standing, core strengths, or slipping metrics. That personal experience directly guided the individual contributor workspace; it needed to act as a highly tailored, self-directed mirror that was granular, honest, and personal.

Conversely, the manager’s interface had to bypass individual milestones initially to provide a macro pulse check on team vulnerabilities. It was designed around a different operational reality: how is the group progressing, and where are the consistent gaps? The view prioritised the aggregate picture first, while retaining an intuitive path to drill down into tactical day-to-day coordination when needed.

Insight

Our insight strategy was locked in during the early conceptual phase, long before wireframing a single chart. We intentionally abandoned the idea of building a dense, passive data log and focused on pacing the narrative arc.

For individual contributors, the core value was self-direction, ensuring they could glance at the interface on a Monday morning and immediately derive a clear priority list for the week ahead.

For managers, the goal was to fundamentally shift the timing of operational conversations, providing them with the necessary baseline to intervene before a skill gap evolved into a critical project failure. The visualisations needed to surface the exact moments when a human check-in would be useful, shifting their workflow from reactive post-mortems to proactive guidance.

The comparison tool was the highlight nobody had asked for. A manager dashboard and an individual dashboard are easy to anticipate. What is harder to land is: what if a manager wants to compare two specific team members against the same metrics, side by side? That view came from a design assumption, and it turned out to be the feature that resonated most.

The decisions that mattered most in this project weren’t in the initial brief — capturing data they hadn’t thought to request, and structuring it to answer questions they had not previously known how to articulate, which is the core differentiator of a user-centric data strategy.

Designing The Mental Model Early

The choice of visualisation layout must follow the geometric nature of the data itself. For this project, the core design problem was enabling an individual user to answer a specific question at a single glance: across eight distinct competency areas, where are my relative strengths and gaps?

To solve this, we mapped the data using a radar chart. By organising multiple variables across axes radiating from a central point using polar coordinates, the interface connects the data points to form a single, unified shape. An even, balanced polygon instantly signals well-rounded proficiency, while a sharply skewed shape draws the eye immediately to an outlier area.

While a traditional linear bar chart would have forced the viewer to scan eight individual bars and mentally calculate the variance, a concentric, radial layout segments the data layers to make progress tracking and skill gaps immediately readable. When all dimensions share an identical scale and scoring method, the radar chart is not an unconventional aesthetic choice — it is the most functional tool for multi-dimensional analysis.

The colour system was the other decision made early, and I mean early. During the branding exercise, each of the three products was assigned a colour. That colour did not stay in the brand guidelines. It was built into the data model from the beginning, running consistently across every chart, every filter, every breakdown. By the time a user landed on the dashboard for the first time, the mental model was already in place. They had not been taught the language. They already knew it.

What Changed

The shift from passive information to active insight showed up first in how the dashboard was actually used. Following the deployment of the personalised dashboards and side-by-side team comparison tools, weekly active engagement on the platform’s analytics features rose noticeably, per internally reported figures. Managers were no longer opening the tool once a month to pull static reports. They were using it every Monday morning to actively plan their week.

Revenue and user growth also moved in the right direction over the following two quarters, though — as with most single-project outcomes — it’s hard to isolate the dashboard’s exact contribution from everything else that changed at the same time. The client reported churn across the platform falling to one of its lowest points on record. The clearest evidence of impact came from qualitative feedback. Managers reported that instead of using data to dissect a ‘bad’ month after the fact, the visualisations allowed them to instantly spot slipping performance and schedule a quick supportive catch-up before it turned into a real gap.

Closing

Data design reaches its full potential when visual presentation is treated as an upstream architectural choice rather than a downstream formatting step. Bringing structured UX thinking to data turns visualisations into active decision-making engines, ensuring every chart, report, and metric directly serves a human purpose:

  • Upstream framing: Grounding every visual choice in a specific operational question rather than defaulting to available metrics.
  • Calibrated density: Tuning the level of complexity directly to the literacy and accountability of the specific reader.
  • Decision-driven insight: Structuring data to reveal strategic outcomes rather than isolated stats, turning visual signals into immediate operational momentum.

The next time you are tasked with creating a data visualisation — whether it is an enterprise dashboard, an executive report, or a public-facing infographic — step away from the design canvas and BI tools. Focus your initial effort on the human decisions behind the screen. Only then will your data stop being a passive log of the past and start driving the direction of the future.

Why Your Website Should Never Stop Changing

This article is a sponsored by Fimo

Every website is at its best the day it ships. The final branch merges, the site goes live exactly as designed, and it is briefly perfect. It will never be this good again.

Not because anything breaks. The site keeps working. But the market moves, the messaging shifts, a competitor launches something, and the careful thing you built slowly stops matching the company it represents. A year later, it is a period piece. Not broken, just behind. Every team knows this decay, and almost everyone treats it as a law of nature.

It doesn’t have to be that way. A website could keep improving after launch instead of drifting away from its best day, quietly optimizing itself while the team that built it works on something else.

Picture it working: while you sleep, an agent catches that last week’s design-system change never propagated to the pricing page, and fixes it. Another finds a set of images shipped uncompressed in a rushed release and optimizes them. A third flags an accessibility regression a new component introduced, and either fixes it or leaves it for you to check. You wake up to a site that is measurably better than the one you left, and a short list of the few decisions the agents wanted your eyes on. That is the version worth wanting.

And the moment you take that promise seriously, you run into a problem that has nothing to do with the technology:

Almost nobody actually wants a website that changes entirely on its own.
Why “Just Make It Autonomous” Is The Wrong Goal

The obvious move, once you have capable agents, is to hand them the whole site. Let them write, edit, optimize, and publish, and get out of the way. It sounds like the natural endpoint, and it is the first thing most people picture when they hear “autonomous website.”

It is also the thing almost nobody wants once it is real in front of them.

We learned this the way you learn most things worth knowing: by building the opposite first. Building Fimo, an autonomous website platform, we set out to make websites fully autonomous, assumed that was the goal, and then watched what people actually did with it. What they did was hesitate. Not because they distrusted the agents, but because a website has no single owner. Different parts belong to different people, and each one wants a different amount of autonomy. So the question was never whether to trust the agents. It was where to draw the line, and for whom.

Once you ask it that way, the work splits cleanly into three kinds.

And they don’t stay fixed. They learn from their tasks and from what you teach them, so the boundary you set last month isn't the one you’re stuck with. What you had to approve then, you can delegate now, not because you lowered your guard but because the agent earned it. The line is not a setting you configure once. It moves as trust is earned, in the direction of less work for you.

Start Narrow, and Widen As You Trust It

None of this means flipping a site to autonomous on day one. In practice it goes the other way. You delegate a little, watch how it does, and loosen.

And you can actually watch. Every agent’s runs, its history, its logs, and a before-and-after of what it changed are there to inspect. Trust doesn’t grow because you got used to the idea; it grows because you can see what happened and compare. The first time an agent quietly fixes something you would have missed, and you can see exactly what it did, the next delegation gets easier.

Deadlines keep you from becoming the bottleneck on what you have already handed over. If you don’t weigh in, the agent proceeds. You set the terms once, and you stop being the thing the whole site waits on.

The Frozen Site Is The Real Risk

The worry people voice first is that an agent will change something on their site without them. Turn it around: the real risk is a site that never changes at all. A frozen site doesn’t stay safe. It just falls behind, slowly, in a way nobody notices until it represents a company that no longer exists.

The point of autonomy was never to remove you from your website. It was to remove the decay.

The point of autonomy is to keep the launch-day version from being the best version, and to let you spend your judgment on the handful of things that actually deserve it, while the rest takes care of itself. Draw the line where your value is. Let the agents hold everything on the other side of it. And let the line move as they prove they can.

Timing Charts: A Blueprint For SMIL Animations

We know that everything on the web is a box by default, but you’ll find many animated <div>s pretending to be circles. But if you’ve ever met a real <circle>, you’ll know that they’ve got a lot more going for them. Dressed in SVG, they fit into a wider range of crowds than a humble <div> wearing HTML/CSS can. <img> has a strict no .html policy.

The <img> tag is not as static as its name suggests. Any embedded JavaScript unfortunately won’t run if you load an SVG file with an <img> tag, but CSS animations work perfectly fine. Many of the SVG attributes do have CSS property counterparts, and the geometry properties have been supported across the major browsers since 2024. Some attributes that you might want to animate, like viewBox, don’t have equivalents yet.

Besides JavaScript and CSS, there’s another way to animate SVGs: Synchronized Multimedia Integration Language (SMIL). Despite its quirks, it’s still worth learning. Like CSS animations, SMIL animations also work in <img> tags and can fully animate everything in an SVG, without JavaScript.

If you’ve never heard of SMIL or need a refresher, check out Andy Clarke’s well-named article. Then we’ll look at a way to plan an animation and make SMIL markup more manageable.

The Break Up

SMIL has a problem: it gets bloated quickly. Unlike CSS and JavaScript, where you can list multiple properties in each keyframe and easily reuse animations, each SMIL tag can only target one element and only one property of that element at a time. A property can be animated through a list of values. But it is still one tag, one element, one property. The shortest way you can write a color and opacity change that will run is the following:

<animate
  attributeName="fill"
  to="someOtherColor"
  dur="someDuration"
/>

<animate
  attributeName="opacity"
  to="someOtherValue"
  dur="someDuration"
/>

That’s not bad, but consider that it needs to be repeated for every element included in the animation. A SMIL animation can quickly get longer than its CSS equivalent.

To make things easier when starting a new animation, let’s plan all of the elements and properties we want to animate, and create a list of descriptive IDs for each tag.

Charting Animation Time And Space

I like to plan my animations using what's called a timing chart. A timing chart is effectively a line segment; some choose horizontal lines, others prefer vertical, which is a great analogy for animation as a whole because line segments can run parallel, overlap, and follow each other with or without a gap. Just like animations.

For now, we’re only interested in when animations start and stop. When drawing our charts, we’ll forget about the in-between lines and instead draw a line for each component animation, marking the beginning and end. I like to annotate timing with a circle and a bar. You can draw your chart using whatever, and it doesn’t have to be exactly to scale, as long as the relative timing between all the little animations that make up the whole is clear. Besides, adding labels for the durations is an easy cheat to get around drawing to scale.

Here is a demo of how I typically set up a timing chart with more than one animation:

See the Pen colorAndOpacityChange [forked] by Johan Grobler.

The important thing to note is that the timing chart lines are arranged according to how the animations are arranged in time. One piece of the animation follows the next piece, which is followed by a subsequent piece, and so forth. It visualizes how the animation’s parts run together and cascade over time.

S(yncbase)MIL

A big part of SMIL is synchronization. It’s even in the name, after all. And there are multiple ways to specify when an animation should start (here’s a test case to check what your browser supports). One of the most useful ways is with a syncbase value, which is a SMIL tag’s ID followed by either .begin or .end, with an optional positive or negative offset.

Let’s piggyback off the previous animation example that includes changes in color and opacity. If we want the opacity animation to start 300 milliseconds before the color animation finishes, we could do arithmetic. Alternatively, the second animation can use the syncbase value colorChange.end - 300ms. This way, the relative timing between the two animations becomes explicit.

<!-- Starts at an absolute time -->
<animate
  id="colorChange"
  begin="1s"
  ...
/>

<!-- Starts relative to when #first ends -->
<animate
  id="opacityChange"
  begin="colorChange.end - 300ms"
  ...
/>

Using syncbase values, the beginning of an animation is positioned in time relative to the .begin or .end of some other animation. A positive offset moves the start to the right (forwards in time), and a negative offset to the left (backwards in time).

See the Pen syncbase.end [forked] by Johan Grobler.

Something with negative offsets is that they can specify a time before the document has loaded or when a click happens. Computers can’t predict the future (at least not yet). The best they can do is jump the animation to where it would have been had the computer peeked into the future to preemptively start the animation. The second animation only runs from start to finish if there is enough room, so to speak.

See the Pen syncbase.begin [forked] by Johan Grobler.

Syncbase values don’t only allow you to connect animations from .end to .begin. Elect a primary animation; the animation that first comes to mind is usually the best representation of the group. All secondary animations can be set with begin="primary.begin". I’ve only used the ID #primary for emphasis. That way, all the other animations begin relative to that starting point. Stacking animations like this reduces maintenance if, say, we later want the whole group to start at a different time.

Let’s put the idea to work and build a loading indicator (or spinner). Then we’re going to explore how changing the relative timing between the parts changes the effect of the whole animation:

Step 1: Choose An Image Approach

Browsers have wide support for the prefers-reduced-motion media feature and Val Head explains this in depth in another article. We definitely want to respect this user preference as we consider moving things around. In fact, consider it non-negotiable.

There are various approaches to adhering to a user’s prefers-reduced-motion setting when it comes to SMIL. Each with its pros and cons. Evaluating early on what’s going to work best for your use case could save you a partial rewrite down the line.

For example, we could consider using a <picture> element instead of a plain <img> because <picture> supports multiple <source> elements that can be used as fallbacks in a media attribute for reduced motion preferences.

Or one SVG file with an inline CSS @media query that uses display: none to swap between versions. That said, it’s an approach that might cause trouble in various environments. But browsers are continuously changing, and this might not be an issue in the future.

You might also consider a CSS background-image instead because we can wrap that style in a media query — @media (prefers-reduced-motion) — that sets a static image as the fallback for reduced motion preferences.

There are even more options we can turn to! For example, SVG’s <view> element can also be used to swap things out for motion preferences.

Or, if we prefer everything bundled together, we can use JavaScript .matchMedia() and the handy SMIL DOM interface to control which animations start instead of completely switching out files.

For this, I’m avoiding any motion and sticking to opacity animations, which tend to cause less trouble. For a non-interactive animation like this, we can load it in an <img> tag. When we add motion, we can go the <picture> route to show the most appropriate version of our animation.

Step 2: Draw The Graphics

We’re going to do our own version of the classic three-dot spinner:

See the Pen StaticDots [forked] by Johan Grobler.

SVG wizards might be able to do everything directly in a text editor. I recommend using a graphic editor like Inkscape if you’re having trouble visualizing how the markup will be rendered. Once again, Andy Clarke has a great article about his process for optimizing and structuring his own drawings.

Note: There’s a gotcha with Inkscape. Setting what you would expect to be an element’s ID via the Layers window actually sets the value of a metadata attribute used internally by Inkscape. Use Inkscape’s object properties or XML editor window to set the true element’s ID. Your mileage may vary with a different editor. Also, in Inkscape, remember to save the file as optimized SVG when the drawing is done to strip away unneeded metadata.

Step 3: Outline The Animation

OK, so we’re sticking with the opacity animation idea. The dots are going to fade in and out. We’ll use separate <animate> tags for those. Six tags in total.

Our naming scheme is going to be straightforward: we’ll call them #fadeIn and #fadeOut, and to differentiate between each pair of tags, we’ll postfix the tag’s ID with either Left, Middle or Right. Try to follow a convention that makes sense to you when coming up with your own IDs.

The fade-in <animate> tag for the dot on the left:

<animate
  id="fadeInLeft"
  href="#leftDot"
  attributeName="opacity"
  from="0"
  to="1"
  ...
/>

And the fade-out <animate> for the middle dot:

<animate
  id="fadeOutMiddle"
  href="#middleDot"
  attributeName="opacity"
  from="1"
  to="0"
  ...
/>
Step 4: Time The Animations

We have an infinite number of ways in which we could space these six animations in time. Let’s look at a couple of choice examples alongside their timing charts to see how changing the arrangement of the parts impacts the visual effect of the whole animation.

To narrow our choices a bit, all of the <animate> tags will use the same dur value, and none of the syncbase values will have offsets.

For someone coming from a culture that reads from left to right, the dots appearing on screen along the same pattern would feel natural. Let’s also start with all the dots fading out together at the end:

See the Pen dotsVersion1 [forked] by Johan Grobler.

Syncbase values stagger the fade-ins and restart the loop when the dots have disappeared:

<animate
  id="fadeInLeft"
  ...
  begin="0s; fadeOutLeft.end"
/>

<animate
  id="fadeInMiddle"
  ...
  begin="fadeInLeft.end"
/>

<animate
  id="fadeInRight"
  ...
  begin="fadeInMiddle.end"
/>

Since all the fade-outs end at the same time, it is an arbitrary choice which one we use to restart the loop. We’ll consider #fadeOutLeft as the primary animation here and also synchronize the other fade-outs to it with the syncbase value fadeOutLeft.begin. Later, if we want to move the fade-outs in time, all we do is change when #fadeOutLeft starts.

<animate
  id="fadeOutLeft"
  ...
  begin="fadeInRight.end"
/>

<animate
  id="fadeOutMiddle"
  ...
  begin="fadeOutLeft.begin"
/>

<animate
  id="fadeOutRight"
  ...
  begin="fadeOutLeft.begin"
/>

Some Alternate Timings

Instead of a group fade-out, we could stagger them just like the fade-ins:

<animate
  id="fadeOutMiddle"
  ...
  begin="fadeOutLeft.end"
/>

<animate
  id="fadeOutRight"
  ...
  begin="fadeOutMiddle.end"
/>

Without adding an offset, there are a couple of points in time we could start #fadeOutLeft at. If it starts on fadeInRight.end:

See the Pen dotsVersion2 [forked] by Johan Grobler.

The visual effect is subtly changed by moving up a spot and starting #fadeOutLeft on fadeInMiddle.end instead:

See the Pen dotsVersion3 [forked] by Johan Grobler.

We can see from the charts that we could try moving up a spot further to fadeInLeft.end:

See the Pen dotsVersion4 [forked] by Johan Grobler.

How about starting the sequence with a fade-out:

See the Pen dotsVersion5 [forked] by Johan Grobler.

You might prefer to start with the dot in the middle:

See the Pen centerFirstDots [forked] by Johan Grobler.

As you iterate on your animation, timing charts are a great way to keep track of your work, and they make visual comparison between versions possible. And by drawing a timing chart, you might even see a pattern in the timing between the parts of the animations that you might otherwise have missed.

Step 5: Adding More Animations

As you animate more elements and properties, it gets harder to keep track of what starts when. To see how timing charts can help you make sense of things, let’s build on the basic spinner:

See the Pen staticDotsWithClipPaths [forked] by Johan Grobler.

I’ve added a <rect> for each dot to the drawing. We’ll move those into to a <cilpPath> tag and remove the fill="white". As the animation runs, the rectangles are going to move over the dots for a different approach to animating the stroke than by animating stroke-dashoffset.

We only need a single <clipPath> for all three dots, but it adds structure to the document, and it’s good practice to wrap it, and similar tags, in a <defs> tag:

<defs>
  <clipPath id="dotsClipPath">
  <!-- The geometry of the rectangles and coordinates used here, and later, depends on the viewBox used for their parent <svg> element. -->
    <rect
      id="clipPathLeftRect"
      width="2" height="2"
      x="1" y="6"
    />
    <rect
      id="clipPathMiddleRect"
      width="2" height="2"
      x="4" y="2"
    />
    <rect
      id="clipPathRightRect"
      width="2" height="2"
      x="7" y="6">
  </clipPath>
</defs>

Remember to set the clip path for the <circle>s. Either with CSS or using the clip-path attribute:

<circle
  id="leftDot"
  ...
  clip-path="url(#dotsClipPath)"
/>

<circle
  id="middleDot"
  ...
  clip-path="url(#dotsClipPath)"
  />

<circle
  id="rightDot"
  ...
  clip-path="url(#dotsClipPath)"
/>

Because the dots now have a stroke added, to leave their size unchanged, we need to compensate by subtracting half the value of stroke-width from r:

<circle
  ...
  r="0.9"
  stroke-width="0.2"
  ...
/>

That's all the changes the graphics need. Have a look at the animated version with its timing chart, then we'll look in more detail at the changes that have been made to the animation:

See the Pen clipPathDots [forked] by Johan Grobler.

There's a new animation, #moveClipPathLeft, that starts the whole sequence, and to tweak the animation's rhythm a bit, there's a 1s delay between when the fade-outs end and the loop restarts:

<animate
  id="moveClipPathLeft"
  href="#clipPathLeftRect"
  attributeName="y"
  from="6"
  to="4"
  begin="0s; fadeOutLeft.end + 1s"
  fill="freeze"
/>

You could use <animateTransform>s to move the rectangles instead, but we need to move them back to their starting positions at the end for a smooth restart of the animation. You’ll need to take into account which tags can animate and set which data types if you do decide to animate the transform attribute instead of translating the rectangles with the y attribute.

To change things up, the <rect> for the middle dot moves down:

<animate
  id="moveClipPathMiddle"
  href="#clipPathMiddleRect"
  attributeName="y"
  from="2"
  to="4"
  begin="moveClipPathLeft.end"
  fill="freeze"
/>

We’re also using the fill-opacity property instead of the opacity property for the fade-ins, and they’ve been synchronized to start once a dot’s clipping <rect> has finished moving:

<animate
  id="fadeInLeft"
  href="#leftDot"
  attributeName="fill-opacity"
  to="1"
  dur="1s"
  begin="moveClipPathLeft.end"
  fill="freeze"
/>

<animate
  id="fadeInMiddle"
  href="#middleDot"
  ...
  begin="moveClipPathMiddle.end"
  ...
/>

<animate
  id="fadeInRight"
  href="#rightDot"
  ...
  begin="moveClipPathRight.end"
  ...
/>

The fade-outs still use the normal opacity property, so both the fill and stroke fade out together. Because this arrangement is set up to use a group fade-out at the end, there are a few places the markup could be optimized. One of them is dropping the fill="freeze" to automatically reset the dot’s opacity back to its starting value once the tag finishes running:

<animate
  id="fadeOutLeft"
  href="#leftDot"
  attributeName="opacity"
  to="0"
  dur="1s"
  begin="fadeInRight.end"
/>

<!-- We'll still consider #fadeOutLeft as the primary animation here and sync the start of the others to it. -->

<animate
  id="fadeOutMiddle"
  href="#middleDot"
  ...
  begin="fadeOutLeft.begin"
/>

<animate
  id="fadeOutRight"
  href="#rightDot"
  ...
  begin="fadeOutLeft.begin"
/>

For the <animate> tags that did use fill="freeze", we’ll use <set> tags to reset those properties back to their starting values. I’ve simplified the chart a little by lumping those tags together. Because these <set> tags don’t have a duration over which they act, on the chart I’ve drawn the start and end markers over each other.

To reset the fill-opacity on the left dot:

<set
  href="#leftDot"
  attributeName="fill-opacity"
  to="0"
  begin="fadeOutLeft.end"
  fill="freeze"
/>

If you use fill="freeze" with the fade-outs, you’ll need an extra <set> for each dot to reset the middle dot’s opacity:

<set
  href="#middleDot"
  attributeName="opacity"
  to="1"
  begin="fadeOutLeft.end"
  fill="freeze"
/>

The last thing we need to do is move the clipping rectangles back to their starting positions. For the right <rect>:

<set
  href="#clipPathRightRect"
  attributeName="y"
  to="6"
  begin="fadeOutLeft.end"
  fill="freeze"
/>

That’s just one of the possible timing variations, and most of what you’ll need to try some of the others, as we did with the basic spinner, is already in place. You might want to have a try at coming up with a couple of your own alternate timings.

That’s The Benefit Of Timing Charts

To sum things up, we know that balancing the different stages of an animation can be difficult at best, and untenable at worst. Any time we get into multi-step animations that exceed one or two steps, it’s a form of orchestration. You’re almost building a Rube Goldberg machine of markup. And using a timing chart is a strategy I use that I hope will help you in your projects as well. They are outlines of what to expect and when, allowing you to map things out in a way that not only helps plan your code, but also makes future updates and maintenance a lot more bearable than going into it without a plan.

While a timing chart can’t reduce the complexity of the markup, it can give a good overview of what should happen when. Timing charts are definitely not limited to SMIL animations. Unfortunately, syncbase values are, and they can still help even if you’re going to use a different approach to implementing your animation.

Further Reading

I highly recommend checking out Andy’s other articles on Smashing Magazine. There’s even more stuff on combining CSS and SVG.

Yosra Emad wrote a great article on creating animations with multiple steps in CSS, and you might want to try drawing a few timing charts as you read through it.

When you’re ready to start adding those in-between lines to your timing chart, Nash Vail’s article on easing dives deep into the details of easing curves.

You might also be interested in tests for your browser’s SVG implementation to see what is supported.

❌
❌