Note

【AI Dev Workflow · 04】 UI Prototype & Ergonomics: From Product Flows to Usable Interfaces

Nov 2, 2026

Turn tasks into usable prototypes, choose a style and observe changes on one website. Explore 24 contextual comparisons to identify interface decisions and describe requirements to an Agent.

What should this stage produce? Chapter 03 defined responsibilities and API contracts. Now turn those decisions into an interface people can understand, operate, and recover in when something goes wrong.

An agent can build a page quickly. A page that renders does not establish that a task is easy to finish. Use a clickable prototype to check the flow, information order, and interaction states before connecting real services.

We continue the knowledge quiz tool from the previous chapters: provide material, generate practice, answer questions, then inspect explanations and source evidence. The layouts and numbers below are teaching examples, not validated product results.

Decisions you ownWork an agent can help with
What the user does first and which outcome mattersMap the task into views and states; identify gaps
Which information is primary or optionalImplement layouts using established styles and components
What waiting, failure, and leaving should meanCreate controllable mock scenarios
What counts as usableCheck implementation, then validate through actual task trials

1. Derive Views from Tasks

Start with one task: “Practice using this material, find what I misunderstood, and check the evidence.” Follow that task before listing a homepage, dashboard, or account center.

One task, four interface moments — Views follow the task; they need not become four separate URLs.

Views follow the task; they need not become four separate URLs. View full-size

Organize around the task; each moment does not need a separate URL. A small tool may switch states on one page. Split views when length or independent access justifies it.

  • Provide material: Explain supported inputs and place format or length limits beside the input.
  • Generate practice: Keep the input recognizable; explain the wait and offer cancellation or recovery.
  • Answer questions: Make the question, answer controls, and submission clear. Do not reveal explanations prematurely.
  • Review feedback: Distinguish correct, incorrect, and insufficient evidence. Source review should return to the same answer position.

This list defines the prototype scope. Do not add accounts, history, or billing merely because a template includes them.

Plan the Page Ending

The main content supports the current task. A footer gives the page a clear ending and a place for help, contact details or usage information. Footer.design collects footer examples organized by styles such as grids, typography, illustration and animation. Identify the information groups before considering decoration.

For the quiz tool, a footer could include “Help,” “Report a problem” and “Privacy.” A few links can share one row. With more categories, group help and feedback under support and keep policy information together. Keep “Generate practice,” “Submit answer” and “View source” near the tasks they serve.

You could request: Place a fine divider and footer after the main content, retaining the existing help, feedback and information links. Arrange them horizontally on desktop and let them wrap on mobile. Use descriptive link text and visible keyboard focus, with the footer scrolling in normal document flow.

2. Establish Information Hierarchy

An interface should answer: Where am I? What can I do now? What happens next? Check those questions in a wireframe before refining color, spacing, and decoration.

Give the next action a clear place — A wireframe for the answering state. Explanations appear after submission.

A wireframe for the answering state. Explanations appear after submission. View full-size

Answering is the primary task, so the question and choices lead. Source material is available on demand; feedback appears after submission. Establish this order before making every module an equally prominent card.

Turn references into explicit requirements

Instead of asking an agent to “copy this screenshot,” identify the parts worth borrowing and the existing rules to retain:

  • Layout: Is the reference about a split view, content width, or spacing?
  • Hierarchy: How do headings, body text, and supporting notes differ? Which action leads?
  • Components: Reuse established buttons, fields, navigation, and feedback patterns.
  • Boundaries: Design narrow screens, error states, and long content that the reference does not show.

Use an existing component library or the project's current stack. Confirm the task and states before adding dependencies. The GOV.UK guide to making prototypes explains the uses of different fidelities, from paper to code. Choose the fidelity that answers the current question.

Define a Visual Direction

Once the flow is clear, describe the character of the page. Anthropic's frontend aesthetics guide recommends specifying typography, color, motion, and backgrounds, providing concrete references, and identifying generic defaults to avoid.

For our quiz tool, “quiet and suitable for reading” can become this visual brief. These are example decisions; replace them with the rules of your project.

Design areaA concrete instruction for the agent
TypographyReuse project fonts; distinguish headings, body, and notes. Wrap long questions naturally and choose a readable measure and line height
Layout and spacingMake answering the primary desktop area, with source material available on demand. On mobile, put the question first; group related information and use consistent spacing
Color and backgroundRetain the light background, neutral grays, and fine rules. Make the primary action clear; accompany error and selection colors with text or shape
Motion and feedbackUse motion to explain a view change or panel appearing. Keep the answer area stable and show the final state directly when reduced motion is requested

In an existing product, inherit its design rules first. The guide's font exclusions, dramatic type contrasts, and background effects are example preferences. This site retains its established two-font, neutral-gray direction. Check Chinese glyph coverage, fallback fonts, and mixed-language text separately; an English specimen alone is insufficient.

