
CLARITY · 2026
Hearing a screen before it is built.
A tool I designed and built so a team can hear, step through and resize a screen before code.
The bank is not named, and every screen shown is a made-up example, for confidentiality.
10
squads using Clarity
50%
less time spent on QC testing
77%
higher accuracy in development than before the team had Clarity
274
screens and screen states covered
MY ROLE
Concept, design and build.
Lead Product Designer on a web application that simulates iOS and Android screens. It started in August 2026 and is continuing.
Who it serves: designers, developers, QA, QC, product owners and the business team.
The goal
Everyone who decides whether a screen works should hear the same screen, before any code is written.
Journeys on the plan
128
Journeys covered so far
3
Login, Home and Transfers so far: 274 screens and screen states.
Where we started: an accessibility checklist, and written notes on the design.
Result: we could read it, and we could not experience it. Nobody heard the screen until it was built.
EVIDENCE
Seven results from the first three journeys.
Squads using Clarity
Reviews, demos and test preparation
10
Product owners demo a whole journey without passing phones around.
Time spent on QC testing
QC checks the build against the expected result
50% less
QA hears the expected result before testing starts.
Accuracy in development
Compared with phase 1, before the team had Clarity
77% higher
Developers get the exact label, role, state and order to build, with code to start from.
Screens and screen states
Login, Home and Transfers
274
Covered across three journeys.
Journeys covered so far
Of 128 on the plan
3
I began with one journey the team was already building, and grew outward from there.
Components in the library
Mapped to 25 component types
56
Rules belong to component types, not screens.
Checks
Each tied to a WCAG success criterion
47
A button alone has 17 checks at level AA.
Clarity prepares a team for testing on real phones with real people. It does not replace that testing.
01 · THE PROBLEM
Most of what makes a screen accessible cannot be seen in a design.
It shows up later, on a real phone, when a customer turns on a screen reader or makes the text bigger. A design file shows how a screen looks and how it moves.
In our team these lived in a checklist and in written notes on the design. Developers read the notes, QA read the checklist, and nobody heard the screen until it was built.
What a design file does not show
How it sounds
What a screen reader says for each element, in VoiceOver on iPhone and TalkBack on Android.
Where focus goes next
The order a person moves through the screen without seeing it.
What happens when the text grows
Which labels wrap, which get cut off, and what falls off the screen.
02 · WHO IT IS FOR
Six groups should all look at the same thing.
Six groups decide whether a screen works for someone who cannot see it, and each needed something different.
A note in a design file means something different to each reader. A screen that speaks does not.
Six groups, and what each needs
Design team
To hear and step through a screen while it is still a design
Developers
The exact label, role, state and order to build, with code to start from
QA
The expected result before testing starts
QC
To check a finished build against that expected result
Product owners
To demo a whole journey without passing phones around
Business team
To review the content and hear how VoiceOver and TalkBack read it
03 · MAKE THE TEXT BIGGER
Cut-off labels show up in the review, not in production.
One control raises the text size, up to the largest accessibility sizes on each platform. The screen reflows the way it would on the phone.

One screen, from the default size to the largest accessibility size. At the top size the balance breaks across two lines, which is exactly what this view is there to catch.
04 · FOLLOW THE READING ORDER
The order is a list a designer can read, question and change.
A focus ring moves through the screen in the order a screen reader would take. The order is a list beside the phone.

Stepping through a banking home screen. The ring on the phone, the order list and the transcript move together.
05 · HEAR IT
Each element is spoken the way the platform would say it.
Pressing Read speaks each element: its label, its role and its state.
The same words appear as text, so the expected result can be copied into a test case.
Each platform keeps its own words
VoiceOver, on iPhone
Calls a disabled button “dimmed”.
TalkBack, on Android
Calls a disabled button “disabled”.
Clarity uses the word the customer will actually hear, because a test case written with the wrong word fails for the wrong reason.

