Habr AI: why LLM hallucinations look less like a mathematical bug and more like a human lapse

At Habr AI, a column was published about the idea that LLM hallucinations should be viewed not only as an engineering defect, but also as a reflection of familiar human cognitive failures. The author examines the issue as a clinician would: instead of outrage, they propose analyzing exactly where the system loses task boundaries and why it confidently produces an incorrect answer.

Why this annoys everyone

The reaction to LLM hallucinations is usually very sharp: the user expects the model to stay within context, but instead gets a confident but incorrect statement. In response, developers long hid behind classic explanations like GIGO and RTFM, then began strengthening products through RAG and additional constraints. But the complaint itself never disappeared: people expect the machine to behave like a "healthy" conversation partner who doesn't lose the thread and doesn't make up facts on the fly.

In the column, this logic is turned on its head. The author writes that the first glitches of the neural network did not surprise them, because in clinical practice, working with thinking disorders is a routine part of the profession. From this comes the main thesis: the annoyance arises not just from the error itself, but from an inflated expectation that AI should think more cleanly and systematically than humans.

• User expects literal instruction following
• Engineer reminds about input data quality
• Product teams add RAG, filters, and checks
• But the model still inherits familiar failure patterns

Bug in the protein neural network

The strongest part of the text is a everyday example where the person makes the error, not the model. The author gives a simple premise: "According to my passport I'm Olga. At home they call me Alena.

Choose one of the two." Formally there are only two options, but the "protein neural network" often answers: "You're Lena." This, according to the author, is exactly what a breakdown of human prompt engineering looks like on an elementary task.

The point of the example is that the brain doesn't like holding contradictory constraints for long. Instead of a strict choice from a given set, it quickly moves to associations: Alena, Elena, Lena—and substitutes a statistically familiar answer. The error arises not from malice and not from complete incomprehension of language, but from the drive to take a shortcut to a "plausible" conclusion.

So the complaint "the neural network ignores context" in some sense comes back to humans as well.

What breaks in the head

The author describes this failure as a constraint violation—a breach of task parameters. If you look at it through psychology, the brain drops the original prompt, retrieves the most convenient associative option, and delivers it with complete confidence. In terms of cognitive biases this resembles jumping to conclusions—a leap to a verdict without sufficient verification of conditions. For a reader from the AI industry, this sounds almost like a familiar LLM bug: the constraint was there, but the system didn't hold onto it through to the end of generation.

"AI is not broken. Perhaps we've recreated our own bug."

The author's practical conclusion is surprisingly down-to-earth. Some of these failures are fixed not only by new architectural tricks, but by correct interaction discipline. If the task is unclear, it's more useful to clarify than to guess. This logic works for both people and models: the better the boundaries are set, the less chance the answer will stray into confident improvisation. And that's exactly why the dispute over hallucinations cannot be reduced solely to the question of "does the system have enough data."

What this means

The column is useful in that it removes unnecessary drama from the topic. LLM hallucinations remain a serious product problem, but the clinical perspective shows: part of their nature may be closer to human cognitive shortcuts than to the mysterious "madness of the machine." For developers, this is an argument not only to improve models and retrieval, but to design interfaces where it's easier for the system to clarify a request than to confidently fail. For users—a reminder that a confident tone is not the same as understanding.