Before You Finish Asking
A wrong answer announces itself, eventually. You act on it, reality pushes back, you go looking for the mistake. That correction loop is what makes wrong answers survivable. The failure nobody built a loop for is the one where the answer is right, for a question you didn't mean to ask.
Clinical diagnosis has a name for the underlying move: premature closure. You accept the first explanation that fits and stop looking before you've ruled out the others. It's one of the more common sources of diagnostic error, more common than plain ignorance. The doctor isn't missing the fact. The doctor found a fit that felt complete and quit searching.
Autocomplete turns that from an occasional lapse of attention into a structural feature of the interface. You start typing a search, a prompt, a line of code, and before the sentence in your head is finished, something else finishes it for you, fluently, plausibly, fast enough that stopping to check whether it finished it correctly feels like extra work you didn't sign up for.
"Wrong" barely applies here, which is what makes the failure hard to catch. A wrong answer to your actual question is a bug you'll eventually trip over. A right answer to a question you didn't mean is worse, because it closes the case. It holds together, it answers something, and the something it answers is close enough to what you meant that the swap doesn't register. Nothing downstream complains, because nothing downstream knew you had a different question in mind. You barely knew yourself.
Type "why does my" into a search bar and take the suggested ending, and you're reading about a symptom cluster adjacent to the one that was actually bothering you, plausible enough that the mismatch never surfaces. Send a chat model three words of a half-formed prompt and get back four confident, structured paragraphs, and the fluency of the answer retroactively makes the prompt look like it was already finished, even though it wasn't. Let a code completion tool finish the function before you've worked through the edge case yourself, tab-accept it, and move to the next line, having skipped exactly the moment where writing it out slowly would have caught the bug.
None of that is the tool being wrong. Wrongness is the failure mode we built defenses for: tests, review, fact-checks, second opinions. Every one of those defenses fires against a specific claim you can hold up and inspect. Premature closure doesn't leave a claim behind. It leaves a satisfied feeling. There's nothing to check against reality, because what got skipped wasn't an answer, it was a question that never finished forming.
The systems doing this aren't optimizing for whether your original question got answered. They're optimizing for whether you accepted an answer quickly and didn't come back. Those look like the same metric from outside, and they aren't. A completed session is good for the product and says nothing about whether the question you walked in with is the one you walked out having addressed. The cost of that gap lands on you, later, when you build on top of the answer and it doesn't hold, and by then you've forgotten there was a question underneath the one you got.
The fix, such as it is, isn't slower answers. It's noticing, before you take the fast one, that you hadn't finished asking.