Problem
The answer is technically responsive and useless. The viewer can’t point at what’s wrong well enough to write a correction, and their instinct is to ask again. Retyping the question means retyping the question, which is the part they were trying to avoid.
Solution
Re-run the same prompt against the same context and show what comes back. Because sampling is stochastic, the second answer differs from the first, sometimes substantially. Being honest about that mechanism matters: this is a dice roll rather than a repair, and an interface that presents it as a repair is overselling.
The design question is what happens to the answer that was already there. Three options, and the choice determines whether the pattern is useful:
- Replace it. Cheapest to build and the worst outcome. The viewer regenerated because the first answer was partly right, and now the part that was right is gone with no way back.
- Append a new turn. Preserves everything and fills the transcript with near-duplicate answers to the same question, which makes the conversation unreadable after the third try.
- Keep both and page between them. A counter on the turn,
2/3, with arrows. The transcript stays linear, the comparison survives, and the viewer can land on whichever attempt was best.
The third is the strongest and carries a consequence worth naming: once a turn holds several responses, the conversation is a tree rather than a list. Continuing from response two produces a different future than continuing from response three. Most products keep the tree and hide it, letting the current selection define the visible thread, which is the right default and means the branch point needs to be discoverable when someone goes looking for it.
The far more useful version gives the retry a direction. Try again with a different model, shorter, more formal, without the code. This converts a reroll into a directed edit, which is HAX guideline 9 in its proper form: make it easy to steer the system when it gets things wrong. A bare retry gives the model nothing it didn’t already have.
Regeneration is also the loudest implicit feedback signal a product receives. It’s coarser than a thumbs-down and far more honest, because nobody clicks retry to be polite.
Use when
Output varies meaningfully between runs and the viewer can judge quality in a few seconds of reading. Drafting, summarising and naming things all qualify.
Don’t use when
The task has a right answer the model either reached or didn’t. Rerolling an arithmetic error or a factual lookup is superstition, and offering the control there teaches a bad habit. Also avoid it where a response has already caused a side effect, since the second answer can’t undo the first one’s consequences.
Trade-offs
Regenerate is cheap to offer and teaches the viewer to reroll instead of writing a better prompt, which makes their outcomes worse over time while feeling productive. Every retry is a full billed generation of the entire response. Keeping alternates makes the transcript a tree the viewer can’t see the shape of. And the pager itself is easy to miss, so a product that preserves three answers and shows the arrows at low contrast has paid the storage cost for nothing.
Checklist
- Does the previous response survive, and can the viewer get back to it?
- Is the count of alternates visible without hovering?
- Can the viewer give the retry a direction rather than rerolling blind?
- What happens to turns that came after the one being regenerated?
- Does the model know it is being asked again, or does it see an identical fresh request?
- Is a retry recorded as a quality signal anywhere?
- Does each regeneration bill, and does the viewer know that?
- Is the control offered on tasks where rerolling cannot help?
- Can the viewer compare two alternates side by side, or only one at a time?
- When the conversation is shared or exported, which alternate goes with it?
Compare
ChatGPT keeps earlier attempts on the turn behind a small pager, so the transcript stays linear while the branch is preserved underneath it. Gemini has historically gone the other way and surfaced multiple drafts as a first-class thing to look at rather than something to page through, which treats variation as information instead of an accident. Claude attaches retry to the response and lets the model be switched at the same time, so the second attempt is a different question rather than the same one asked twice. Perplexity frames the rerun around the source set rather than the prose, so trying again is closer to searching again than to rewriting.
Related
Stop generation is the other correction control and fires earlier in the same sequence. Response actions is the row this button sits in. Edit and resend is the version that changes the question instead of rerolling the answer, and is usually the better move. Model picker is what makes a directed retry worth having. Usage meter is where the cost of three attempts becomes visible.