Here VoiceOver reads “Hide balance, button”, and the same words appear as text.
06 · MOVE BETWEEN SCREENS
Many accessibility problems sit between screens, not on them.
When a new screen opens, the screen reader should say where the customer now is. When they go back, focus should return to the button they came from, not to the top of the page.
Clarity follows a whole journey this way. Each new screen is announced by its heading, and going back puts focus on the element that was used.

Sending money in a made-up banking app: home, choose a person, go back and land on the same person, enter an amount, review, done.
07 · HAND IT TO DEVELOPERS
The expected speech and the code come from the same page.
Each component has a page where a designer sets its label, icon and state, and adds accessibility details such as a hint. The expected speech updates with every change.
The Code tab gives the developer the same component in SwiftUI or Jetpack Compose, with the accessibility settings already written in.

A button changes label, icon and state, gains a hint, and ends as SwiftUI or Jetpack Compose code a developer can copy.
08 · KNOW WHAT TO CHECK
Every component type carries its own guidelines and checks.
Each check is tied to a WCAG success criterion and a way to test it.
A new screen built from these components inherits the rules without anyone writing them again.
The library today
Checks in the library
47
Checks on a button, level AA
17
The library holds 56 components, mapped to 25 component types.

The Guidelines tab for the primary button, then the Checks tab with its 17 checks at level AA.
DESIGN DECISIONS
Five decisions shaped the product more than any screen did.
A prediction is labelled as a prediction
The speech is marked as a preview everywhere it appears. Clarity prepares a team for testing on real phones with real people. It does not replace that testing, and the interface never suggests it does.
Hear it
Each platform keeps its own words
VoiceOver calls a disabled button “dimmed”. TalkBack calls it “disabled”. Clarity uses the word the customer will actually hear.
Hear it
Rules belong to component types, not screens
A button, a text field and a tab bar each carry their own guidelines and checks. A new screen built from them inherits the rules.
Know what to check
The phone and the tool stay visibly apart
The simulated screen is the bank’s design, untouched. Everything around it is quiet and dark, so nobody mistakes a tool control for part of the product.
The workspace
Code has to compile before it is offered
The SwiftUI and Jetpack Compose output is checked against the real Apple and Android build tools. A snippet that looks right and does not build would cost a developer more time than it saves.
Hand it to developers
HOW I BUILT IT
I am not an engineer. Three guards catch the mistakes.
I built Clarity with AI coding assistants, directing them in plain language and checking the result in the browser. That only works if the product can catch its own mistakes.
Two things did not work the first time
Every screen was built by hand. The first version covers only the journeys I built into it, one screen at a time. It proved the idea, and it meant every new screen needed me. The next phase replaces that with import from Figma.
Two parts of the product disagreed. The workspace and the component page each worked out the spoken text their own way, and gave different words for the same button. I found it by comparing them side by side, and I am bringing them to one wording.
Three guards
Automated tests
88 test files run with one command, before I call a change finished.
Written rules
A design system document and a short set of review rules that every change to the interface must follow.
Real compilers
Generated code is compiled before it is shown to anyone.
OUTCOME AND NEXT
Ten squads use Clarity today. Import from Figma is next.
It is in use across three journeys: Login, Home and Transfers. Product owners demo a whole journey without passing phones around. QA hears the expected result before testing starts, and QC checks the build against it. The business team reviews the content by hearing it in VoiceOver and TalkBack. We are all learning accessibility as we go.
What comes next
Any designer brings their own Figma frames.
Each component is mapped once.
The result is previewed, then handed to developers.
The remaining journeys: 3 of 128 are covered so far.
One wording for the spoken text, across the workspace and the component page.
What I learned
You cannot review what you cannot experience.
The checklist was complete and nobody could feel it. The same rules, heard through a phone, are much harder to skip.
A simulation earns trust by saying what it is not.
Labelling the speech as a preview tells the team exactly how far to rely on it.
Start with one real journey.
I did not begin with a platform. I began with one journey the team was already building, and grew outward from there.
Building it myself changed what I ask.
I used to ask what a screen looks like. Now I ask what it is like for someone else.