Extract Rules from References

When a page appeals to you, identify the specific decision worth borrowing. Refero Styles organizes website examples into typography, color, spacing and component rules, with formats such as DESIGN.md. Use its method to turn a visual preference into instructions an agent can reuse.

Observe one decision, write one rule, then define its limits. For the quiz tool:

What you observeA requirement for your own project
Prominent headings and quieter body textReuse project fonts, distinguish heading and body roles, and check wrapping with real long questions
Related content sits together, with space between groupsKeep questions and choices together; disclose source evidence on demand instead of importing the reference's entire layout
One action leads visuallyPrioritize “Generate practice” after material input; keep “Use sample” secondary and specify waiting and failure states

Keep three things: the reference, the adopted rule, and what still needs validation. Update the project's existing design notes, or maintain a DESIGN.md. The filename matters less than concrete, checkable rules that stay aligned with the implementation.

Refero's example notes distinguish normalized styles, interpreted recommendations and reconstructed examples. Treat these as design references, rather than official brand specifications or original component code. Check the reference's fonts, buttons and palette against your own project before adopting them.

3. Describe the Behavior

“Make it polished” and “add animation” are hard to verify. Beginners do not need to memorize every component name. Start with:

Object → trigger → visible change → completion and boundaries.

Vague: Make the card move.
Specific: On pointer hover, raise the practice card by 4 px over 200 ms and darken its border; restore it on pointer leave. Use an outline for keyboard focus and direct activation on touch. Remove the movement when reduced motion is requested.

The duration and distance are adjustable example parameters. They describe a visual transition, not a promise that a business request finishes in 200 ms.

Turn observations into requirements through see the effect → learn its name → identify adjustable decisions → describe your own requirement. Identify the object on screen, record the wording, position, spacing or state to change, then check the result using your own content.

Describe an Action Entry

“Make the button stand out” leaves its purpose unclear. A call to action (CTA) should explain what to click, what follows, and which action takes priority. CTA.gallery collects buttons, forms, downloads and other action entries. Inspect wording, placement and priority; inclusion in a marketing gallery does not establish conversion performance.

Compare two actions using the same material in the quiz tool:

ComparisonWhat to observe
Replace “Continue / Try” with “Generate practice / Use sample”Can someone predict the next step before clicking?
Keep explicit wording, then emphasize “Generate practice”Is the main action easy to find, while the secondary action remains recognizable?
Activate the action and inspect waiting and failureAre duplicate submissions prevented, material retained on failure, and retry clearly available?

You could request: Make “Generate practice” the main action after the material field, with “Use sample” secondary. During generation, explain the wait and prevent duplicate submissions. On failure, retain the material and offer retry. Check wording, visual priority and request states separately; stronger button color cannot answer every question.

Change One Dimension

The guide also demonstrates typography-only prompts and theme constraints. Here, apply that approach to a bounded iteration: identify the intended improvement, then compare the result.

  1. Keep a baseline: Capture the same content, state, and viewport before editing, with both desktop and narrow-screen examples.
  2. Limit the pass: For example, “Adjust only the question page's text hierarchy and paragraph spacing. Retain layout, palette, buttons, and answering behavior.” Keep the scope of a typography change explicit.
  3. Compare and try: Check hierarchy, long Chinese text, and mobile readability, then complete answering and source review again. Record observations instead of accepting “more polished” as a test result.

Use the lab next to connect these decisions with examples you can operate.

Try the Interface Lab

I built this lab to help newcomers to web design put the interface they have in mind into words. Try the examples and use them to describe what you want for your own project. I'll keep adding styles, animations and fonts, and you can collect designs you like to build a UI inspiration library of your own.

Open the interactive lab →

Explore with a Question

Start with Refero Styles, CTA.gallery and Footer.design to understand page rules, primary actions and page endings. Scrolltide and Scroll Shaders are optional advanced resources once the task, content hierarchy and recovery are clear. Choose one question at a time and leave with a requirement in your own words.

Where you are stuckReferenceWhat to take away
You like a page but cannot describe its styleRefero StylesExtract typography, color, spacing and component rules into your visual brief or DESIGN.md
You need to clarify the next actionCTA.gallerySpecify action wording, position, priority, and waiting and result states
You need to decide how a page endsFooter.designList retained links and groups, with desktop and mobile arrangements
You need to describe a scroll effectScrolltideSelect one object and specify its trigger, movement, ending, touch behavior and reduced-motion alternative
You need to assess an animated backgroundScroll ShadersCompare color, speed and intensity with your text; record readability and a static alternative

First distinguish the scroll trigger. Scrolltide offers scroll-related templates, components and generation prompts. For one local effect, distinguish “play once on entering the viewport” from “continuously follow scroll progress.” Hold content, layout and color constant, then compare one change at a time.

