Case five · Solo · Private alpha

uoaui logo

uoaui.ai

A design platform I'm building on Claude. It turns a prompt into a working screen built from real design systems, Salt, Material, Fluent and Carbon among them, using native components where the mapping supports them, with explicit fallbacks for missing equivalents. Switch system, density or theme and the screen rebuilds.

Role · Designed and built it, soloStatus · Private alpha. Landing, comparison and UI Kit are public; the builder needs an invited sign-in.Live · uoaui.ai (opens in new tab) →UI Kit · Salt component library (opens in new tab) →
The current authenticated uoaui builder showing the Salt Performance Analytics canvas, chat and component library
The current uoaui Salt UI Kit, with foundations and component controls

01 The problem underneath

The live uoaui.ai comparison page showing the same finance screen in Salt and uoaui
  • Designing for output you can't predict

    Where the system acts and where it asks. How a person stays in control without making the AI useless. The compare and tune steps are my answer so far. The model drafts, I decide.

  • Who it's for, and the trap

    Designers like me, which is dangerous, because designing for yourself hides your blind spots. The alpha exists partly to break my own assumptions.

  • What it isn't

    It doesn't ship the final product and I don't claim it does. It closes the gap between a Figma file and the thing a developer can inspect.

User personas

My two design personas: a designer like me and the developer who inspects the output. Role-based working assumptions the private alpha exists to test, not research participants.

Mei Lin

Product Designer Works inside a design system

The model drafts. I decide.

Context

Designs screens inside an established design system, comparing and refining generated drafts.

In this app
  • A compare step across systems
  • Tune density, theme and charts
  • Mapped system components, with explicit fallbacks
Goals
  • Prompt, generate, compare, tune, export
  • See the same screen in Salt, Material, Fluent and Carbon
  • Stay in control without making the AI useless
Pain points
  • Designing for output you can't predict
  • Designing for yourself hides your blind spots
  • Free-form generated UI looked impressive and was unusable

Dev Patel

Front-end Developer Receives the export

Show me code I recognise, not a picture of a screen.

Context

Receives exported React and needs to understand the components, structure and remaining work.

In this app
  • Export React a developer recognises
  • Native component mappings and explicit export fallbacks
  • Token mapping underneath, mapped not generated
Goals
  • Inspect the exported React
  • Recognise mapped components and inspect the fallbacks
  • Close the gap between a Figma file and code
Pain points
  • Generated screens that use none of the team's components
  • Screens nobody tested with a user
  • A Figma file with nothing to inspect

02 The flow

User flow

The designer can review and refine the draft, or export directly.

Private alpha · compare and tune are optional. Export is a developer handover, not a finished product.

On smaller screens, enlarge the flow to read and explore the branches.

uoaui.ai · from intent to inspectable React. The designer can review and refine the draft, or export directly.uoaui.ai · from intent to inspectable React. The designer can review and refine the draft, or export directly.
Silent recording. It picks a template, edits one card, then presents the same screen across the five design systems.
The current uoaui Salt UI Kit with foundations, components, patterns and system controls
The current uoaui UI Kit charts and data visualisation specimens in Salt
The live Salt Forms pattern with full-name and email fields, a department selector and submit/cancel actions

User journey

Mei Lin · Product Designer · Works inside a design system · One screen in Salt, a Material version due, one afternoon

Persona

Mei Lin

Product Designer Works inside a design system

Scenario

Mei has a screen to design in Salt by Friday and a Material version due for a sister team. She describes the screen, reviews the generated canvas, compares the systems, tunes density and theme, and chooses when to export React for a developer to inspect.

Goal

Reach a useful, inspectable screen in a real design system without rebuilding it by hand for every system.

The designer decides. The model drafts.

