Skip to content
NakodaAI

AI FIELD MANUALDESIGNERS

A client pitch is in three days and the designer needs five genuinely different UI directions, not five variations on the first idea

Using AI UI-generation tools for fast, constraint-driven concept exploration - then treating the output as a starting point for real design work in Figma, not a finished deliverable.

Last reviewed 1 September 2026

THE PROBLEM

A freelance product designer has a pitch in three days for a fintech dashboard redesign. The client wants to see "a few different directions" before committing to one. Sketching five fully distinct, polished concept directions by hand in three days while also handling the rest of an active client load is a real time crunch, and the failure mode under time pressure is producing five directions that are really one idea with the header moved.

AI UI-generation tools can produce visual variations fast, but used carelessly they produce exactly the same trap faster: a vague prompt like "design a fintech dashboard" five times over tends to converge on the same generic dashboard patterns the model has seen most often in training data, just with different color themes - which looks like five directions and isn't one.

The fix is prompting for genuinely different *constraints*, not different colors, and treating anything generated as a fast first draft for real design judgment, never as the pitch deck itself.

THE APPROACH

Write five deliberately different design briefs - each constraining a different core decision (information density, navigation model, primary interaction pattern) - rather than one vague brief run five times. Generate from each brief separately, then bring the strongest elements into Figma for the actual polish, accessibility, and interaction-detail work no generation tool does well.

Constraint-first prompting is what actually produces different directions: "data-dense, table-first, power-user layout" and "card-based, glanceable, mobile-first summary view" are structurally different starting points; "modern fintech dashboard" repeated five times is not.

WHY IT WORKS

Generative UI tools are trained on an enormous number of existing interfaces and default toward the statistically common pattern for a vague prompt - a sidebar-plus-cards SaaS dashboard is the mode of that distribution. Forcing a specific, different constraint per brief pushes each generation away from that default mode, which is the only way to get outputs that are actually different from each other rather than superficially restyled.

Treating the output as a first draft rather than a deliverable matters because current UI-generation tools are reliably weak on the details that make an interface actually usable - real accessibility (focus order, contrast, semantic structure), edge-case states (empty, error, loading), and pixel-level interaction polish. A designer's judgment is exactly the layer that catches what the generation step cannot.

STEP BY STEP

  1. Write five different constraint briefs, not one repeated prompt

    For each direction, name the specific thing that makes it structurally different: e.g. table-first vs. card-first, sidebar nav vs. top nav, chart-forward vs. number-forward. Write each as its own short brief.

  2. Generate one concept per brief

    Run each brief through a UI-generation tool (v0 by Vercel, or Relume for a more marketing-site-oriented layout) separately - don't batch them into one prompt, which tends to blend the constraints back together.

  3. Screen all five against the actual client goal in five minutes, not fifty

    Quickly rule out any generated direction that doesn't structurally serve what the client actually said they needed (e.g. if the client explicitly wants fast at-a-glance status, a dense table-first direction may look impressive and be the wrong answer).

  4. Pick the two or three strongest and rebuild them properly in Figma

    Don't present raw AI-generated screens. Rebuild the structure and layout logic of the strongest 2-3 directions in Figma, using your own component library and actual brand tokens - this is where real design judgment (spacing, hierarchy, accessibility) replaces the generator's generic defaults.

  5. Add the states the generator skipped

    Loading, empty, and error states for the key screens - almost never present in a first AI generation, and exactly what separates a concept sketch from something a client should trust represents real product thinking.

  6. Present as directions with named trade-offs, not as finished screens

    For each of the 2-3 refined directions, state the specific trade-off it represents (e.g. "more information density, steeper first-use learning curve" vs. "faster to scan, less detail per screen") - this is what makes the pitch a design conversation instead of a beauty contest.

TOOLS

LIMITATIONS

  • AI-generated UI reliably underperforms on accessibility (semantic structure, focus order, real contrast checking against your actual palette) and on edge-case states. Never hand a generated screen to a client or a developer as-is - the Figma rebuild step is not optional polish, it's where the design work actually happens.

  • Constraint-first prompting reduces but does not eliminate convergence toward common patterns - if all five briefs still produce visually similar results, the constraints weren't actually different enough and need rewriting, not more generation attempts.

  • This workflow is for early concept exploration speed, not for final visual design or a design system. Brand-specific type, color, and component decisions still need to be made by a designer working from the brand's actual tokens, not inherited from whatever the generator defaulted to.

EXAMPLE

A fintech dashboard redesign pitch needs three genuinely distinct directions in three days.

  1. Five briefs written: table-first/power-user, card-first/glanceable, chart-forward/narrative, minimal/single-metric-focus, and comparison-forward/multi-account.

  2. Each generated separately in v0; the chart-forward and comparison-forward directions were screened out early as not matching the client's stated priority of fast daily status checks.

  3. Table-first, card-first, and minimal directions rebuilt in Figma with the studio's actual component library, brand type and color tokens applied.

  4. Loading, empty (no transactions yet) and error (sync failed) states added to the primary screen of each of the three.

  5. Pitch presented as three directions, each with a one-line trade-off: table-first ("more control, more to scan"), card-first ("faster glance, less depth per view"), minimal ("fastest read, requires drilling in for detail").

Three structurally distinct, properly detailed directions delivered in three days instead of one polished idea with two shallow variations - and a pitch conversation about real trade-offs instead of a single "do you like this" screen.

RELATED

Nakoda editorial · last reviewed

This entry describes a workflow Nakoda recommends - it is not a claim about how any named tool behaves in every case, and it is not paid placement. Spotted something out of date? Tell us.

Back to the Field ManualTalk to Nakoda