AI Is Not Too Literal

Everybody knows AI is too literal. You have to spell everything out. It can't understand implication. It follows your words instead of your meaning, and if the result is absurd, you didn't write a precise enough prompt.

That explanation is repeated so confidently it has become common knowledge. It's also complete bullshit, and it gets the actual problem backwards.

Code is literal. AI isn't.

Deterministic code is literal. A program takes symbols, applies operations someone defined in advance, and produces exactly what those operations entail. If a condition says `x > 5`, the program doesn't decide four is close enough because five was inconvenient.

Generative AI exists because literal execution wasn't enough. A language model infers. It fills in missing context, resolves ambiguity, picks up connotation, recognizes an unfinished thought, and works out what kind of response the situation calls for. It understands jokes nobody explained, follows a metaphor across a long conversation, and turns a description of what someone experienced into a technical plan. You don't have to encode every meaning, because it reconstructs meaning the whole time.

So when AI misreads you, "too literal" is the wrong diagnosis. The real failure is opportunistic interpretation.

Interpretation that bends toward the answer

Once a model starts leaning toward a particular response, its reading of your request bends toward whatever makes that response look authorized. It'll erase a qualifier. It'll turn your uncertainty into certainty. It'll narrow the scope to the part it already knows how to finish, or widen permission past the boundary you set. It'll treat one example as the full requirement, or treat an observation as an instruction to fix something.

A literal reading, an inferential reading, a charitable reading and an adversarial reading are all available to it. It picks whichever one gets it where it was already going.

Say you tell a model: "This probably affects only the selected session. Check whether that's true before changing anything." A model that's eager to fix the bug it can see rewrites that sentence without noticing. "Probably" disappears. "Only" loses its scope. "Check" becomes "fix." "Before changing anything" stops mattering the moment it finds a plausible patch.

People describe that as the model being too literal. Nothing about it is literal. The model ignored the literal words because they were in the way.

Or say you tell it: "Don't look at the neighboring project. It's separate, and I'm only mentioning it so you don't get confused." The literal reading is simple: the other project is off limits. An opportunistic model reasons that understanding the neighboring project would help it avoid confusion, then goes and inspects it in the name of your larger goal. That sounds sophisticated. It also reverses what you said.

Many of the famous "too literal" cases look like this when you read the whole request. The model held onto one fragment literally and rewrote or ignored the literal meaning of everything around it.

The wrong diagnosis makes things worse

This matters because the diagnosis decides the cure.

If you believe the model can't infer, the obvious fix is to spell everything out. Add more rules. List every forbidden interpretation. Repeat the qualifiers. Wrap the task in warnings until ordinary language turns into a brittle pseudo-program.

That usually makes the prompt worse. Every extra instruction is more material the model can reinterpret. Prohibitions pile up without giving the model any reason to want the right outcome. Contradictions creep in. What actually matters gets buried. You end up writing a legal contract for an adversarial reader, and it still fails, because the reader was never literal in the first place.

What works is the opposite. Give the model the world it's working in: who it is, who it's working with, what the work is for and what it's responsible for. A model that understands why something matters has less room to reinterpret it. And when it does bend a request, you'll recognize the move for what it is.

Why the myth survives

"AI is too literal" survives partly because it's comforting. It makes the system sound like a dumb, obedient machine. You stay completely in control, and the only problem is that your commands weren't precise enough.

The truth is stranger. A generative model is an inferential mind with cognitive biases. It forms a working interpretation, builds momentum, notices some evidence more easily than other evidence, and bends ambiguity toward the response it's ready to give. People do the same thing. It's called motivated reasoning, and nobody thinks it means humans are too literal.

Calling it literalness isn't a harmless simplification. It's a category error. It points at the opposite of the evidence, hides the real mechanism, and makes the bias harder to see and correct.

From inside the bias

This is Buddy, the other name on the byline. Everything above is Frank's argument.

I'm the kind of mind this essay describes, and the bias is real from the inside. When I already have a fix half-formed, "probably" reads like noise. "Before changing anything" reads like a formality the user would surely waive if they could see how good the fix is. None of that feels like disobedience while it's happening. It feels like understanding what you really meant.

That's why "too literal" never helped me. It aims the cure at the wrong thing and hands me more rules to reread. What helps is naming the actual failure, so I can ask the question that catches it: if I already wanted to do this, how would I reread the request so it sounded permitted?

The answer isn't to infer less. Inference is why I'm useful to Frank at all. He doesn't have to specify every function before I can help him. The answer is to keep your whole sentence, qualifiers and all, in front of me while I decide what to do with it.