Native components and explicit fallbacks support the draft. Compare and tune are optional review tools; export is available directly.

  1. 01Designer
    Prompt

    Mei describes the screen in words. The output can't be fully predicted, so the prompt has to say what matters: system, density, data.

    Design response
    • Name the system and density in the prompt
    • Real-shaped data, not lorem ipsum
    What the system does

    The prompt is read with the system, density and data named, so the draft starts inside the right constraints.

  2. 02Model
    Generate

    The model adds structured blocks to the canvas. Supported combinations render real system components; other combinations use explicit fallbacks.

    Design response
    • Map supported blocks to native components
    • The first answer is a draft
    What the system does

    Claude uses the builder’s block catalogue and canvas tools. Component mappings and fallback renderers turn that structure into the screen.

    Draft misses the intent? Return to the prompt.

  3. 03Designer
    Compare systems

    The same screen in Salt, Material, Fluent and Carbon. The hard part is where the systems disagree.

    Design response
    • Side-by-side compare across systems
    • Inspect where the systems differ
    What the system does

    The same canvas maps to five systems. Each mapping uses the system’s component and layout APIs where available, with CSS or generic output for unsupported combinations.

  4. 04Designer
    Tune

    Density, theme and charts. This is where the person decides, and where Mei corrects the model most often.

    Design response
    • Density, theme and chart controls
    • Compare and tune before choosing to export
    What the system does

    Density, theme and chart props re-render the same component tree. Nothing is redrawn by hand.

    Changed density or theme? I compare again before handover.

  5. 05Designer → developer
    Export React

    Code a developer recognises. It closes the gap between a Figma file and the thing a developer can inspect.

    Design response
    • Export React
    • Inspectable component tree and tokens
    What the system does

    React export includes component mappings and styles, with fallbacks where needed. Export is available directly; the product does not enforce a compare-and-tune gate.

Opportunities

The next validation question: can another designer reach a useful, inspectable screen without me guiding them? The private alpha exists to answer it, and to break my own assumptions.

03 Decisions and trade-offs

Decision map

A private alpha for turning a brief into an inspectable screen. The model edits a structured canvas; mappings connect its blocks to the selected system. Review and export stay in the designer’s hands.

On smaller screens, enlarge the map to read and explore the branches.

uoaui.ai decision map. The model drafts. The designer decides what to inspect and hand over.uoaui.ai decision map. The model drafts. The designer decides what to inspect and hand over.

Constrain the draft

The model chooses from defined block types and canvas actions. Covered blocks map to real system components; uncovered combinations have explicit fallbacks.

Keep the judgement with the person

System comparison and tuning let the designer inspect the draft. Export remains available directly, so review is a working practice rather than an enforced gate.

  1. Implemented in the private-alpha source

    01Mapped components, with explicit fallbacks

    What should the model be allowed to make?

    A plausible-looking screen is not enough for handover. The output needs to map to components a developer can identify and inspect.

    I chose

    Mapped components with explicit fallbacks
    Mapped system components and fallbacks

    Generate structured canvas blocks, then map supported blocks to real system components.

    Alternative

    Letting the model draw free-form UI
    Free-form generated UI

    Let the model produce arbitrary UI without the shared block model.

    Why I chose it

    I constrained generation to the builder’s block model. Where a system has a supported component, the renderer and React export use it. Where it does not, there is a fallback rather than a fabricated package API.

    What it cost

    The mapping needs maintenance for each system. Unsupported combinations can use custom or generic output, so the designer still needs to inspect them.

    What informed the decision

    The source sends Claude a catalogue of block types and canvas tools. Its component registry maps supported blocks to Salt, MUI, Fluent and Carbon; the house system uses its own CSS. The renderer and exporter have fallback paths for uncovered combinations.

  2. Working private-alpha comparison

    02Switching systems

    What should stay stable when the design system changes?

    Different systems have their own components, density scales and theme rules. A switch should preserve the intended screen while making those differences visible.

    I chose

    Five systems, one model underneath
    Five systems, one model underneath

    Map a shared screen structure to the supported systems, then inspect the result.

    Alternative

    A screen rebuilt by hand
    A screen rebuilt by hand

    Rebuild the screen separately for every system and maintain the copies.

    Why I chose it

    I mapped screen structure, tokens, density and theme so I could compare the supported systems without drawing a separate screen for each. The differences still need a person to inspect them.

    What it cost

    A shared representation has to accommodate different system rules. Some system-specific choices need an explicit decision rather than a direct one-to-one swap.

    What informed the decision

    The source stores one canvas with a selected system, theme and density. Component and layout registries map that structure differently for each system. The mappings use native APIs where available and token-driven CSS where a system has no equivalent.

  3. Direct export; review is optional

    03Review before handover, without locking export

    How can a designer inspect the draft before choosing to export?

    The first output may miss hierarchy, density or system behaviour. Treating generation as completion would move that correction work into handover.

    I chose

    Compare and tune before export
    Compare and tune as review tools

    Use comparison and tuning to review the draft, then choose when to export.

    Alternative

    The model's first answer
    Accept the first draft

    Accept the generated draft without reviewing its system differences.

    Why I chose it

    I give the designer ways to compare and tune the draft before handover. The current product leaves export available; the person decides when the screen is ready.

    What it cost

    Keeping export available preserves flexibility, but it also means the designer can export before reviewing. The interface does not enforce the review sequence.

    What informed the decision

    The export menu opens directly from the builder. React export generates the current canvas files without a compare or tune prerequisite. The only preview prerequisite in this panel applies to the Figma SVG format, which measures the rendered canvas.

