Typing for programmers: how to type code faster

You can be a 90 WPM typist on prose and still crawl through a line of code. Code is a different text. It is full of brackets, operators, underscores and capital letters in the middle of words, and it leans on keys that normal typing practice almost never reaches: the number row, the right pinky's corner of the keyboard, Shift held at awkward moments. Fortunately it is a small, specific skill, and it responds well to practice.

Does typing speed matter for programmers?

The usual line is that programmers spend most of their time thinking, so typing speed does not matter. The first half is true. The second half is wrong in a quiet way.

The real cost is interruption. If you have to glance down to find {, or you stop for half a second to remember which pinky does the underscore, that tiny stall pulls you out of what you were thinking about. Do that a few hundred times a day and it adds up to real lost focus. Fluent typing means the code goes from your head to the screen without your attention leaving the problem.

There are practical wins as well. Fast, accurate typists are more willing to write a clear variable name instead of an abbreviation, to type out a quick test, to rename something properly, or to write a commit message that says what changed. They also type longer, clearer messages to colleagues. None of that shows up in a WPM figure, but you can see it in the code.

So set a modest goal: never look down, and never hunt for a symbol. A respectable WPM follows from that.

Symbols and brackets

On a US layout, most programming symbols live on the number row (with Shift) and around the right pinky. In standard touch typing, each finger owns the number keys above its home key. Here is the usual assignment, with the symbol each key gives you with Shift:

The last row is the one to look at. The right pinky handles a huge share of the symbols in code, so it gets tired, and it is usually the least accurate finger a programmer has. Two things help:

• Use the opposite Shift. For any symbol typed with the right hand, hold the left Shift. For {, that means left pinky on Shift and right pinky on the bracket key. Using the right Shift for a right-hand symbol forces a painful claw and is a common source of errors.
• Return to home after every reach. The pinky travels further on the number row than any other finger. If it does not come back to ;, the next letter lands on the wrong key.

A symbol drill you can do today

Type each of these lines ten times, slowly and without looking, then speed up only once you get three clean repeats in a row:

• () [] {} <> () [] {} <>
• a[i] = b[j] + c[k];
• if (x >= 0 && y != 1) { return; }
• user_id user_name max_value is_valid
• "name": "value", 'key': 'val'
• !@#$% ^&*() !@#$% ^&*()

Five minutes a day on lines like these for two weeks makes a noticeable difference. Write your own lines from the code you actually work in: Python wants colons and underscores, JavaScript wants braces, arrows and semicolons, shell wants pipes, dollar signs and dashes.

The number row

Most typists never really learned the number row. They learned letters on a course and then picked up numbers by looking. In code, the number row is also where most of the symbols are, so this gap costs programmers more than anyone.

The fix is boring and quick. Take the finger table above and practise numbers alone for a few days: 1029 3847 5610 2938 and so on, eyes on the screen. Then mix numbers into words. Presspace has a numbers toggle on the options row of the typing test that does this. Then switch to symbols. Most people get comfortable within a week or two of short daily drills.

If you are not yet a touch typist on the letters, do that first. Our touch typing guide covers the foundations, and trying to learn symbols on top of hunt-and-peck letters is frustrating for everyone.

camelCase, snake_case and other naming styles

Identifiers are where code and prose look least alike. Each style has its own trick.

camelCase and PascalCase

Every capital letter mid-word means a Shift press, and the opposite-Shift rule applies. In getUserName, the U is a right-hand key, so the left pinky holds Shift; the N is also right hand, so left Shift again. The rhythm feels awkward at first because your brain wants a pause before the capital. Drill a list of real names from your codebase until the capitals stop causing a hitch.

snake_case and SCREAMING_SNAKE_CASE

The underscore is Shift+-, right pinky on the minus, left pinky on Shift. Because it repeats so often, it is worth drilling on its own: max_retry_count first_name is_admin. For constants, many people hold Shift for the whole word, which is fine, or turn on Caps Lock for the stretch, which works just as well.

kebab-case

Just the minus key, no Shift. Common in CSS and file names. It is the easiest of the lot.

A tip that helps with all three: type identifiers as one word in your head. "getUserName" should feel like a single shape. That comes from repetition, which is why practising on real code works better than practising on random symbols.

Let the editor type for you

The fastest programmers are often not the fastest typists; they just type less. A modern editor will happily write half your code if you let it.

• Autocomplete. Type the first few letters of a long name and accept the suggestion with Tab or Enter. This also kills typos in identifiers.
• Auto-closing brackets and quotes. Most editors insert the closing bracket for you. Learn how yours behaves: in many, typing the closing bracket yourself just steps over the one it inserted, so you can type naturally without ending up with doubles.
• Snippets. Short triggers that expand into common structures: a loop, a function, a test case. A few you write yourself for your own patterns save more time than any typing drill.
• Multi-cursor editing. Change the same name in several places at once instead of typing it five times.
• Line operations. Move, duplicate or delete whole lines with one shortcut instead of selecting them by hand.

A handful of VS Code shortcuts that pay off almost immediately:

Do not forget the plain text-editing shortcuts either: jumping and deleting by word with Ctrl (or Option on Mac) is just as useful in code as in prose. Our keyboard shortcuts guide has the full Windows and Mac tables, and the shortcuts trainer has decks for VS Code and the terminal.

A note on AI code completion: it reduces how much you type, but you still have to read, accept, reject and edit what it suggests. Fast, accurate editing (moving by word, selecting, deleting a line) matters even more.

Keyboard layouts and setups for coders

Your layout decides how easy symbols are to reach, and some layouts are much kinder to programmers than others.

• US QWERTY is the layout most programming languages were designed around. Brackets, braces, backslash and the backtick are all on their own keys without AltGr. Many programmers outside the US switch to it for coding for that reason.
• European layouts often hide code symbols behind AltGr. On a German QWERTZ keyboard, for example, the curly braces and square brackets sit on the number row with AltGr, which turns every { into a two-hand chord. Coders on these layouts who type a lot of code often use US layout for programming, or a custom variant.
• Colemak and Colemak-DH move letters for comfort but keep punctuation and symbols where QWERTY has them, so your code habits survive the switch.
• Dvorak and Programmer Dvorak. Programmer Dvorak rearranges the number row so the symbols used most in code come without Shift and numbers need it. It is a real option, but the learning cost is large.

Our keyboard layouts guide compares these in more detail. For most people the sensible advice is to stay on the layout you know and get fluent on its symbols. A layout change costs weeks or months of slow typing.

A few smaller tweaks are well worth trying:

• Remap Caps Lock to Ctrl, or to Escape if you use Vim. It is the best-placed key on the keyboard and Caps Lock wastes it.
• Programmable keyboards (QMK or similar firmware) let you put brackets and symbols on a layer under your home row, held with a thumb key. People who set this up rarely go back.
• Rest your pinkies. If your right pinky aches at the end of a day of coding, see our ergonomics guide, and see a professional if it does not settle.

Practise on real code

The code typing test on Presspace uses real code in six languages: JavaScript, TypeScript, Python, CSS, SQL and shell. Indentation and line breaks are collapsed, so you are never punished for whitespace you cannot see, and what is left is the part that trains your hands: symbols, mixed case, brackets and operators. Expect your score to be well below your prose score. A drop of a third or more is normal and is the gap you are working to close.

A weekly routine that works:

1. Monday and Thursday: one 60-second prose test and one code test in your main language. Note both numbers.
2. Every day, 5 minutes: the symbol drill lines above, or ones written from your own code.
3. Every day, 2 minutes: one deck in the shortcuts trainer, VS Code or terminal.
4. Once a week: check the heatmap in the Stats panel. If one key (very often -, [ or ') is far slower than the rest, drill it on its own.

Watch the gap between your prose and code scores. When it shrinks, your hands have learned the symbols.

Start now: take a code typing test in the language you write most, then a normal 1-minute test, and write down both numbers. That gap is your baseline.

Questions people ask

Read next