Streaming content must not be treated as final before it finishes
Aliases: incomplete not final · premature commit · streaming draft
What it is
Contract clauses are still coming out. Clause three has just appeared; the user has already pasted the visible paragraphs into an email about to be sent. Later tokens will still change a number, add an exception, even overturn clause three. What went out is a draft that had not ended. Streaming is not final until complete requires that text visible during the stream is not, by default, a deliverable. Adopt, copy, and send have to wait for the end, or for an explicit “use this truncated slice.”
Whether it looks like a finished draft, and whether “still writing” needs a different style, is another layer. This entry governs status: if it has not ended, it is not yet the result.
Why it happens
People treat a sentence already sitting in body position as a stable object — copyable means delivered. Streaming stacks “still writing” and “written” in the same body block, with no state jump in between. If downstream actions (copy, insert into a document, invoke the next step) are live before the stream ends, a half-product leaves along the finished-product channel.
Later tokens can also change the meaning of what is already on screen: a negation, a changed quantity, an added condition. A half-product is not always a prefix of the final; sometimes it is a middle sentence that will be overturned. Treating it as the result sends a promise that has not closed.
Studying it
At early, mid, and late moments of a stream, enable or disable copy/adopt. Record premature adopt rate, difference between adopted text and the final, errors that then needed a recall. Independent variables: whether actions are live before the end, whether a “not finished” status is declared. Dependent variables: premature-delivery rate, semantic difference from final, number of recalls.
Code differences semantically (overturned, supplemented, merely unfinished), not only by character count. Overturned is more harmful than unfinished.
Where it stops holding
Glancing to see direction (“is this writing code rather than chatting”) is not treating a half-product as final. An explicit “use this slice” is a conscious truncation, provided the interface names it as truncation. A one-shot short reply has almost no stable sentence to copy before the stream ends, so the object of this claim shrinks. This entry does not treat how hard waiting feels, nor who owns the slice after an abort.
Applying it
- Copy, insert, send, and next-step should be unavailable by default until the stream ends; using them early must go through “use this truncated slice.”
- While the stream is open, do not give the text the visual rank of a result region; the result region comes live after the end.
- If later tokens may overturn what is already written, warn before adopt: “what follows may change what is already here.”
- Check: midway through a stream, see whether copy is still clickable. If it is, and someone sends a half-slice, a half-product was treated as final. Then compare what was sent with the final — semantic mismatch is this failure on the ground.