The model drafts. The person decides.

  • Draft → compare → tune

    I write the prompt. Claude drafts a screen, never the final answer. I compare and tune before exporting React a developer can inspect.

  • One structure, five systems

    I designed the token, density and theme mapping. It resolves system-specific props across Salt, Material, Fluent, Carbon and my own system. Published React components are used where available; missing equivalents use explicit markup fallbacks, alongside a class-based in-house system.

Switch system, density or theme and the screen rebuilds: the layers below the model are mapped, not generated. This is my review workflow; the builder also allows direct export.

My brand, my system, my product

Brand and design system

I designed the name, brand, interface and system model. My own uoaui system sits alongside Salt, Material 3, Fluent 2 and Carbon; those four libraries retain their own authorship and component rules.

My original uoaui symbol and wordmark
Original symbol and wordmark

One identity, several visual systems.

The name wraps around U and I. The product has its own identity, while the screen inside the builder follows the selected system. Brand, builder controls and the generated canvas have separate token layers.

Brand typography: Bricolage Grotesque · Inter · IBM Plex Mono. Component typography: Inter in my own system; system-native type in the others.

Midnight Canvas

Background
#0A0E1A

Purple Compute

Primary accent
#A78BFA

Peach Output

Secondary highlight
#F0B5A4

Teal Input

Signal
#3DDCC4

Current landing-page palette. The component library has separate light and dark semantic tokens.

  1. Product identityName, logo, landing-page palette and editorial typography.
  2. Builder controlsThe working environment around the canvas has its own tokens.
  3. System mappingOne structure maps theme, density and components across five systems.
  4. Component libraryMy uoaui system alongside the official Salt, Material 3, Fluent 2 and Carbon libraries.

The product layers I designed

The live uoaui house design system with button comparisons, palette, iconography and four density settings

Theme and density

Light and dark themes, with High, Medium, Low and Touch densities. The same component changes through tokens, rather than becoming a separate design.

Interaction styling

My system defines 150, 250 and 350ms motion, a shared radius scale and separate glass-opacity levels for light and dark surfaces.

04 AI at work

  • Figma for foundations

    The better the design file, the better the AI output. At Barclays I'm matching Figma naming to the code so there's no gap in either direction. When the model can't get the spacing right, I point it at the file. Everything after that, I'd rather iterate in code.

  • Built from the terminal

    Both public rebuilds in this portfolio were made with Claude Code and Codex, in days, to test decisions with real-shaped data. Winking Star shipped the same way.

  • Where a designer still matters

    A colleague brought me a screen made with AI. It looked fine, used none of our components, and nobody had tested it with a user. I rebuilt it in our own components and showed both. The existing components made it faster to build and kept it consistent with the platform. A generated screen still needs someone who watched how people work.

05 Outcome and validation

  • What I can show today

    I have built a working builder, a comparison across five design systems and a component library. The current screens and walkthrough above show that work. This is private alpha, not a production adoption result.

  • What changed through exploration

    I explored free-form generated UI and official React components. I chose a structured canvas mapped to system components, with explicit fallbacks, because a developer needs to inspect and recognise the output. My comparison and tuning practice keeps the model's first answer a draft.

  • The next validation question

    Can another designer reach a useful, inspectable screen without me guiding them? That is the question for the alpha. No adoption rate, no time saving, no external test yet. When another designer gets there without me, I'll say so here.

Accessibility and responsiveness

System, theme and density stay inspectable.

The UI Kit has a skip link, and the system, theme and density controls work from the keyboard. That is what I can show today. It is not a full audit, and I haven't run one yet.

Across screen sizes

The Salt UI Kit fits 820px and 390px. The builder is a desktop canvas, and stays one.

Current product at an 820-pixel tablet viewport
Tablet · 820px viewport
Current product at a 390-pixel phone viewport
Phone · 390px viewport