For example: Fade the explanation region in once when it first enters the viewport; keep it visible when returning. Let body content scroll normally and show it immediately when reduced motion is requested. For continuous scroll effects, also define where the change starts, ends and reverses. Turn observations into these rules before asking an agent to implement them.

Check text readability before choosing a background. Scroll Shaders presents WebGL backgrounds and related components. Overlay your headings and body text while comparing color, speed and intensity. Does text remain readable throughout, does motion keep pulling attention, and does the page still work when the effect stops?

For the quiz tool, keep questions and choices on a static surface. Try motion in an introductory area if atmosphere serves a purpose, with a still image or solid color as an alternative. A working preview does not validate performance on your devices and page; check an actual phone and long content.

Check the design lesson and asset permissions separately. The lab does not embed templates or shaders from these reference sites. Scrolltide's terms and Scroll Shaders' license distinguish finished-project use from resource redistribution. Check the specific permissions before copying code, downloading assets or offering reusable examples. Public references were checked in November 2026; changing catalog counts and prices are not selection criteria here.

4. Reduce Interaction Burden

Fewer clicks and denser screens need to serve the task. Automatic generation may save a click, but uploading private material or incurring charges requires an explanation before the trigger and confirmation where the product rules require it.

For the quiz tool:

  • Reduce searching: Keep material, the current question, and progress in predictable places. Show submission feedback nearby.
  • Reduce remembering: Preserve the current selection while inspecting the source.
  • Reduce guessing: “Submit answer” is clearer than “Continue.” A busy button should communicate its action state.
  • Reveal details on demand: Collapse explanations and full material where appropriate, with discoverable entry points.

Keep the task order across screen sizes — A secondary source panel can move into a drawer; preserve the current answer.

A secondary source panel can move into a drawer; preserve the current answer. View full-size

Desktop may show questions and source side by side. On mobile, prioritize answering and open the source on demand. Responsive design preserves task order; shrinking the desktop is insufficient.

Check these directly

  • Keyboard: Reach controls in order, see focus, and return to the opener after dismissing an overlay.
  • Touch and narrow screens: Essential actions must not require hover. Controls remain usable without page-wide horizontal scrolling.
  • Meaning: Give errors textual explanations. Do not communicate selection or completion through color alone.
  • Motion: Respect the system's reduced-motion preference. Status must remain understandable without animation.

These checks relate to WCAG 2.2 requirements for keyboard access, focus, reflow, and status messages; performing a few checks does not establish conformance to the whole standard. Browsers expose the motion preference through prefers-reduced-motion.

5. Design Waiting and Recovery

AI mockups often show only input and an attractive final result. Prototype the intermediate states to discover repeated clicks, premature impressions of completion, and lost material.

StateWhat users should understand and be able to do
EmptyKnow the supported material and next action; optionally try a sample
Invalid inputSee the reason near the field, with entered content retained
RunningSee genuinely available status; avoid duplicate submissions
Partial outputKnow it is unfinished and what remains missing
CompleteSee the result and next action, beyond a success notification
Failed or canceledKnow what is retained, how to retry, and whether another charge applies

Do not invent progress. If the backend can only confirm “accepted” and “generating,” show those states. Without a basis for total work, do not display a precise-looking percentage. The lab explicitly labels its progress as a local simulation.

Streaming does not establish faster processing. It can reveal output progressively, but measure time to first useful content separately from full completion. Durable queues, background execution, and recovery belong to chapter 08 on production upgrades. Here, define what the person sees and controls.

For example, retain material when quiz generation fails and offer retry. A prototype's Cancel button defines intended behavior; whether the server can stop work and what happens to charges still require contract confirmation.

6. Build a Clickable Prototype

Give the agent the core task, scope, API contracts, existing visual references, and state rules. Use controlled mock data to make the full path testable first.

Attach a behavior description to the relevant component. One applicable description from the lab is more useful than ten unrelated animations in a broad prompt.

Then compare the prototype with chapter 03's contracts: does the data exist, can errors be distinguished, and do cancel and retry have matching meanings? A behavior working with mocks does not mean the real service supports it.

7. Validate with a Task

Walk the full flow yourself, then ask someone resembling the intended user to try it. Give a task without teaching each click. Record hesitation, misunderstood wording, and unnecessary backtracking.

For example: “Use this material to complete a quiz, check the evidence for a wrong answer, and return to your practice.” Observe completion and points needing explanation. Do not claim efficiency gains without measurement.

Bring these into the next stage

  1. A clickable prototype: One complete task and an accessible failure branch.
  2. Views and state rules: Who triggers each change, what appears, available actions, and when it ends.
  3. Component and layout decisions: Reuse, mobile behavior, and draft retention.
  4. Trial notes and open questions: Observed problems versus items needing real services or users.

Connect real features and data in the next stage. Replace mocks scenario by scenario and verify again. The prototype's central deliverable is a shared, checkable understanding of what should happen.

← Back to Notes