Steer: tell the model what you mean, before it commits
Surface the assumptions. Name the ambiguity. Decide, then generate.
A blank box invites a loose request, and a loose request invites a confident guess. The model fills the gaps you didn't specify (audience, goal, tone) silently, and hands back fluent output that's wrong in ways you only notice after you've shipped it. Steer is an exploration of moving the decision earlier: parse the request into a visible brief, show the assumptions as editable chips, flag the genuine forks the model shouldn't resolve on its own, and let the person steer before a single word is written.
Fully interactive. Parse the request, edit an inferred assumption, resolve the either/or forks, then Generate with these settings and compare against Generate blind. Built on the Minia design system. Opens in desktop by default; use the toggle for the mobile layout. Data is synthetic.
The problem: a guess wearing the costume of an answer
The failure isn't a typo or a refusal. It's fluent, plausible output built on assumptions you never saw and never got to change.
Generative tools optimise for a frictionless first draft, so they treat every gap in your request as theirs to fill. Most of the time the guess is invisible, until the draft is confidently aimed at the wrong audience, pushing the wrong goal, in the wrong voice. Correction then happens at the most expensive moment: after generation, by re-prompting, when you've already anchored on what you read. The cheap moment to intervene is before, when intent is still a decision rather than a guess.
Inferred assumptionsguesses, each one click to override
Genuine forkthe model will not resolve this for you
Audience
-
You type a loose request
“Write a launch email for our new dashboard.” Natural, fast, and silent on audience, goal, tone, and format.
-
The model fills the gaps, silently
Four or five unstated decisions get made on your behalf. None surface; none are flagged as guesses.
-
It generates, confidently
The output is fluent and well-formed. Fluency reads as correctness, so nothing prompts a second look.
-
You find the wrong assumption, too late
Aimed at strangers when you meant customers. Now it's a re-prompt and a re-read, after you've already anchored.
The thesis: make intent a step, not an afterthought
The same model and the same request can produce a guess or an answer. The difference isn't the prompt. It's whether the gaps were decided on purpose.
Steer inserts one move between request and output: a brief the person can see and edit. Inferred details are shown as assumptions, labelled as guesses, each one click to override. Genuine forks, the decisions a model has no business making for you, are surfaced as choices, not resolved in the dark. Only then does it generate. Same effort as a re-prompt, spent before the mistake instead of after it.
Blind versus steered, rendered live in the Minia design system, the same theme as the prototype above.
Show the guesses as guesses
Every inference the model makes is rendered as an editable assumption, visible, attributable, and one click to change.
The danger of a silent assumption isn't that it's wrong; it's that it's hidden, so it can't be corrected until it's expensive. Steer turns each inference into a chip: tone, length, CTA, sender, marked plainly as something the model guessed. Leaving one untouched is a real decision (you've accepted the default); changing one updates the brief immediately. The person stays the author of intent; the model just drafts a starting point.
Inferred assumptions, made visible, rendered live in the Minia design system, the same theme as the prototype above.
Refuse to guess what actually matters
Some gaps shouldn't be filled by a model at all. Those are surfaced as forks, and an unresolved fork blocks a steered generation.
There's a line between a reasonable default and a decision that belongs to the person. Audience, intent, the core goal. Guessing these isn't helpfulness, it's overreach. Steer draws that line explicitly: low-stakes inferences become editable assumptions, but genuine ambiguity becomes an either/or choice the person must make. The model declines to resolve it silently, and says so. Naming the fork is itself the design. It teaches what the request was missing.
Ambiguity as an explicit choice, rendered live in the Minia design system, the same theme as the prototype above.
The payoff is auditable intent
When the brief is visible, the output is explainable. Every choice traces back to a decision someone made on purpose, not a guess nobody saw.
Try it in the live prototype above: parse the request, change an assumption, and watch the brief on the right update. Resolve the forks and generate, then flip to Generate blind and see the same model produce confidently-wrong output from the gaps it filled on its own. The decision log keeps a record of every steer, so a good result is reproducible and a bad one is diagnosable.
How it got here: v1 → v6
The composer wasn't designed all at once. Each version moved one more decision earlier, from re-prompting after the fact to steering before generation.
It started as a better prompt box and ended as a negotiation. Every step closed a gap between what the person meant and what the model assumed, until the assumptions were visible, the real forks were the person's to decide, and nothing got generated on a silent guess.
-
1
A bigger prompt box
More room to type, with placeholder hints. People still under-specified; the model still guessed.
-
2
+ Parsed-intent summary
Echoed back what it understood before generating. Read only, but at least the guess was visible.
-
3
+ Editable assumptions
Turned the summary into chips you could override, so correcting a guess no longer meant re-prompting.
-
4
+ Ambiguity forks
Separated low-stakes inferences from real decisions; the latter became explicit either/or choices.
-
5
+ Generation gate
An unresolved fork blocks a steered generation. The model won't fill a real gap without you saying so.
-
6
+ Blind/steered contrast · current
Made the value legible: run the same request blind and steered, side by side, and the difference is undeniable.
Explore more work
More explorations from the AI Product Design Lab, each a different facet of making AI products people can direct, verify, supervise, and trust.
Ground, verify what AI claims
Every claim traceable to a source with confidence and freshness; unsupported claims flagged; source conflicts shown, not smoothed over.
View exploration
Oversee, safe agent autonomy
A control surface for agents that take real actions: scope it, preview it with a dry run, interrupt it mid-task, and undo what's reversible.
View exploration
Recall, legible AI memory
A memory layer you can see, attribute, edit, scope, and revoke. Personalization as a negotiated, inspectable thing, not a black box.
View exploration