Iteration history must be revisitable

What it is

Four rounds of edits. Round three was actually better; round four broke the tone. If the surface keeps only “the current piece,” round three is already gone. Revisitable iteration history requires that every generation or local change leave a node you can return to: the input then, the artifact then, the parameters then. Revisit is not undo-last — undo is a stack, history is a timeline. Without a timeline, iteration is a one-way street, and people refuse to change again for fear of never seeing a version once more.

Local beating a full redo, and freezing what was not asked, still live inside “how this round walks.” History owns “how the rounds already walked are still here.”

Why it happens

Iteration’s value is comparison. Without the previous version, evaluation runs against a residue in the head. Working memory will not hold wording from three rounds ago; the residue mis-scores “seems smoother” as the current being better. If versions cannot be opened, comparison cannot be externalized, and people privately build history with copy-paste. If that private build fails (didn’t copy, copied into the wrong window), that version dies.

Generation is also unreproducible: even with the prompt still there, another run is not that piece. History must therefore store the artifact itself, not the prompt hoping for a replay. Parameters and model version must travel with the node, or opening a revisit is a cousin from another world.

Studying it

A multi-round revision task, with a clearly better version inserted in the middle and a clearly worse one after. Watch whether people can return to that version, and by what strategy (in-UI history, manual copy, rewrite from memory). Independent variables: whether a timeline is offered, thumbnails versus full text, undo-one-step only, whether nodes carry parameters. Dependent variables: success returning to the target version, rate of privately built history, share who stop iterating early for fear of loss.

If the experimenter reminds “you can copy,” private-build becomes homework and hides a product that lacks history. Cleaner: no reminder; just watch who select-all before they change.

Where it stops holding

One-shot irreversible outbound sends (mail already gone) cannot be altered by revisit; history only helps the next letter. In collaboration, history without author marks lets anyone make someone else’s version current. Full artifact storage for very long threads has a cost; sampling or storing only pinned nodes is allowed — “pinnable” is still history, not none. This entry does not require jumping to arbitrary internal decode steps, only that each user-visible artifact remain. It also does not treat failed reference, or peripheral edits destroying trust.

Applying it

• Each submit lands a node: input, artifact, parameters, time. The list should be scannable, a node openable as current, without destroying nodes after it (fork, not truncate).
• Do not let one-step undo stand in for a timeline. Undo can stay; round three must still be tappable.
• Offer pin. Pinned nodes skip automatic cleanup and export as that version’s original text.
• Check: four rounds, round three best. Close the page, reopen, ask whether round three can be made current. If you can only return to round four, or undo 4→3 with four then gone, history is not a timeline. Then check nodes that stored only the prompt and regenerate a new piece on open — that is replay, not revisit.

Related

• Same group: L2.05.1 Local revision beats regenerating the whole · L2.05.2 A revision must leave unmentioned parts unchanged
• Nearby: L2.07 Prompt History and Reuse · L2.12 Iterative Edits and Local Regeneration · L1.11 Reproducibility of Non-deterministic Output
• Search terms: revisitable iteration history · generation timeline · versioned prompt-output