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.
-
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