Case study

Installing an AI-native design practice

Presented byJohn Percival
DateSeptember 2026

About me

I create and develop design organizations.

24 years in design, product and technology — IC, 0-to-1 bets, global organizations
13 of them at Amazon — Design Technology, Design Systems, Amazon Autos
9-figure revenue goals supported by teams I’ve led — distributed across regions
100s of features shipped — customer- and seller-facing

The question

“When every designer adopts a different AI tool, what holds the craft together?”

The problem

The AI tools were a step change — but we lacked shared standards.

Tool freedom

I set a tenet: embrace tool freedom.

Different tools are better at different jobs, so the practice had to hold together without picking one.

Figma Make

Work headed to critique — context comments land where the conversation already is.

Claude Code, Codex and Kiro

Production-bound work — high-quality output that moves toward real code.

The opportunity

Make the standards the constant, and the tool the variable.

Consistency without locking down the toolchain. And something new: a written standard can now be executed rather than remembered — an AI harness or agent reads the definition of good and checks work against it at the moment of the decision.

What I put in place

A definition of good, with an owner for every part.

Made the definition of good explicit

One steering document per discipline, each with a single accountable person — the only route to changing it.

Put it in version control, read live by every tool

No local copies.

Removed the technical barrier to contributing

Owning a standard doesn’t require learning Git. An agent does that part.

The source of truth

Repository listing of the standards directory: one markdown document per design discipline, each with its own commit history.
AI tools link dynamically to our evolving source of standards. The standards/ directory sits on a protected mainline — one document per discipline, each with a named owner and its own history. Nothing is copied locally; every tool reads the current file.

What a standard looks like

standards/accessibility.md191 lines · scroll to read
---
standard: Accessibility
owner: <designer name>
maintainers: [TBD]
approvers: [<designer name>]
approval_rule: owner (<designer name>) must approve
status: draft
last_reviewed: 2026-07-08
review_cadence: monthly
applies_to: all Amazon Autos UX builds
---

# Accessibility Standards

> **What this file is:** the authoritative standard for accessibility (a11y)
> requirements and checks across all Amazon Autos builds — the bar every
> component and page ships at, and how AI is used to check it without letting
> automated tooling stand in for human validation. If a build conflicts with
> this file, this file wins (or files an exception below). If *this file* is
> wrong, fix it via a [CR](../ways-of-working/cr-process.md) — don't work
> around it silently.

> 🌱 **Baseline draft — seeded from existing Kiro steering for the owner to
> validate and adopt.** The content below was distilled from prior Kiro
> accessibility steering (WCAG 2.2 AA rules, ARIA patterns, POUR checklist). It
> is a starting point, **not finished truth** — <designer name> owns validating and
> adopting it. Items marked _[<designer name> to confirm]_ are proposed defaults the owner
> should confirm or change. See [`_TEMPLATE.md`](_TEMPLATE.md) for the required
> structure and [`research.md`](research.md) for a fully-worked example.

## Scope

**Covers:** the WCAG 2.2 AA conformance bar for every component and page;
keyboard operability and focus management; screen-reader semantics and the
correct use of native HTML vs. ARIA; color/contrast and non-text contrast;
target size, motion, zoom/reflow; accessible forms and error handling; and the
manual + automated testing protocol a build passes before it ships.

**Does not cover** (defer to the neighboring standard):
- Component tokens, focus-ring styling, and reusable component internals →
  [`design-system.md`](design-system.md)
- Accessible *wording* of labels, errors, and instructions →
  [`copy.md`](copy/copy.md)
- Usability findings from testing with users with disabilities →
  [`research.md`](research.md)
- Analytics / measurement of a11y outcomes → [`data-measurement.md`](data-measurement.md)

Accessibility is primarily a **④ QA & Rollout** concern in the
[process model](../foundation/02-process-model.md) but is designed in from
**② Design** — semantics, focus order, and contrast are cheaper to get right up
front than to retrofit.

## The standards

