How Autocorrect Actually Decides What You Meant to Type

Every time autocorrect swaps a word, three separate signals have gotten about half a second to agree on what you actually meant, and most of the complaints about "autocorrect being dumb" are really about watching that quiet contest go wrong in public. The keyboard weighs where your finger actually landed on the screen, what the rest of your sentence is about, and what you personally tend to type — then picks whichever candidate word wins on points. Understanding those three signals explains both why it's usually right and why it occasionally produces spectacularly wrong substitutions.

Signal one: how far your finger actually landed from the key

Modern keyboards don't just register which key you pressed — they track the exact x/y coordinate of your touch relative to the center of each key. If you meant to hit "L" but landed slightly toward "K", the keyboard registers that as a near-miss rather than a deliberate "K" press. This spatial model is why autocorrect fixes typos from adjacent keys ("hwllo" to "hello") far more confidently than it fixes typos involving keys nowhere near each other.

Signal two: a language model scoring what's statistically likely

Behind the spatial layer sits a language model trained on huge volumes of real text, which assigns a probability to how likely any given word is to appear, both on its own and following the words that came just before it in your sentence. This is why the same typed word can autocorrect differently depending on context — type "I'd rather have tea then coffee" and the keyboard swaps "then" for "than" because it's scoring a comparison, but type "I finished eating then left" and it leaves "then" alone because the model recognizes a sequence of events immediately before it, not a comparison. Same input word, opposite outcome, because the model is scoring the whole phrase, not the isolated word.

Signal three: your own typing history

Both iOS and Android keyboards maintain a personal dictionary built from words you type repeatedly, including names, slang, and even words your device's default dictionary would flag as errors. Once a word survives several deliberate uses without you correcting it back, the keyboard treats it as a legitimate personal vocabulary entry and stops trying to "fix" it, which is why your friends' unusual names or brand terms eventually stop getting autocorrected away.

How the ranking actually gets decided

These signals — key-distance probability, language-model score, and personal dictionary weight — get combined into a single confidence score for each candidate replacement word. If the top-scoring candidate beats your literally-typed word by a wide enough margin, autocorrect silently swaps it in. If the margin is narrow, the keyboard instead just shows the alternative as a suggestion bubble above the space bar and waits for you to tap it, rather than forcing the change. That threshold-based split is deliberate: it's the system hedging between being helpful and being invasive.

Why autocorrect gets things spectacularly wrong sometimes

Failures cluster around a few predictable causes. Short, rare, but real words (like uncommon names) lose the probability contest to far more common words that happen to be nearby on the keyboard. Sentences using slang, code-switching between languages (very common in Indian typing, mixing Hindi/regional words with English), or deliberately unconventional phrasing confuse the language model because it's scoring against patterns from formal, common text. And autocorrect operates with no real understanding of meaning — it's pattern-matching probability, not comprehension, so it has no way to know a swap changed the sentence's actual intent as long as the resulting sentence is statistically plausible.

Why it's gotten noticeably better in recent years

Newer keyboard engines (Gboard, SwiftKey, and Apple's own) increasingly use on-device neural network models rather than older statistical n-gram models, allowing them to weigh longer sentence context and adapt faster to a user's personal writing style without sending data to a server. This is also why autocorrect quality has diverged noticeably between phones — it's now genuinely a machine learning feature with model quality differences, not a shared dictionary lookup everyone gets equally.

The pattern holds up once you know what to look for: common words in ordinary sentences get corrected with real confidence, while names, slang, and mixed-language typing sit right at the edge of what the model was ever trained to recognize — which is exactly where most of the legendary autocorrect disasters come from.