Why TypeScript Feels Slower Than JavaScript to Type
A line of TypeScript has everything a line of JavaScript has, plus type annotations. That is `: string`, `: number`, `: Promise<User>`, `: Array<{ id: string }>`, `<T extends object>`, and so on. The colon-plus-type pattern appears on nearly every parameter and return position.
The additional punctuation load adds roughly 15 to 25% more keystrokes per line compared to plain JavaScript. If your fingers are not trained on the specific TS patterns, that translates directly into a 10-to-15 WPM drop on real TypeScript code.
The TypeScript Weak Spots
Three specific patterns account for most of the slowdown:
- Angle brackets for generics: `<T>`, `<T extends object>`, `Array<string>`, `Promise<User[]>`
- Union and intersection types: `string | number`, `User & { role: string }`
- Colon-annotation pattern: `function foo(x: number): string`
- The `satisfies` operator and `as const` assertions
- Mapped and conditional types: `{ [K in keyof T]: ... }`
Drilling Angle Brackets
Angle brackets are shifted reaches on both sides — comma and period on QWERTY — and they appear in pairs with a payload between them. The TypeScript symbols lesson drills the full pattern (`<T>`, `<string>`, `<Map<K, V>>`) as rhythm units rather than isolated characters. This is essential: typing `<` and `>` separately is slow, but typing the pair as a single motor chunk is fast.
A useful target: you should be able to type `Array<User>` in under 1 second once the pattern is trained. If it takes longer, more drill time is warranted.
Union Types and Colon Annotations
The `|` character is a shift-backslash reach that is uncommon in prose. Practice it inside real TS patterns rather than in isolation: `string | number`, `'pending' | 'resolved' | 'rejected'`, `User | null`. The TypeScript declarations lesson drills these in context.
Colon annotations fall naturally out of practicing real function signatures. The TypeScript functions lesson drills signatures like `function fetchUser(id: string): Promise<User>` as whole units. Once this pattern is automatic, TS function declarations feel no slower than JS.
Advanced Patterns: `satisfies`, Mapped Types, and Generics
The TypeScript idioms and real snippet lessons move into the higher-order patterns: `satisfies`, `as const`, mapped types like `{ [K in keyof T]: T[K] }`, and conditional types like `T extends U ? X : Y`. These are lower frequency but disproportionately painful when your fingers stumble on them.
You do not need to drill these to the same speed as base syntax — you will type them less often. But familiarizing your hands with the shape of the punctuation pays off the first time you refactor a codebase and have to write a dozen of them in a row.