WCAG 2.2 AA is the floor, not a stretch goal. The rules below are organized so a
builder can act on them; the fuller criterion-by-criterion and pattern-by-pattern
detail lives in [Reference](#reference).

### Must (non-negotiable)

1. **WCAG 2.2 AA across the board.** Every component and page conforms to WCAG
   2.2 Level AA (all four POUR principles). AA is a hard requirement; AAA items
   are welcome but not gating.
2. **Keyboard-operable, always.** Every interactive element is reachable and
   operable with the keyboard alone, with no keyboard traps (you can always Tab
   or Escape out). Focus order is logical and matches the visual layout.
3. **Focus is always visible and not obscured.** A visible focus indicator with
   at least 3:1 contrast against adjacent colors on every focusable element; the
   focused element is never fully hidden behind sticky headers/footers (SC
   2.4.11). Never remove focus indicators — not even under `prefers-reduced-motion`.
4. **Everything interactive has an accessible name and correct role.** Prefer
   native HTML elements first; reach for ARIA only when native won't do, and when
   you do, follow the [ARIA APG](https://www.w3.org/WAI/ARIA/apg/) pattern
   exactly (roles, states, keyboard, focus management). No custom control ships
   without name, role, and state exposed.
5. **Contrast meets AA.** 4.5:1 for body text; 3:1 for large text (≥18pt, or
   ≥14pt bold); 3:1 for UI components, icons, and meaningful graphical objects
   (SC 1.4.11).
6. **Color is never the only signal.** Error, selected, and status states use an
   icon, text, or shape in addition to color (SC 1.4.1). Verify in grayscale.
7. **Minimum target size 24×24 CSS px** for interactive targets (SC 2.5.8), or
   adequate spacing where the target itself is smaller.
8. **Accessible forms.** Every input has a persistent, visible `<label>` — never
   placeholder-as-label. Error messages are in text (not color alone),
   programmatically associated with their field, and announced on submit.
9. **Status changes are announced.** Toasts, inline errors, loading, and result
   counts use ARIA live regions (`assertive` for errors/critical, `polite` for
   success/status) so screen-reader users hear them without a focus change
   (SC 4.1.3).
10. **Zoom & reflow hold up.** UI stays functional and content is not lost at
    200% text zoom and reflows to a single column at 320 CSS px wide with no
    horizontal scroll (SC 1.4.4, 1.4.10).
11. **Respect motion and timing preferences.** Honor `prefers-reduced-motion`;
    no content flashes more than 3×/second; auto-playing motion longer than 5s
    is pausable/stoppable.
12. **Ship with a clean audit + manual pass.** Zero automated-tool violations
    **and** a keyboard-only pass **and** a screen-reader pass on the primary
    flow before a CR is approved (see [testing protocol](#reference)).

### Should (strong default; deviation needs a reason)

1. **Don't roll your own composite widgets.** Prefer native `<select>`,
   `<dialog>`, `<input type="range">`, etc., or a battle-tested library
   _[<designer name> to confirm the approved library — e.g. Cloudscape / Radix]_ over a
   hand-built combobox, menu, or slider. These are the patterns most often gotten
   wrong.
2. **44×44 px for primary touch targets.** Exceed the 24px minimum for the main
   touch controls on mobile — it's the difference between "conformant" and
   "comfortable."
3. **Manage modal focus correctly.** Trap focus inside; return focus to the
   trigger on close; Escape closes; mark background content inert / `aria-hidden`.
4. **Icon-only controls get a name.** `aria-label` or visually-hidden text on
   every icon-only button.
5. **Test on real assistive tech, not just the axe score.** VoiceOver on macOS
   (primary) and NVDA on Windows (secondary) _[<designer name> to confirm the primary/
   secondary AT matrix]_; automated tools catch only a slice of issues (below).
6. **Announce SPA route changes.** Client-side navigation isn't announced for
   free — programmatically announce and manage focus on route change.

### Reference

- **WCAG 2.2 quick reference:** <https://www.w3.org/WAI/WCAG22/quickref/>
- **ARIA Authoring Practices Guide (APG):** <https://www.w3.org/WAI/ARIA/apg/>
- **POUR checklist (criterion-by-criterion, with priority tiers P0/P1/P2 and
  how-to-test):** distilled from the Kiro `wcag-checklist` — _[<designer name> to confirm
  where the canonical checklist lives in the repo]_.
- **ARIA pattern cookbook:** roles/properties, keyboard tables, and focus
  management for accordion, alert, button, checkbox, dialog, disclosure,
  listbox, menu/menubar, radio group, slider, switch, tabs, tooltip, tree view,
  and combobox — distilled from the Kiro `aria-patterns` reference. Includes the
  cross-cutting patterns: **focus-indicator spec**, **roving tabindex** (for
  tabs/radio/tree/menu), and the **live-region priority** table. _[<designer name> to
  confirm repo location.]_
- **Focus-ring / contrast tokens:** owned by [`design-system.md`](design-system.md).
- **New in WCAG 2.2 to watch:** target size (2.5.8), dragging alternatives
  (2.5.7), focus-not-obscured (2.4.11), accessible authentication (3.3.8),
  redundant entry (3.3.7), consistent help (3.2.6).
- **Amazon internal accessibility guidance:** _[<designer name> to confirm the canonical
  internal link.]_

**Limits of automated checks:** automated tooling catches only roughly a third
of issues. Keyboard testing plus a screen-reader pass catch most of the rest;
full validation still needs manual AT testing and expert review. This is why
Must #12 gates on manual passes, not just a clean scan.

## AI integration

How AI is used *within* accessibility work, mapped to the
[3-tier taxonomy](../foundation/02-process-model.md#the-ai-classification-the-key-idea-we-adopt)
(🟢 can automate · 🔵 augments · ⚪ human-led) and the
[quality bar](../foundation/03-quality-bar.md).

| A11y task | AI role | What AI does | Human gate |
|---|---|---|---|
| Automated WCAG / a11y audit (QA phase) | 🟢 can automate | Runs the audit in the QA gate, flags violations, produces the machine-checkable report | None to *run* it; but a clean scan alone never means "accessible" (see below) |
| Remediation suggestions | 🔵 augments | Proposes fixes — ARIA attributes, label wiring, contrast/token swaps, focus-management scaffolding | Builder confirms the fix is correct for the pattern (native-first, APG-conformant) before merging |
| Generate ARIA / component scaffolding | 🔵 augments | Drafts a starting implementation from an APG pattern | Builder verifies name/role/state and keyboard behavior against the pattern |
| Keyboard-only walkthrough | ⚪ human-led | — (AI stays out) | Human tabs through the real flow |
| Screen-reader validation | ⚪ human-led | — (AI stays out) | Human runs VoiceOver/NVDA on the primary journey |
| Expert / edge-case a11y review | ⚪ human-led | — | Human accessibility judgment on the ~two-thirds of issues tools miss |

**The load-bearing gate:** the automated audit is 🟢 because it's already a
mechanical step in the QA phase — but a passing scan is *necessary, not
sufficient*. Remediation review and the keyboard + screen-reader passes are
🔵/⚪ and stay human-owned. "axe reported zero violations" is not proof of
accessibility; the keyboard and AT passes are.

**Current tools:** → [`tools/`](../tools/) (audit + contrast + AT tooling; kept
separate so they can churn). This standard names the *bar*, not the tool.

## Exceptions

WCAG 2.2 AA conformance is not waivable at will — accessibility is a legal and
usability floor. When a build genuinely cannot meet an item on time:

1. Log the specific SC, the reason, the affected surface, and a remediation plan
   with a date, in the build's CR / exception log.
2. **<designer name> approves** the exception (owner / final approver); prefer a time-boxed
   waiver with a fix committed over an open-ended one.
3. Treat every exception as a signal the standard, tooling, or component library
   may need updating — surface it, don't bury it. _[<designer name> to confirm the exception
   log location and any hard "never-waivable" P0 subset.]_

## Changelog

Newest at top. One line per change; link the CR.

- *2026-07-08* — Seeded baseline draft from Kiro accessibility steering (WCAG 2.2
  AA, ARIA patterns, checklist); owner (<designer name>) to validate. — jperciva
- *TBD* — Initial stub scaffolded. — jperciva

A peek at what a standard actually looks like — accessibility. A markdown file with YAML front matter; this is the file itself, not a summary of it.

The front matter is the governance. Owner, approvers, approval rule, review cadence and last-reviewed date — structured data at the top of the file, so a tool or an agent can read who owns this and when it was last checked without parsing the prose.

Every standard carries its own AI section — a table naming, task by task, what an agent may do and where a person still decides.

What engineering gets out of it

Design wasn’t the biggest beneficiary.

The inspector

The DS Inspector panel open over a live prototype: 95% design-system coverage, 87 design-system components against 5 custom, and a counted list of every component on screen.
We still have work to do to get our prototype code polished enough for production, and I’m working with engineering partners to do exactly that. In the meantime, as a bridge, I built DS Inspector — it helps engineering deconstruct a prototype against our design-system library of components and patterns, naming every component on screen and separating system components from one-offs.

Education and adoption

A standard nobody was taught is a standard nobody uses.

Mechanics

  • Standing AI office hours — open agenda, any AI topic: tools, workflows, prompting, experiments. I run it.
  • Starter kits and templates — a guided first contribution, with an agent doing the technical part.
  • Documentation — written so someone can get productive without being walked through it.

What’s in place

  • Every functional discipline in the org is represented in the standards, each with a written document and a named owner.
  • One source of truth, branch-protected — every change reaches it through the domain owner.
  • Fully adopted and collectively managed across the distributed team.

Distributed ownership is the whole model.

Early results

33% reduction in engineering development time and climbing Twelve weeks down to eight — four weeks back on every project, measured against a pre-AI-practice baseline.
<1 day to ramp a new hire Two recent new hires, against a goal measured in weeks.
1 platform team adopted it Unprompted, inside their own AI product, after we consulted with them.

The gap, and the north star

This proves a design was built correctly. It doesn’t yet prove it was the right design.

The honest gap

None of it tells us whether the design worked for the customer. Usability validation isn’t consistently in the flow today, and no one owns it yet.

The north star: experimentation

  • Ship behind a weblab, with the hypothesis stated before launch rather than reconstructed after.
  • Weblab exposing an MCP, with partner teams — so our AI tools reach the experimentation service directly.
  • Results feed back to the standard. A pattern that keeps winning becomes the default.

Thank you.

Questions?

Private · case study

Installing an AI-native design practice

Shared for review by John Percival. Please don’t redistribute.