The Hidden Cost of the Backspace Key

You can measure this directly rather than estimating. Take an ordinary timed test, note the result, then take the same length of test with backspace disabled.

What the second one removes is not your errors — you will make the same number — but your ability to repair them. So the gap between the two scores is not a measure of your accuracy. It is a measure of what repairing was costing you, expressed in the same units as your speed.

Most people are surprised by the size of it, and surprised in a particular direction: their no-backspace score is much closer to their normal score than expected, because the errors they were fixing were fewer than the time spent fixing implied. That is the informative part. A small number of errors can consume a large amount of time, which is exactly the asymmetry that makes accuracy work pay.

The no-backspace test exists for this measurement specifically, and it is worth doing once even if you never do it again.

The backspace itself is the cheapest part of what a correction costs you, which is why counting backspaces understates the problem so badly. Detection, the interruption, the removal of everything typed since, the retyping, and the sluggish few words while your reading catches back up are all in there too, and the full accounting is done properly in accuracy versus speed.

The figure that comes out of that accounting is the one worth carrying around: a single mistake runs to roughly a dozen keystrokes' worth of time. That multiplier is what this whole post rests on. It explains how a typist with an error rate they would describe as good can still be losing a third of their keystroke budget, and it explains why nobody notices — because no individual correction feels like twelve of anything.

Of those costs, the one that varies most between people is the first, and it is almost never practised.

Catch a mistake on the next character and you throw away one character. Catch it five words later and you throw away five words, because everything after the error has to go too. Nothing about the accuracy differs between those two cases; the entire difference is how long the error was allowed to stand.

Detection is a separate skill from accuracy, and it responds to different practice. Typing without looking at the screen at all makes it worse; typing while genuinely reading what appears makes it better. So does slowing down, which is one of the less obvious reasons that deliberately reduced pace improves output rather than merely reducing errors.

This is what the error recovery drill is built around — the seconds after the mistake rather than the mistake itself, which turns out to be the more trainable half of the pair.

Here is the part that inverts the intuition, and it is why this is not merely advice for beginners. The penalty is not constant across skill levels; it grows as you get quicker, for reasons the accuracy versus speed guide works through, and the practical upshot is that a tolerance you built at a modest pace becomes a wall at a higher one.

So the received order of operations — build speed, tidy up accuracy afterwards — is backwards, and expensively so. It has you deferring the work that grows more valuable precisely as you defer it. Someone who arrives at a ceiling in their eighties having never done accuracy work is in the worst position to begin, because by then the habit of pushing and repairing has been rehearsed tens of thousands of times. One specific way that bites is catalogued in why typing speed plateaus.

There is a generation of typists whose felt accuracy substantially exceeds their measured accuracy, because they learned on surfaces that silently repaired their mistakes.

A phone keyboard fixes transpositions and misspellings without telling you. A word processor underlines errors and offers corrections. Both produce clean output from imprecise input, which is excellent for the output and terrible for the feedback loop — you never find out how often your hands were wrong.

The result is a specific shock: a plain text field, a command line, a search box or a typing test produces an error count that feels impossible. Nothing has changed about the typing; what has changed is that nothing is hiding it any more.

That is a whole argument in itself and I have made it at length in autocorrect changed what accuracy means. The relevance here is that a lot of people carrying a large backspace cost are carrying it without knowing, because the thing that would have told them has been fixing it invisibly for years.

Deliberately removing backspace is a strange-sounding practice technique that works for a reason worth stating.

With correction unavailable, the only way to produce correct text is to type it correctly the first time, which forces a pace where that is achievable. Most people discover that pace is considerably slower than the one they habitually use — and that the output at the slower pace is not much lower, because they were spending the difference on repairs.

That discovery is the point. It converts an abstract argument about accuracy into a number about your own hands, and it does it in one attempt rather than over weeks.

The more extreme version of the same idea is One Life, where a single wrong character ends the run — which inverts every strategy on the site, since with no recovery at all the optimal pace is the slowest you can bear. Both are worth doing occasionally, not as a way to type, but as a way to find out what you have been paying.