Track
Home-row foundations
These lessons stay close to the core anchor zone for this layout and help establish clean, repeatable movement patterns.
53 lessons
View trackColemak typing lessons
Practice Colemak with layout-aware lesson pages that explain where the focus keys sit on Colemak and link straight into live drills on SureTyping.
Lesson tracks
Each track groups Colemak lessons by the keyboard zones they focus on so you can work through the path in order or jump to the area that needs the most practice.
Track
Upper-row reach
These lessons add upward travel and coordination so you can leave the anchor zone without losing rhythm.
28 lessons
View trackTrack
Lower-row control
These lessons train downward reach, edge-key control, and steadier recovery back into the center of the board.
23 lessons
View trackTrack
Full-keyboard fluency
These lessons blend multiple zones, punctuation, numbers, or longer phrases so the layout starts working as one system.
1117 lessons
View trackColemak lesson catalog
Each lesson page shows the focus keys on Colemak and links directly into the live typing drill when you are ready to practice.
1221 lessons
Lesson Stage
Individual Home Row Letters
Part of the SureTyping guided lesson path.
18 lessons
Finding the F key
The Letter F
Building F confidence
The Letter F II
Finding the J key
The Letter J
Building J confidence
The Letter J II
Finding the D key
The Letter D
Building D confidence
The Letter D II
Finding the K key
The Letter K
Building K confidence
The Letter K II
Finding the S key
The Letter S
Building S confidence
The Letter S II
Finding the L key
The Letter L
Building L confidence
The Letter L II
Finding the A key
The Letter A
Building A confidence
The Letter A II
Finding the G key
The Letter G
Building G confidence
The Letter G II
Finding the H key
The Letter H
Building H confidence
The Letter H II
Foundations
Home Row Combinations
Early lessons that build finger anchors, repeatable reaches, and the first real words.
21 lessons
Anchor taps
Keys t & n
Alternating rhythm
Keys t & n II
Short anchor bursts
Keys t & n III
Home row reach
Keys s & e
Reach recovery
Keys s & e II
Four-key coordination
Home Row Blend I
Four-key recovery
Home Row Blend II
Accuracy focus
Keys r & i
Outer home rhythm
Keys r & i II
Add s & l
Home Row Blend III
Left-right balance
Home Row Blend IV
Edge keys
Keys a & o
Edge stability
Keys a & o II
Outer home review
Home Row Blend V
Center home row
Keys d & h
Center release
Keys d & h II
Short home-row words
Home Row Words I
Longer home-row words
Home Row Words II
Word chaining
Home Row Words III
Letters into words
Home Row Review I
Longer home-row flow
Home Row Review II
Lesson Stage
Individual Top Row Letters
Part of the SureTyping guided lesson path.
18 lessons
Reaching for E
The Letter E
E confidence builder
The Letter E II
Reaching for I
The Letter I
I confidence builder
The Letter I II
Reaching for R
The Letter R
R confidence builder
The Letter R II
Reaching for U
The Letter U
U confidence builder
The Letter U II
Reaching for T
The Letter T
T confidence builder
The Letter T II
Reaching for Y
The Letter Y
Y confidence builder
The Letter Y II
Reaching for W
The Letter W
W confidence builder
The Letter W II
Reaching for O
The Letter O
O confidence builder
The Letter O II
Reaching for Q
The Letter Q
Reaching for P
The Letter P
Upper Reach
Top Row Combinations
Lessons that add upper-row travel, alternating-hand rhythm, and controlled reach.
18 lessons
Inner reach
Keys f & u
Inner reach rhythm
Keys f & u II
Top row reach
Keys p & l
Reach timing
Keys p & l II
Inner reach words
Top Row Blend I
Upper-row recovery
Top Row Blend II
Outer reach
Keys w & y
Outer reach rhythm
Keys w & y II
Edge reach
Keys q & ;
Edge timing
Keys q & ; II
Center reach
Keys g & j
Center timing
Keys g & j II
Upper-row word set A
Top Row Words I
Upper-row word set B
Top Row Words II
Longer upper-row words
Top Row Words III
Word chaining
Top Row Words IV
Home + top words
Top Row Review I
Longer upper-row flow
Top Row Review II
Lesson Stage
Individual Bottom Row Letters
Part of the SureTyping guided lesson path.
12 lessons
Reaching for V
The Letter V
V confidence builder
The Letter V II
Reaching for M
The Letter M
M confidence builder
The Letter M II
Reaching for B
The Letter B
B confidence builder
The Letter B II
Reaching for N
The Letter N
N confidence builder
The Letter N II
Reaching for C
The Letter C
C confidence builder
The Letter C II
Reaching for X
The Letter X
Reaching for Z
The Letter Z
Lower Reach
Bottom Row Combinations
Lessons that strengthen precision on the lower row and improve edge-key control.
19 lessons
Lower row intro
Keys v & m
Lower row rhythm
Keys v & m II
Center lower reach
Keys b & k
Center lower rhythm
Keys b & k II
Lower-row center blend
Bottom Row Blend I
Precision taps
Keys c & ,
Lower-left precision
Keys c & , II
Rhythm control
Keys x & .
Lower-right precision
Keys x & . II
Outer lower reach
Keys z & /
Outer lower rhythm
Keys z & / II
Lower-row word set A
Bottom Row Words I
Lower-row word set B
Bottom Row Words II
Longer lower-row words
Bottom Row Words III
Word chaining
Bottom Row Words IV
Clean word flow
All Rows Review I
Longer review
All Rows Review II
Sentence rhythm
All Rows Review III
Extended review
All Rows Review IV
Word Building
Word Building
Lessons that turn letter control into common words, bigrams, and connected phrases.
16 lessons
Top frequency set
Common Words I
Everyday words
Common Words II
Core fluent words
Common Words III
Function-word control
Common Words IV
Sentence glue
Common Words V
Longer high-frequency set
Common Words VI
High-frequency pairs
Core Bigrams I
Link common patterns
Core Bigrams II
Longer pair runs
Core Bigrams III
Frequent three-letter chunks
Core Trigrams I
Transition chaining
Core Trigrams II
Connected typing
Short Phrases I
Accuracy under flow
Short Phrases II
Longer connected flow
Short Phrases III
Simple sentence control
Sentence Flow I
Longer sentence control
Sentence Flow II
Lesson Stage
Fluency Review
Part of the SureTyping guided lesson path.
4 lessons
Checkpoint before capitals
Review: Common Words
Flowing multi-word groups
Review: Short Phrases
Complete thoughts at speed
Review: Full Sentences
Words, phrases, and sentences combined
Review: Mixed Skills
Capital Letters
Capital Letters
Lessons that teach opposite-hand Shift technique for capitals before moving into full mixed-text fluency.
8 lessons
Right Shift with left-hand home letters
Capital Letters I
Left Shift with right-hand home letters
Capital Letters II
Right Shift with left-hand reach letters
Capital Letters III
Left Shift with right-hand reach letters
Capital Letters IV
Title-case words
Capital Letters V
Names and proper nouns
Capital Letters VI
Sentence starts and proper nouns
Capital Letters VII
Capitals in full sentences
Capital Letters VIII
Lesson Stage
Shift Technique
Part of the SureTyping guided lesson path.
12 lessons
Shift with left-hand letters
Right Shift Introduction
Capitalize left-hand home keys
Right Shift — Home Row
Capitalize left-hand top and bottom rows
Right Shift — Reach Keys
Right Shift in real sentences
Right Shift — Flow
Shift with right-hand letters
Left Shift Introduction
Capitalize right-hand home keys
Left Shift — Home Row
Capitalize right-hand top and bottom rows
Left Shift — Reach Keys
Left Shift in real sentences
Left Shift — Flow
Both Shift keys in one exercise
Mixed Shift Practice
Every word capitalized
Title Case Practice
Names, places, and days
Proper Nouns
Mixed case real-world text
Abbreviations & Acronyms
Lesson Stage
Bigram & Trigram Drills
Part of the SureTyping guided lesson path.
6 lessons
Words built on the two most common pairs
Bigram Stream: TH & IN
Rolling er and re transitions
Bigram Stream: ER & RE
Anchor pairs an and on in a steady stream
Bigram Stream: AN & ON
Suffix chunks that end thousands of words
Trigram Stream: ING & ENT
Long-word endings in connected runs
Trigram Stream: TION & THER
All the core pairs and chunks in real sentences
Checkpoint: Bigram Fluency
Lesson Stage
Tricky Words
Part of the SureTyping guided lesson path.
6 lessons
Words people mistype by dropping a letter
Tricky Words: Double Letters
Near-twins your fingers love to flip
Tricky Words: Swapped Letters
ible, able, ance, and ence under control
Tricky Words: Slippery Endings
Spelling your ears cannot help you with
Tricky Words: Silent Letters
Words that read alike and land on the wrong keys
Tricky Words: Lookalikes
Every trap word family mixed into prose
Checkpoint: Tricky Words
Lesson Stage
Capitals Ladder
Part of the SureTyping guided lesson path.
6 lessons
One clean capital at the start of every line
Capitals Ladder: Sentence Openers
Capitals landing mid-sentence on names
Capitals Ladder: Names in Motion
Proper nouns for places, months, and weekdays
Capitals Ladder: Places & Days
Dense title case without losing rhythm
Capitals Ladder: Headlines
Back-to-back capitals held down the row
Capitals Ladder: Acronyms
Openers, names, places, titles, and acronyms combined
Checkpoint: Capitals Ladder
Lesson Stage
Speed Drills
Part of the SureTyping guided lesson path.
7 lessons
High-frequency words at pace
Speed: Common Words
Quick sentence bursts
Speed: Short Sentences
Sustained multi-sentence rhythm
Speed: Paragraph Flow
Words, numbers, and punctuation at speed
Speed: Mixed Content
Push your WPM ceiling
Speed: One-Minute Challenge
Longer passage, keep the rhythm
Speed: Sustained Flow I
Continue the pace without dropping
Speed: Sustained Flow II
Lesson Stage
Accuracy Training
Part of the SureTyping guided lesson path.
4 lessons
Zero-mistake short word runs
Accuracy: Short Words
Clean complete sentences
Accuracy: Sentence Precision
Longer text with zero tolerance
Accuracy: Paragraph Precision
The ultimate precision test
Accuracy: No-Mistake Challenge
Lesson Stage
Real-World Typing
Part of the SureTyping guided lesson path.
22 lessons
Professional email composition
Real World: Email
Casual digital communication
Real World: Chat Messages
Structured note-taking
Real World: Meeting Notes
Programming in practice
Real World: Code
Formal analytical writing
Real World: Academic Prose I
Building on research
Real World: Academic Prose II
Referencing sources accurately
Real World: Citations
Formatting reference lists
Real World: Bibliography
Writing a clear opening argument
Real World: Essay — Thesis
Supporting your argument with evidence
Real World: Essay — Body
Wrapping up with impact
Real World: Essay — Conclusion
Executive summary writing
Real World: Report — Summary
Data-driven conclusions
Real World: Report — Analysis
Actionable next steps
Real World: Report — Recommendation
Establishing a scene
Real World: Creative — Setting
Adding texture to narrative
Real World: Creative — Detail
Shifting the story forward
Real World: Creative — Turning Point
Installation instructions
Real World: Tech Docs — Setup
API usage examples
Real World: Tech Docs — Usage
Contract language
Real World: Legal — Agreement
Terms and conditions
Real World: Legal — Terms
Switching between styles
Real World: Mixed Format
Lesson Stage
Endurance
Part of the SureTyping guided lesson path.
10 lessons
Sustained multi-paragraph flow
Endurance: Three Paragraphs
News reporting, part one
Endurance: Article I
News reporting, part two
Endurance: Article II
News reporting, part three
Endurance: Article III
The valley of frustration
Endurance: Learning I
Consistency over intensity
Endurance: Learning II
How the brain builds skill
Endurance: Learning III
The origins of writing
Endurance: History I
Technology expands access
Endurance: History II
The modern era
Endurance: History III
Lesson Stage
Weak Key Recovery
Part of the SureTyping guided lesson path.
3 lessons
Commonly swapped keys
Recovery: Confused Pairs
Left-right mirror positions
Recovery: Mirror Keys
Difficult stretches and returns
Recovery: Reach Keys
Full Keyboard
Mastery
Lessons that combine punctuation, numbers, symbols, mixed strings, and speed-oriented review work.
10 lessons
Sentences and symbols
Punctuation
Longer punctuation flow
Punctuation II
Left-side digits
Number Row I
Right-side digits
Number Row II
Reach and return
Number Row III
Common programming marks
Coding Symbols
Longer code rhythm
Coding Symbols II
Words and transitions
Mixed Drills
Speed checkpoint
Timed Sprint
Full keyboard
Final Review
Lesson Stage
Speed Ladder: 40 WPM
Part of the SureTyping guided lesson path.
4 lessons
Short common-word sprint, hold the pace
Speed 40 WPM I
Longer sprint at the same steady pace
Speed 40 WPM II
Full-length sprint with simple sentences
Speed 40 WPM III
Prove the pace holds for a full passage
Checkpoint: Speed 40 WPM
Lesson Stage
Speed Ladder: 50 WPM
Part of the SureTyping guided lesson path.
4 lessons
Everyday words at a working pace
Speed 50 WPM I
Longer everyday sentences, no hesitation
Speed 50 WPM II
Sustained sprint with varied vocabulary
Speed 50 WPM III
A full passage at fifty, start to finish
Checkpoint: Speed 50 WPM
Lesson Stage
Speed Ladder: 60 WPM
Part of the SureTyping guided lesson path.
4 lessons
A word a second, light and even
Speed 60 WPM I
Longer lines, denser words, same clock
Speed 60 WPM II
Sustained sprint pushing into fluency
Speed 60 WPM III
The fluency line: hold sixty for the distance
Checkpoint: Speed 60 WPM
Lesson Stage
Speed Ladder: 70 WPM
Part of the SureTyping guided lesson path.
4 lessons
Entering expert pace on common words
Speed 70 WPM I
Longer expert sprint, zero wasted motion
Speed 70 WPM II
Sustained expert pace with real prose
Speed 70 WPM III
The top rung: seventy held to the last word
Checkpoint: Speed 70 WPM
Lesson Stage
Accuracy Lab
Part of the SureTyping guided lesson path.
5 lessons
Words separated by a single keystroke
Accuracy Lab: Minimal Pairs
Same-finger doubles without a stutter
Accuracy Lab: Double Taps
Rare sequences that break autopilot
Accuracy Lab: Awkward Runs
Deliberately unhurried, deliberately perfect
Accuracy Lab: Slow Motion
Every trap in one passage, zero errors allowed
Checkpoint: Accuracy Lab
Lesson Stage
Real-World Pro
Part of the SureTyping guided lesson path.
5 lessons
A full-length professional email, about 150 words
Pro Email: Project Update
Formal report prose with figures, about 150 words
Pro Report: Quarterly Findings
Magazine-style prose, about 150 words
Pro Article: Feature Piece
Dense action-oriented briefing notes
Pro Briefing: Meeting Prep
Email, figures, and narrative prose in one sitting
Checkpoint: Professional Output
Lesson Stage
Endurance Passages
Part of the SureTyping guided lesson path.
4 lessons
A sustained 200-word narrative passage
Endurance Passage: The Cartographer
A sustained 200-word descriptive passage
Endurance Passage: The Glasshouse
A sustained 210-word reflective passage
Endurance Passage: The Night Shift
The longest sustained passage in the course
Checkpoint: Endurance
Lesson Stage
Punctuation & Numbers
Part of the SureTyping guided lesson path.
42 lessons
First three digits
Numbers: 1, 2, 3
Expanding left hand
Numbers: 4, 5
Digits 1-5 fluency
Numbers: Left Review
First three right-hand digits
Numbers: 6, 7, 8
Completing the row
Numbers: 9, 0
Digits 6-0 fluency
Numbers: Right Review
All ten digits together
Numbers: Full Row Mix
Numbers in everyday text
Numbers: Real World
Calculations and formulas
Numbers: Math Expressions
Ending sentences
Period: Introduction
Natural sentence endings
Period: In Sentences
Pauses and lists
Comma: Introduction
Joining ideas
Comma: In Clauses
Combined practice
Period & Comma Together
Asking questions
Question Mark: Introduction
Longer queries
Question Mark: Complex Questions
Adding emphasis
Exclamation Point: Introduction
Both in context
Questions & Exclamations Mixed
Introducing lists and explanations
Colon: Introduction
Connecting related ideas
Semicolon: Introduction
Using both confidently
Colon & Semicolon Together
Common shortened forms
Apostrophe: Contractions
Showing ownership
Apostrophe: Possession
Quoting speech
Quotation Marks: Introduction
Full conversation
Quotation Marks: Dialogue
Adding extra info
Parentheses: Introduction
Technical grouping
Brackets: Introduction
Both in use
Parentheses & Brackets Together
Email and tagging
@ and # Symbols
Money and percentages
$ and % Symbols
Connections and math
& and + and = Symbols
All special symbols
Special Characters Review
Code blocks
Curly Braces
HTML and comparisons
Angle Brackets & Slash
Real code patterns
Programming: Full Practice
Everyday date formats
Dates & Times
Digital addresses
Emails & URLs
Contact information
Phone & Address
All punctuation in context
Mixed Review I
Business context
Mixed Review II
Academic context
Mixed Review III
The final challenge
Punctuation Mastery
Lesson Stage
Number Row Mastery
Part of the SureTyping guided lesson path.
5 lessons
Digits drilled in the order real text uses them
Number Row: Frequency Order
Calendar numbers without looking down
Number Row: Dates & Years
Currency amounts with clean symbol reaches
Number Row: Prices & Money
Quantities, percentages, and measurements
Number Row: Stats & Measures
Dates, prices, and data in one continuous run
Checkpoint: Number Row Mastery
Lesson Stage
Symbol Pairs
Part of the SureTyping guided lesson path.
5 lessons
Open and close as one motion inside prose
Symbol Pairs: Parentheses
Dialogue punctuation at full sentence speed
Symbol Pairs: Quotes & Apostrophes
Compound words and ranges without slowing
Symbol Pairs: Hyphens & Dashes
Editorial marks and structured lists
Symbol Pairs: Brackets & Colons
Every pair woven through connected prose
Checkpoint: Symbol Pairs
Lesson Stage
Mixed Finals
Part of the SureTyping guided lesson path.
4 lessons
Sentences that keep leaving the letter rows
Final Mix I: Prose & Numbers
Punctuation-dense professional writing
Final Mix II: Prose & Symbols
Numbers, symbols, capitals, and prose combined
Final Mix III: Everything at Once
The full-keyboard graduation passage
Checkpoint: Grand Final
Lesson Stage
Casper Test Typing Prep
Part of the SureTyping guided lesson path.
55 lessons
Free preview -- the typing demand of the test, in typeable prose
What Casper Asks of Your Fingers
Free preview -- a timed 105-word response to measure your baseline
Diagnostic Mini-Sim
A longer 160-word timed passage that sets your starting numbers
Checkpoint: Baseline Under the Clock
High-frequency prompt and response vocabulary
Casper Vocabulary Warmup
Core ethics terms you will reach for again and again
Ethical Reasoning Vocabulary
A 70-word bank of ward, clinic, and rotation terms
Clinical Setting Vocabulary
A 75-word drill on identifying everyone a decision touches
Naming the Stakeholders
A 70-word drill on the verbs that carry a response forward
Action Verb Bank
A 75-word bank of phrases that show care without cliche
Empathy Language Bank
A 70-word bank of workplace and institutional terms
Professionalism & Policy Vocabulary
A 70-word bank for resource and equity scenarios
Fairness & Equity Vocabulary
A 75-word bank for the moments a scenario turns serious
Safety & Escalation Vocabulary
A 150-word timed passage mixing every bank in this module
Checkpoint: Vocabulary Under Pressure
Openers that anchor a thoughtful Casper answer
First-Person Response Stems
Linking phrases that keep a five-minute response flowing
Reflective Transition Phrases
An 85-word drill on the sentences that buy you certainty
Gather-Information Stems
A 90-word drill on seeing the scenario from every chair
Perspective-Taking Stems
A 90-word drill on turning reasoning into concrete steps
Action-Plan Stems
An 85-word drill on holding two truths in one response
Counterpoint & Nuance Stems
An 85-word drill on endings that land instead of trail off
Closing & Follow-Up Stems
Commas, semicolons, colons, and em-dashes in real prose
Punctuation Flow for Reflective Writing
A 155-word timed passage chaining stems into one complete arc
Checkpoint: Full Skeleton, No Content
A full 75-word response to a classmate integrity scenario
Short Response: Classmate Ethics
A 78-word response to an uneven group-project scenario
Short Response: Team Conflict
A 78-word response to a confidentiality dilemma
Short Response: Patient Confidentiality
A 78-word response to a coworker claiming your idea
Short Response: Credit Taken at Work
A 78-word response to a volunteer-organization scenario
Short Response: Donations Mismanaged
A 76-word response to an unfair-advantage scenario
Short Response: Old Exam Offered
A 78-word response to a clinical safety observation
Short Response: Hygiene Shortcut
A 77-word response to a friend asking for your prescription
Short Response: Borrowed Medication
Two back-to-back 55-word responses -- 112 words without a break
Checkpoint: Two Shorts, One Clock
A 120-word response to an uncomfortable supervisor request
Medium Response: Workplace Supervisor
A 122-word response to a cultural-sensitivity scenario
Medium Response: Cultural Sensitivity
A 120-word response to a resource-allocation ethics scenario
Medium Response: Resource Allocation
A 125-word response to a struggling teammate who copied
Medium Response: Plagiarism and Pressure
A 125-word response about reporting your own mistake
Medium Response: Owning Your Error
A 122-word response to a community access scenario
Medium Response: The Language Barrier
A 126-word response to a disclosure dilemma
Medium Response: Family Asks for Silence
A 123-word response to a colleague mocking clients online
Medium Response: The Group Chat Screenshot
A 150-word timed response with no warmup and no pausing
Checkpoint: Medium Response, Cold Start
A 185-word realistic full-length medical ethics response
Full 5-Minute Response I
A 188-word response to an interpersonal dilemma
Full 5-Minute Response II
A 190-word response to a burned-out colleague scenario
Full 5-Minute Response III
A 192-word response to a retaliation-risk scenario
Full 5-Minute Response IV
Two consecutive responses, 205 words total, no rest between
Back-to-Back Block I
Two consecutive responses, 210 words total, at exam cadence
Back-to-Back Block II
Three back-to-back mini-responses, just like the real block
Exam Simulation Sprint
A single 215-word response typed at full exam cadence
Checkpoint: The Long Haul
Three mini-responses, 265 words -- a complete Casper block
Full Simulation 1 of 5
Three mini-responses, 270 words -- clinical, academic, workplace
Full Simulation 2 of 5
Three mini-responses, 268 words -- community, family, research
Full Simulation 3 of 5
Three mini-responses, 272 words -- pressure from every direction
Full Simulation 4 of 5
Three mini-responses, 275 words -- the hardest block, full speed
Full Simulation 5 of 5
A graded 285-word, three-response final at full exam cadence
Final: The Complete Casper Block
A reflective 130-word wind-down to close the course
Cooldown: What Your Hands Learned
Lesson Stage
JavaScript code typing
Part of the SureTyping guided lesson path.
33 lessons
The punctuation and operators you hit every day in JavaScript
Operators & Symbols
Fat arrows, implicit object returns, and curried chains
Arrow Functions
?. ?? and ??= plus the ?.[] and ?.() call forms
Optional Chaining & Nullish
Three dots across arrays, objects, rest params, and defaults
Spread & Rest
Backticks, ${} interpolation, multiline blocks, and tagged templates
Template Literals
Nested patterns, defaults, renames, and obj[key] access
Destructuring & Computed Keys
Every JavaScript glyph cluster from this module in one longer drill
Checkpoint: Symbol Fluency
Reserved words grouped and repeated for rhythm
Keywords
const, let, arrow functions, and classes
Declarations
import, export, default, aliases, and dynamic import
ESM Imports & Exports
await, for await, and the Promise combinators
async / await
map, filter, reduce, spread, and nullish patterns
Idiomatic One-Liners
map, filter, reduce, flatMap, at, and sort comparators
Array Method Chains
Modules, async, and array idioms inside one exported helper
Checkpoint: Keywords & Idioms
if/else, for-of, while, and switch in realistic shapes
Control Flow
Arrow params, destructuring, defaults, and async/await
Functions & Methods
ES class syntax with #private state, getters, and toJSON
Class with Private Fields
Custom Error subclasses with try/catch and Promise.allSettled
Error Handling
Tallying with Map, deduping with Set, grouping with Object.groupBy
Map & Set Collections
Fetch a JSON feed, rank it, and render to the DOM
Realistic Snippet
One document listener routing clicks through data attributes
Event Delegation
A fetch wrapper with AbortController timeouts and retries
Checkpoint: Real Snippets
Two closure-based timer utilities typed without stopping
Speed Run: Debounce & Throttle
Map insertion order used as an eviction policy
Speed Run: LRU Cache
A rule table reduced into a field-error map
Speed Run: Form Validation
groupBy, sum, and sort chained over an order list
Speed Run: Array Pipeline
node:test and assert wrapped around a slugify helper
Speed Run: Test Suite
An event-latency report typed in one continuous run
Checkpoint: Sustained Speed
A cached fetch, a groupBy, and a ranked payout table
Assessment Sim 1: Customer Revenue Report
A complete ranked-table program over request records
Assessment Sim 2: Log Analyzer
A full page loop with exponential backoff and retries
Assessment Sim 3: Paginated Fetch
An add/complete/query store persisted with node:fs/promises
Assessment Sim 4: Task Store
An end-to-end priced order report -- the course's graded final
Checkpoint: JavaScript Mastery Final
Lesson Stage
TypeScript code typing
Part of the SureTyping guided lesson path.
33 lessons
Type annotations, generic brackets, and the punctuation you hit constantly
Operators & Symbols
Nested type arguments and defaulted parameters without losing the closing bracket
Generic Angle Brackets
Pipe and ampersand types, literal unions, and discriminated shapes
Unions & Intersections
keyof, typeof, infer, conditional types, and mapped keys
Type-Level Operators
Assertion operators, optional marks, and definite assignment
satisfies, as const & Bang
Function-type arrows, overload signatures, and is/asserts guards
Arrows, Overloads & Predicates
Every TypeScript glyph cluster from this module in one longer drill
Checkpoint: Symbol Fluency
All reserved words and TypeScript-specific keywords
Keywords
Interfaces, type aliases, generics, and typed functions
Declarations
typeof, in, instanceof, and Array.isArray instead of any
Narrowing unknown
Omit, Pick, Record, Awaited, and the Exclude/Extract pair
Utility Types
satisfies, mapped types, and utility type expressions
Idiomatic One-Liners
Promise.all, allSettled, race, and for await loops
Async Idioms
A Result union with constructors and an exhaustive never check
Checkpoint: Keywords & Idioms
Type guards, narrowing, and discriminated unions in real branches
Control Flow
Generics, overloads, and typed async handlers
Functions & Methods
Parameter properties and this-returning chains
Class & Fluent Builder
Error subclasses narrowed with instanceof
Typed Error Classes
Typed collection work with spreads and reduce
Maps, Sets & Records
A typed fetch wrapper with a consistent response envelope
Realistic Snippet
A branded id, a repository interface, and its in-memory implementation
Generic Repository
A typed event-map emitter with keyed payloads and unsubscribe handles
Checkpoint: Real Snippets
A dependency-free validator returning Result<T, string[]> at full pace
Speed Run: Runtime Validator
A generic private send method wrapped by get and post
Speed Run: Typed Fetch Client
A cart reducer over a discriminated action union
Speed Run: State Reducer
Recursive mapped types, template literal keys, and Awaited chains
Speed Run: Utility Type Gymnastics
A node:test suite with typed fixtures and strict assertions
Speed Run: Tests & Asserts
A layout leaderboard summarised and formatted in one continuous run
Checkpoint: Sustained Speed
A complete row-to-record parser that accumulates errors instead of throwing
Assessment Sim 1: CSV Record Parser
A full expiring cache with typed keys and a load-through helper
Assessment Sim 2: Generic TTL Cache
A complete worker loop dispatching a discriminated job union
Assessment Sim 3: Typed Job Queue
A whole env-to-typed-shape loader with guards and range checks
Assessment Sim 4: Config Loader
A typed order-analytics pipeline -- the course's graded final
Checkpoint: TypeScript Mastery Final
Lesson Stage
Python code typing
Part of the SureTyping guided lesson path.
33 lessons
Python punctuation, operators, and block glyphs
Operators & Symbols
Brackets, for, and if inside comprehensions
Comprehension Brackets
The @ symbol on functions, methods, and classes
Decorators
Braces, conversions, and alignment inside f-strings
F-Strings & Format Specs
The -> and : punctuation of modern type hints
Annotations & Arrows
Stars, slices, and the walrus operator
Unpacking & Slicing
Every Python glyph cluster from this module in one longer drill
Checkpoint: Symbol Fluency
Python reserved words grouped by role
Keywords
Constants, annotated variables, functions, and dataclasses
Declarations
enumerate, zip, any, all, and sorted with keys
Iteration Idioms
yield, yield from, and lazy pipelines
Generators & yield
Protocol, TypeVar, and union aliases in daily use
Typing & Protocols
Comprehensions, f-strings, and the walrus operator
Idiomatic One-Liners
A lazy sensor pipeline mixing this module's material
Checkpoint: Keywords & Idioms
if/elif/else, loops, and match statements
Control Flow
Default args, star args, context managers, and async def
Functions & Methods
with blocks and @contextmanager wrappers
Context Managers
A custom exception hierarchy with try/except/else/finally
Exceptions & Cleanup
Tallying with collections instead of hand-rolled dicts
Counter & defaultdict
Structural pattern matching over dataclasses and dicts
Match Statements
Parse a CSV, rank by revenue, and pretty-print the result
Realistic Snippet
Dataclasses, pathlib, and grouping in one pass
Checkpoint: Real Snippets
A backoff wrapper typed end to end without stopping
Speed Run: Retry Decorator
A small command-line tool at full pace
Speed Run: Argparse CLI
DictReader into a formatted revenue table
Speed Run: CSV Report
asyncio.gather over a batch of requests
Speed Run: Async Fan-Out
Fixtures, parametrize, and raises without pausing
Speed Run: Pytest Module
A regex log dashboard typed in one continuous run
Checkpoint: Sustained Speed
A complete JSON-backed task tracker
Assessment Sim 1: Task Store
A full stack evaluator with real error paths
Assessment Sim 2: RPN Calculator
A dataclass ledger that refuses to oversell
Assessment Sim 3: Inventory Ledger
A log parser that ranks the slowest endpoints
Assessment Sim 4: Latency Report
A ranked sales summary -- the course's graded final
Checkpoint: Python Mastery Final
Lesson Stage
Java code typing
Part of the SureTyping guided lesson path.
33 lessons
Java punctuation, generics brackets, and arrow glyphs
Operators & Symbols
Angle brackets, bounded types, and nested type arguments
Generics & Wildcards
The -> arrow and :: separator in functional positions
Lambda Arrows & Method References
At-signs, annotation arguments, and stacked markers
Annotations
Fluent dots, collectors, and closing parenthesis stacks
Stream Chain Punctuation
case X -> arms, comma-grouped labels, and yield bodies
Switch Arrows & Yield Blocks
Every Java glyph cluster from this module in one longer drill
Checkpoint: Symbol Fluency
Reserved words plus the modern record and sealed additions
Keywords
Records, sealed interfaces, final classes, and var
Declarations
map, flatMap, and orElseThrow instead of null checks
Optional Idioms
try, catch, finally, throw, and throws in rhythm
Exception Keywords
Triple-quoted blocks, formatted, and printf specifiers
Text Blocks & Formatting
Streams, collectors, and method references at a glance
Idiomatic One-Liners
A small service class mixing this module's material
Checkpoint: Keywords & Idioms
Enhanced for, switch expressions, and instanceof patterns
Control Flow
Generic signatures, Optional returns, and varargs
Functions & Methods
Validation and normalisation inside a compact constructor
Records & Compact Constructors
permits clauses, record patterns, and when guards
Sealed Hierarchy & Exhaustive Switch
Auto-closing streams and wrapping checked exceptions
try-with-resources
computeIfAbsent, merge, and getOrDefault on real data
Maps & Aggregation
A CSV sales report loaded, grouped, and printed
Realistic Snippet
A generic Result type built from sealed records and switch
Checkpoint: Real Snippets
groupingBy, summingDouble, sorted, and limit without pausing
Speed Run: Stream Report
supplyAsync, allOf, and join across a thread pool
Speed Run: CompletableFuture Fan-Out
ConcurrentHashMap merge and AtomicLong under load
Speed Run: Concurrent Counter
BeforeEach fixtures, assertEquals, and assertThrows
Speed Run: JUnit 5 Suite
Chained comparators behind an Iterable leaderboard
Speed Run: Comparators & Iterable
A p95 latency monitor typed in one continuous run
Checkpoint: Sustained Speed
A complete tracker built on records, sealed types, and streams
Assessment Sim 1: Task Tracker
A full Files.lines program that ranks word frequencies
Assessment Sim 2: Word Histogram
A Deque evaluator with underflow and divide-by-zero paths
Assessment Sim 3: RPN Calculator
A stock-movement program that rejects oversell
Assessment Sim 4: Inventory Ledger
An end-to-end traffic and latency report -- the graded final
Checkpoint: Java Mastery Final
Lesson Stage
Code: C
Part of the SureTyping guided lesson path.
33 lessons
C punctuation, pointer glyphs, and compound assignment
Operators & Symbols
Star and ampersand in declarations, dereferences, and arithmetic
Pointers & Address-Of
-> through pointers, . through values, and chained hops
Arrow & Dot Access
Allocation idioms built on sizeof(*p), calloc, and realloc
malloc, free & sizeof
Hash includes, defines, guards, and macros with arguments
Preprocessor Directives
printf conversions, width flags, and backslash escapes
Format Strings & Escapes
Every C glyph cluster from this module in one longer drill
Checkpoint: Symbol Fluency
Reserved words of standard C
Keywords
Variables, structs, and function prototypes
Declarations
static, const, extern, volatile, and restrict in real declarations
Storage & Qualifiers
Named types, tagged enums, unions, and function pointers
typedef, enum & union
Common C one-liners
Idiomatic Patterns
strncpy, snprintf, strcmp, and bounds-safe copies
String & Memory Library
enum, struct, switch, and const pointers mixed in one pass
Checkpoint: Keywords & Idioms
Branches, loops, and switches
Control Flow
Small, complete C functions
Functions & Methods
A typedef struct with a paired constructor and destructor
Struct Lifecycle
Return codes, errno, and strerror on the failure path
Error Handling
Growing, appending, and freeing a heap vector
Dynamic Array
Singly linked list with insert and free
Realistic Snippet
Duplicating and trimming with bounds checks
String Helpers
Structs, qsort comparators, and formatted output in one pass
Checkpoint: Real Snippets
A fixed-size circular queue typed without stopping
Speed Run: Ring Buffer
Masks, shifts, and toggles at full pace
Speed Run: Bit Flags
Binary search paired with an insertion sort
Speed Run: Search & Sort
fgets plus strtok field parsing with malformed rows
Speed Run: Line Reader
An FNV-1a hash with open-addressing probes
Speed Run: Hash Lookup
A priority scheduler typed in one continuous run
Checkpoint: Sustained Speed
An argv-driven file utility with usage text and error paths
Assessment Sim 1: Line & Word Counter
A complete stack evaluator with underflow and divide-by-zero paths
Assessment Sim 2: RPN Calculator
A full stdin-to-summary program with mean, min, and max
Assessment Sim 3: Reading Statistics
A file-backed word counter over a small open-addressed table
Assessment Sim 4: Word Frequency
A log-level summary with allocation, growth, and cleanup -- the course's graded final
Checkpoint: C Mastery Final
Lesson Stage
Code: C++
Part of the SureTyping guided lesson path.
33 lessons
Modern C++ punctuation rhythm
Operators & Symbols
Double-colon paths through namespaces and class members
Scope Resolution
Template arguments, nested closers, and casts
Angle Brackets
make_unique, move, lock_guard, and destructors
RAII & Smart Pointers
Bracket capture lists and trailing return types
Lambdas & Captures
const&, &&, noexcept, and structured bindings
References & Qualifiers
Every C++ glyph cluster from this module in one longer drill
Checkpoint: Symbol Fluency
Modern C++ reserved words
Keywords
Types, templates, and smart pointers
Declarations
Constraining templates instead of hoping for the best
Concepts & requires
Value-or-nothing and value-or-error in daily use
optional & expected
Modern C++ one-liners
Idiomatic Patterns
Pipe operators, projections, and lazy adapters
Ranges & Views
A constrained range template mixing this module's material
Checkpoint: Keywords & Idioms
Ranges, loops, and pattern-style switches
Control Flow
Small, idiomatic C++ functions
Functions & Methods
An owning handle that cleans up after itself
RAII & the Rule of Five
Typed failures returned instead of thrown
Error Handling with expected
Tallying with operator[] and merging with try_emplace
Maps & Container Idioms
Thread-safe bounded queue template
Realistic Snippet
A small value type with arithmetic and spaceship
Operator Overloading
Structs, ranges, optional, and std::format in one pass
Checkpoint: Real Snippets
An unordered_map tally ranked without stopping
Speed Run: Word Counter
std::visit over an overloaded set at full pace
Speed Run: Variant Dispatch
A constexpr Vec3 with free operators and normalize
Speed Run: Vector Math
jthread fan-out guarded by a lock_guard accumulator
Speed Run: Threads & Mutex
A slugify function plus the assertions that pin it down
Speed Run: Asserts & Tests
A slowest-event report typed in one continuous run
Checkpoint: Sustained Speed
A complete stdin-to-ranked-table program
Assessment Sim 1: Word Histogram
A full stack evaluator returning expected errors
Assessment Sim 2: RPN Calculator
A complete stock-movement program that rejects oversell
Assessment Sim 3: Inventory Ledger
A full string_view parser built on from_chars and concepts
Assessment Sim 4: CSV Row Parser
A ranked p95 latency report -- the course's graded final
Checkpoint: C++ Mastery Final
Lesson Stage
Code: C#
Part of the SureTyping guided lesson path.
33 lessons
C# punctuation and null handling
Operators & Symbols
Fat arrows in LINQ chains and expression-bodied members
Lambda Arrows
?. ?? ??= and the null-forgiving bang
Null Operators
Angle brackets, where clauses, and nested type arguments
Generics & Constraints
async Task<T>, await using, await foreach, and ConfigureAwait
Async Punctuation
Property patterns, switch arms, tuples, and out var
Pattern Matching
Every C# glyph cluster from this module in one longer drill
Checkpoint: Symbol Fluency
Modern .NET keywords
Keywords
Records, nullable types, and properties
Declarations
sealed, required, virtual, override, and init accessors
Modifiers & Members
from, where, let, group by into, orderby, select
Query Syntax
LINQ and modern C# one-liners
Idiomatic Patterns
C# 12 literals, spreads, and dictionary initializers
Collection Expressions
An interface, a primary constructor, and a static helper in one pass
Checkpoint: Keywords & Idioms
Pattern matching, loops, and switches
Control Flow
Async methods and expression bodies
Functions & Methods
Non-destructive mutation and positional deconstruction
Records & With Expressions
A custom exception plus catch ... when guards
Exceptions & Filters
A primary-constructor service with logging and a guard clause
Injected Service
LINQ report over a list of records
Realistic Snippet
An IAsyncEnumerable producer consumed with await foreach
Async Streams
Records, a join, and a grouped report typed end to end
Checkpoint: Real Snippets
A bounded producer and consumer typed without stopping
Speed Run: Channel Pipeline
A generic retry helper with doubling delays at full pace
Speed Run: Retry With Backoff
IComparer<T> with null handling driving a sorted queue
Speed Run: Custom Comparer
Endpoint registration blocks with route constraints
Speed Run: Minimal API
Fact and Theory attributes with InlineData rows
Speed Run: xUnit Tests
A latency percentile report typed in one continuous run
Checkpoint: Sustained Speed
A complete file-to-frequency program with LINQ and GroupBy
Assessment Sim 1: Word Histogram
A Stack<double> evaluator with every error path wired up
Assessment Sim 2: RPN Calculator
A stock-movement program that rejects oversell
Assessment Sim 3: Inventory Ledger
Parse, group, and print a ranked table with aligned columns
Assessment Sim 4: CSV To Records
A resilient async API client -- the course's graded final
Checkpoint: C# Mastery Final
Lesson Stage
Code: Go
Part of the SureTyping guided lesson path.
33 lessons
Go punctuation and channel arrows
Operators & Symbols
The := operator and multi-value assignment
Short Declarations
Sends, receives, and directional chan types
Channel Arrows
Star, ampersand, and nil checks on methods
Pointers & Receivers
Slice, map, and struct literals with backtick tags
Composite Literals & Tags
%w wrapping plus %v %s %q %T formatting
Error Wrapping & Verbs
Every Go glyph cluster from this module in one longer drill
Checkpoint: Symbol Fluency
Go reserved words drilled in rhythm
Keywords
Structs, interfaces, and functions
Declarations
Small interfaces, embedding, and compile-time checks
Interfaces & Embedding
Cleanup that runs no matter which path returns
defer, panic & recover
Common Go one-liners
Idiomatic Patterns
Type parameters with [T any] and comparable
Generics & Constraints
A rate limiter that mixes this module's material
Checkpoint: Keywords & Idioms
Error handling, loops, and type switches
Control Flow
Idiomatic Go functions
Functions & Methods
A concurrency-safe type with a constructor and methods
Mutex-Guarded Counter
Sentinel errors, an Error() method, and errors.As
Custom Error Types
Grouping with append and ranking with sort.Slice
Maps & Slices
HTTP handler with JSON and context
Realistic Snippet
Subtests with t.Run over a case table
Table-Driven Tests
A bufio.Scanner log filter mixing this module's material
Checkpoint: Real Snippets
Handler chaining typed end to end without stopping
Speed Run: HTTP Middleware
WaitGroup fan-out under a WithTimeout deadline
Speed Run: Context Fan-Out
sort.Slice over aggregated totals at full pace
Speed Run: Ranking Report
Marshal and unmarshal with struct tags and wrapped errors
Speed Run: JSON Round Trip
A select loop batching work until ctx.Done()
Speed Run: Ticker & Shutdown
A server with graceful shutdown typed in one continuous run
Checkpoint: Sustained Speed
A complete stdin word counter with a ranked printout
Assessment Sim 1: Word Frequency
A complete stack evaluator with explicit error returns
Assessment Sim 2: RPN Calculator
A full stock-movement program that rejects oversell
Assessment Sim 3: Inventory Ledger
A channel fan-out with WaitGroup and collected results
Assessment Sim 4: Worker Pool
A tabwriter latency report -- the course's graded final
Checkpoint: Go Mastery Final
Lesson Stage
Code: Rust
Part of the SureTyping guided lesson path.
33 lessons
Rust punctuation and borrow symbols
Operators & Symbols
Double-colon paths and ::<> type arguments
Paths & Turbofish
Tick-a annotations and angle-bracket bounds
Lifetimes & Generics
Pattern => value pairs and range patterns
Match Arms & Fat Arrows
Error propagation with ? on Result chains
The ? Operator
Vertical-bar parameter lists in iterator chains
Closures & Pipes
Every Rust glyph cluster from this module in one longer drill
Checkpoint: Symbol Fluency
Rust reserved words
Keywords
Structs, enums, traits, and functions
Declarations
trait, impl, and generic bounds
Trait Bounds & Impls
unwrap_or, map, and if-let in daily use
Option & Result Idioms
Common Rust one-liners
Idiomatic Patterns
take, zip, flatten, chunks, and friends
Iterator Adapters
A custom Iterator impl mixing this module's material
Checkpoint: Keywords & Idioms
Match expressions, loops, and Result handling
Control Flow
Idiomatic Rust functions
Functions & Methods
Chainable constructors with mut self
Builder Pattern
Display and Error impls by hand
Custom Error Enum
Tallying with entry().or_insert()
HashMap & Entry API
CLI arg parser with error handling
Realistic Snippet
Fan-out work over mpsc
Threads & Channels
Structs, iterators, and formatting in one pass
Checkpoint: Real Snippets
A key=value parser typed end to end without stopping
Speed Run: Config Loader
Filter-map-sum chains at full pace
Speed Run: Iterator Pipeline
Enum transitions through match on tuples
Speed Run: State Machine
dyn dispatch over boxed shapes
Speed Run: Trait Objects
A slugify function plus its test module
Speed Run: Tests & Asserts
An event-latency report typed in one continuous run
Checkpoint: Sustained Speed
A complete word-count library with tests
Assessment Sim 1: Word Histogram
A full stdin-to-summary program
Assessment Sim 2: Temperature Stats
A complete stack evaluator with error paths
Assessment Sim 3: RPN Calculator
A full stock-movement program with rejections
Assessment Sim 4: Inventory Ledger
A ranked traffic report -- the course's graded final
Checkpoint: Rust Mastery Final
Lesson Stage
Code: Ruby
Part of the SureTyping guided lesson path.
33 lessons
Rhythm drill
Operators & Symbols
Curly-brace blocks and |param| lists
Blocks & Pipes
:name literals, key: value, and hash rockets
Symbols & Hash Keys
Pound-brace interpolation and squiggly heredocs
String Interpolation
&., ||=, and ternary conditionals
Safe Navigation & Defaults
Two-dot ranges, *args, **opts, and &:method
Ranges & Splats
Blocks, symbols, and interpolation in one longer drill
Checkpoint: Symbol Fluency
Reserved words
Keywords
Variables and constants
Declarations
attr_reader, initialize, and namespacing
Classes & Modules
Trailing if/unless the Ruby way
Guard Clauses & Modifiers
One-liners Rubyists love
Idiomatic Patterns
each_with_object, zip, tally, and friends
Enumerable Chains
An Enumerable class mixing this module's material
Checkpoint: Keywords & Idioms
Idiomatic branching
Control Flow
Small complete methods
Functions & Methods
Value objects with the spaceship operator
Struct & Comparable
begin/rescue/retry/ensure done properly
Exceptions & Retries
Reading, parsing, and writing settings
File & JSON I/O
CSV sales report
Realistic Snippet
Sharing behavior with include
Module Mixins
Structs, grouping, and formatting in one pass
Checkpoint: Real Snippets
A key=value parser typed end to end without stopping
Speed Run: Config Loader
Select-sort-sum chains at full pace
Speed Run: Enumerable Pipeline
OptionParser flags and banners
Speed Run: CLI Options
scan, tally, and sort_by in a tight loop
Speed Run: Word Frequencies
A slugify method plus its tests
Speed Run: Minitest Suite
An event-latency report typed in one continuous run
Checkpoint: Sustained Speed
A complete two-class program with Enumerable
Assessment Sim 1: Task List Program
A full ARGF-to-summary program
Assessment Sim 2: Reading Stats
A complete stack evaluator with error paths
Assessment Sim 3: RPN Calculator
A full stock-movement program with rejections
Assessment Sim 4: Inventory Ledger
A ranked traffic report -- the course's graded final
Checkpoint: Ruby Mastery Final
Lesson Stage
Code: PHP
Part of the SureTyping guided lesson path.
33 lessons
Rhythm drill
Operators & Symbols
$vars, $this->, and static:: access
Dollar Variables
->, =>, and ?-> chains
Arrows & Double Arrows
??, ??=, and elvis-style defaults
Null Coalescing
Curly interpolation, concatenation, and heredocs
Strings & Interpolation
Spreads, destructuring, and nested literals
Array Syntax
Dollars, arrows, and ?? in one longer drill
Checkpoint: Symbol Fluency
Reserved words
Keywords
Variables and constants
Declarations
implements, use, and final classes
Interfaces & Traits
Backed enums and match expressions
Enums & Match
Modern PHP one-liners
Idiomatic Patterns
array_column, usort, and the spaceship
Array Function Toolkit
A named-constructor value object with match
Checkpoint: Keywords & Idioms
Loops and branches
Control Flow
Typed functions
Functions & Methods
Named constructors for domain errors
Exceptions & Finally
JSON_THROW_ON_ERROR round trips
File & JSON I/O
Streaming a log file line by line
Generators & yield
Enum and readonly class
Realistic Snippet
Bound parameters done safely
PDO Prepared Statements
Readonly objects, array functions, and sprintf in one pass
Checkpoint: Real Snippets
A key=value parser typed end to end without stopping
Speed Run: Config Loader
Filter, usort, and slice at full pace
Speed Run: Array Pipeline
A tiny HTTP router built on match(true)
Speed Run: Match Router
filter_var and friendly error maps
Speed Run: Input Validation
A slugify helper plus its tests
Speed Run: PHPUnit Suite
An event-latency report typed in one continuous run
Checkpoint: Sustained Speed
A complete readonly-class cart program
Assessment Sim 1: Shopping Cart
A full STDIN-to-summary program
Assessment Sim 2: Reading Stats
A complete stack evaluator with error paths
Assessment Sim 3: RPN Calculator
A full stock-movement program with rejections
Assessment Sim 4: Inventory Ledger
A ranked traffic report -- the course's graded final
Checkpoint: PHP Mastery Final
Lesson Stage
Code: Swift
Part of the SureTyping guided lesson path.
33 lessons
Swift punctuation, optionals, and operator glyphs
Operators & Symbols
Chaining, nil-coalescing, and the force-unwrap bang
Optionals: ? and !
Trailing braces with $0 and $1
Closures & Shorthand Args
Backslash-paren blocks and multi-line literals
String Interpolation
Backslash-dot key paths, @ attributes, and #available
Key Paths & Attributes
Closed ... and half-open ..< in loops and subscripts
Ranges & Slices
Every Swift glyph cluster from this module in one longer drill
Checkpoint: Symbol Fluency
Swift reserved words
Keywords
let, var, and explicit types
Declarations
guard let, guard case, and throwing on failure
Guard & Early Exit
Default implementations and constrained extensions
Protocols & Extensions
Closures and optionals in daily use
Idiomatic Patterns
compactMap, grouping, first(where:), and friends
Collection Methods
A custom Sequence mixing this module's material
Checkpoint: Keywords & Idioms
Loops, guards, and branch ladders
Control Flow
Typed signatures, defaults, and async throws
Functions & Methods
Payload cases and exhaustive switches
Enums with Associated Values
Custom errors with CustomStringConvertible
Throwing Functions & Error Enums
CodingKeys, decoding, and pretty-printed encoding
Codable & JSON
Model plus view-model with async refresh
Realistic Snippet
Isolated state and structured concurrency
Actors & Task Groups
Structs, optionals, and formatting in one pass
Checkpoint: Real Snippets
A key=value parser typed end to end without stopping
Speed Run: Config Loader
filter-sort-reduce chains at full pace
Speed Run: Collection Pipeline
Enum transitions through a switch on tuples
Speed Run: State Machine
any Shape dispatch across conforming structs
Speed Run: Existentials
A slugify function plus its XCTest case
Speed Run: Tests & Asserts
An event-latency report typed in one continuous run
Checkpoint: Sustained Speed
A complete networking layer with typed errors
Assessment Sim 1: Async User Repository
A full stdin-to-summary program
Assessment Sim 2: Temperature Stats
A complete stack evaluator with error paths
Assessment Sim 3: RPN Calculator
A full stock-movement program with rejections
Assessment Sim 4: Inventory Ledger
A ranked traffic report -- the course's graded final
Checkpoint: Swift Mastery Final
Lesson Stage
Code: Kotlin
Part of the SureTyping guided lesson path.
33 lessons
Kotlin punctuation and null-safety glyphs
Operators & Symbols
Safe calls, the Elvis operator, and the double bang
Null Safety: ?. and ?:
Trailing braces, implicit it, and method references
Lambdas & it
Dollar signs, curly blocks, and raw strings
String Templates
Angle brackets, out projections, and :: references
Generics & Variance
Double-dot ranges, until, downTo, and step
Ranges & Progressions
Every Kotlin glyph cluster from this module in one longer drill
Checkpoint: Symbol Fluency
Kotlin reserved words
Keywords
val, var, and explicit types
Declarations
Default arguments, copy(), and destructuring
Data Classes & copy
Exhaustive branches over sealed interfaces
when & Sealed Hierarchies
Scope functions and null-safe one-liners
Idiomatic Patterns
associateBy, groupBy, partition, and friends
Collection Operators
A custom Iterable mixing this module's material
Checkpoint: Keywords & Idioms
when branches and loops
Control Flow
Default arguments, expression bodies, and suspend
Functions & Methods
Modelling success, failure, and pending states
Sealed Result Types
require, custom exceptions, and Result chaining
Exceptions & runCatching
Extending types you do not own
Extension Functions
Coroutine API client with a sealed load state
Realistic Snippet
flow builders, operators, and structured concurrency
Coroutines & Flow
Data classes, operators, and formatting in one pass
Checkpoint: Real Snippets
A key=value parser typed end to end without stopping
Speed Run: Config Loader
filter-sort-sumOf chains at full pace
Speed Run: Collection Pipeline
Enum transitions through when over pairs
Speed Run: State Machine
apply, receivers, and a typesafe request builder
Speed Run: Builder DSL
A slugify function plus its kotlin.test suite
Speed Run: Tests & Asserts
An event-latency report typed in one continuous run
Checkpoint: Sustained Speed
A complete caching layer over a suspend repository
Assessment Sim 1: Cached Repository
A full stdin-to-summary program
Assessment Sim 2: Temperature Stats
A complete stack evaluator with error paths
Assessment Sim 3: RPN Calculator
A full stock-movement program with rejections
Assessment Sim 4: Inventory Ledger
A ranked traffic report -- the course's graded final
Checkpoint: Kotlin Mastery Final
Lesson Stage
Code: SQL
Part of the SureTyping guided lesson path.
33 lessons
SQL punctuation and comparison operators
Operators & Symbols
Double-quoted identifiers, string literals, and :: casts
Quoting & Casts
BETWEEN, IN, LIKE, ILIKE, and IS DISTINCT FROM
Comparison & Matching
The -> ->> #>> @> family
JSONB Operators
ARRAY literals, ANY, unnest, and string_agg
Arrays & Aggregated Text
Bound parameters with COALESCE, NULLIF, GREATEST
Placeholders & Null Handling
Every SQL operator family from this module in one query
Checkpoint: Symbol Fluency
Core ANSI SQL reserved words
Keywords
Tables, indexes, and views
Declarations
INNER, LEFT, FULL OUTER, and LATERAL
Join Types
ON CONFLICT, UPDATE FROM, and DELETE USING
Upserts & Multi-Table Writes
Common SQL one-liners
Idiomatic Patterns
HAVING, aggregate FILTER clauses, and DISTINCT ON
Grouping & FILTER
A CTE, a join, and a HAVING clause in one longer query
Checkpoint: Keywords & Idioms
CASE expressions, filters, and joins
Control Flow
Aggregates and window functions
Functions & Methods
Stacked WITH blocks that read top to bottom
CTE Chains
ROW_NUMBER, RANK, LAG, and running totals
Window Functions
Correlated lookups without accidental cross joins
Subqueries & EXISTS
Monthly revenue report with CTEs and window
Realistic Snippet
BEGIN/COMMIT, FOR UPDATE, and index maintenance
Transactions & Locking
A sensor summary joining CTEs, aggregates, and HAVING
Checkpoint: Real Snippets
A rolling 30-day activity report typed without stopping
Speed Run: Daily Active Users
Boolean aggregates rolled into a single funnel row
Speed Run: Conversion Funnel
ROW_NUMBER plus DELETE USING at full pace
Speed Run: Deduplicate Rows
generate_series joined against sparse counts
Speed Run: Gap-Free Time Series
INSERT ... SELECT ... ON CONFLICT in one continuous run
Speed Run: Bulk Upsert
A latency percentile report typed in one continuous run
Checkpoint: Sustained Speed
A customer cohort report joining three CTEs
Assessment Sim 1: Cohort Retention
A complete two-stage aggregation report
Assessment Sim 2: Typing Stats by Layout
Signed movements rolled into stock levels and status
Assessment Sim 3: Inventory Ledger
Partitioned ranking with a display-name fallback
Assessment Sim 4: Layout Leaderboard
A ranked traffic report -- the course's graded final
Checkpoint: SQL Mastery Final
Lesson Stage
HTML & CSS code typing
Part of the SureTyping guided lesson path.
33 lessons
Angle brackets, attribute quotes, and CSS punctuation.
Operators & Symbols
Opening, closing, and self-closing tags with quoted attributes.
Tags & Attributes
Classes, ids, combinators, pseudo-classes, and attribute matches.
Selectors & Combinators
px, rem, ch, hex, rgb(), and timing values.
Units, Colors & Values
Double-dash declarations and var() with fallbacks.
Custom Properties
Ampersand escapes for reserved characters.
HTML Entities
Every markup and stylesheet glyph from this module in one drill.
Checkpoint: Symbol Fluency
HTML tag names and CSS at-rules, properties, and values.
Keywords
Doctype, meta tags, CSS custom properties, and base rules.
Declarations
header, nav, main, article, aside, footer, and ARIA labels.
Semantic Landmarks
label, input, select, fieldset, and the attributes they need.
Forms & Inputs
Common flex, grid, and utility patterns you reach for daily.
Idiomatic One-Liners
grid-template, sticky positioning, and logical properties.
Layout Property Vocabulary
A semantic pricing block with its stylesheet in one pass.
Checkpoint: Keywords & Idioms
Media queries, container queries, and :has() conditional styling.
Control Flow
CSS functions like calc(), clamp(), minmax(), and color-mix().
Functions & Methods
A wrapping nav bar built with flex and gap.
Flexbox Navigation
A named-area application shell that reflows on small screens.
Grid Template Areas
caption, thead, scope attributes, and zebra striping.
Accessible Data Table
A responsive landing-page hero with semantic HTML and modern CSS.
Realistic Snippet
Entrance animation with a reduced-motion escape hatch.
Keyframes & Transitions
A responsive stat strip with dark-mode overrides.
Checkpoint: Real Snippets
A full custom-property sheet typed without stopping.
Speed Run: Design Tokens
A component sheet with modifiers and focus states.
Speed Run: Button & Badge
Markup and stylesheet for a labelled form at full pace.
Speed Run: Contact Form
Four media queries and a container query in one run.
Speed Run: Breakpoint Ladder
Stack, cluster, center, and screen-reader helpers.
Speed Run: Utility Sheet
A container-query card component typed in one continuous run.
Checkpoint: Sustained Speed
A complete card grid with custom properties, grid, and dark mode.
Assessment Sim 1: Card Grid Page
A two-plan pricing block, markup and stylesheet complete.
Assessment Sim 2: Pricing Section
A full HTML document with head metadata and prose styles.
Assessment Sim 3: Article Document
Grid areas, a sidebar nav, and a responsive stat row.
Assessment Sim 4: Dashboard Shell
A complete landing page -- the course's graded final.
Checkpoint: HTML & CSS Mastery Final
Lesson Stage
Code: Bash
Part of the SureTyping guided lesson path.
33 lessons
Shell punctuation, special parameters, and redirections
Operators & Symbols
$( ) substitution, ${ } braces, and $(( )) arithmetic
Command & Arithmetic Expansion
[[ ]] string tests and (( )) arithmetic tests
Test Brackets
Streams, tee, process substitution, and heredocs
Pipes & Redirection
Single versus double quotes and $'...' literals
Quoting & Escaping
Wildcards, {a,b} lists, and numeric ranges
Globs & Brace Expansion
Every shell glyph cluster from this module in one longer drill
Checkpoint: Symbol Fluency
Bash reserved words
Keywords
Variables, arrays, and declare flags
Declarations
Indexing, expansion, and keyed lookups
Arrays & Associative Arrays
Dispatch tables and wait loops
case & until
Parameter expansion in daily use
Idiomatic Patterns
Defaults, required values, trimming, and case folding
Parameter Expansion Catalog
A field tally built from a pipe, an array, and a sort
Checkpoint: Keywords & Idioms
Loops, arithmetic conditions, and tests
Control Flow
Shell helpers with locals and guards
Functions & Methods
Field extraction, sums, and formatted output
awk One-Liners
In-place edits, line ranges, and recursive searches
sed & grep One-Liners
mktemp, lock files, and cleanup that always runs
Traps & Temp Files
Deploy script with logging, traps, and argument parsing
Realistic Snippet
Null-delimited batches and parallel fan-out
find & xargs Pipelines
A sensor summary built from awk inside a guarded script
Checkpoint: Real Snippets
A key=value parser typed end to end without stopping
Speed Run: Config Loader
awk, sort, and uniq chained at full pace
Speed Run: Log Pipeline
Flags, values, usage text, and OPTIND in one run
Speed Run: getopts Parser
A curl health check with backoff and exit codes
Speed Run: Retry Loop
A slugify function plus a hand-rolled assertion harness
Speed Run: Tests & Asserts
An event-latency report typed in one continuous run
Checkpoint: Sustained Speed
A complete backup script with logging, guards, and retention
Assessment Sim 1: Database Backup
A full stdin-to-summary program with validation
Assessment Sim 2: Temperature Stats
A complete stack evaluator with error paths
Assessment Sim 3: RPN Calculator
A full stock-movement program with rejections
Assessment Sim 4: Inventory Ledger
A ranked traffic report -- the course's graded final
Checkpoint: Bash Mastery Final
Lesson Stage
Kira Talent Typing Prep
Part of the SureTyping guided lesson path.
56 lessons
A 90-word orientation you can type in one sitting
How Kira Tests Your Typing
A 110-word timed response to measure your starting point
Diagnostic Mini-Sim
A 150-word timed baseline mixing orientation facts and response prose
Checkpoint: Baseline Diagnostic
Core words that appear in almost every Kira response
Core Admissions Vocabulary
A 60-word rotation of leadership vocabulary
Leadership Word Bank
A 62-word rotation of collaboration and conflict vocabulary
Teamwork and Conflict Word Bank
A 60-word rotation for failure, mistake, and growth prompts
Failure and Growth Word Bank
A 58-word rotation for why-this-program prompts
Motivation and Fit Word Bank
A 58-word rotation of integrity and judgment vocabulary
Ethics and Judgment Word Bank
An 80-word bank of phrases that describe what you did
Action Phrase Bank
An 82-word bank of phrases that describe what you learned
Reflection Phrase Bank
A 95-word drill that puts the word banks into real sentences
Mixed Vocabulary in Sentences
A 150-word timed drill mixing every word bank in flowing prose
Checkpoint: Vocabulary Under Pressure
Opening phrases you can lean on when the timer starts
Response Opening Stems
An 85-word bank of first sentences that frame the prompt
Framing Openers
An 88-word bank of mid-response transitions
Transition Lines
An 80-word bank of final sentences that land the answer
Closing Lines
A 100-word drill typing the situation-task-action-result shape
The STAR Skeleton
A 105-word drill on the four-move argument shape
Frame, Position, Evidence, Close
A 95-word drill on concrete, checkable detail
Evidence Sentences
A 92-word drill on credible self-assessment phrases
Honest Qualifiers
A 110-word drill combining openers, transitions, and closers
Template Remix
A 155-word timed drill chaining stems into a complete response
Checkpoint: Stems to Sentences
A 100-120 word answer to a team leadership prompt
Short Response: Leadership
A 100-120 word answer to a failure prompt
Short Response: Failure and Growth
A 105-word answer to a workplace teamwork prompt
Short Response: Carrying a Teammate
A 108-word answer to a motivation prompt, community setting
Short Response: Why This Field
A 110-word answer to an academic conflict prompt
Short Response: Disagreeing with Authority
A 106-word answer to an initiative prompt, clinical setting
Short Response: Initiative
A 112-word answer to a feedback prompt, workplace setting
Short Response: Receiving Hard Feedback
A 104-word answer to an adaptability prompt
Short Response: Adapting to Change
Two back-to-back 100-word answers, 200 words total, no pause between
Checkpoint: Two Short Responses
A 150-180 word answer to a team conflict scenario
Medium Response: Conflict
A 155-word answer to a failure prompt, research setting
Medium Response: A Public Mistake
A 160-word answer to a leadership prompt, community setting
Medium Response: Leading Volunteers
A 158-word answer to an integrity prompt, workplace setting
Medium Response: An Ethical Line
A 150-word answer to a why-this-program prompt
Medium Response: Program Fit
A 162-word answer to a resilience prompt, personal and clinical
Medium Response: Resilience
A 130-word continuous drill: type straight through, no backspace
No-Hesitation Drill I
A 135-word continuous drill at response cadence, no backspace
No-Hesitation Drill II
A 175-word timed response mixing conflict, ownership, and reflection
Checkpoint: Medium Response Under the Clock
A 180-220 word Kira-style answer on motivation for the program
Endurance: Motivation for the Program
A 200-word sustained response at full test cadence
Endurance: Leading Through a Setback
A 195-word sustained response about productive conflict
Endurance: The Team That Disagreed Well
A 205-word sustained response on failure and long-term growth
Endurance: The Mistake I Keep Learning From
A 190-word sustained response on community contribution
Endurance: Impact Beyond the Resume
Two consecutive 100-word responses, 200 words total, real cadence
Back-to-Back Block I
Two consecutive responses, 210 words total, no recovery pause
Back-to-Back Block II
A 215-word continuous response at full simulation length
Checkpoint: Endurance Block
Two written follow-ups, 250 words total, at real test cadence
Full Simulation 1 of 5
Two written follow-ups, 260 words total, ethics and self-awareness
Full Simulation 2 of 5
Two written follow-ups, 255 words total, failure and motivation
Full Simulation 3 of 5
Two written follow-ups, 265 words total, collaboration and pressure
Full Simulation 4 of 5
Two written follow-ups, 270 words total, growth and future practice
Full Simulation 5 of 5
A 300-word graded final mixing every skill in the course
Final: The Complete Kira Response
A relaxed 120-word review of the habits this course built
Cooldown: What You Take With You
Lesson Stage
Duet Typing Prep
Part of the SureTyping guided lesson path.
56 lessons
An 85-word orientation to the written side of Duet
How Duet Tests Your Typing
A 95-word rationale typed against the clock -- your baseline
Diagnostic Mini-Sim
A 150-word timed diagnostic mixing ranking, defense, and tradeoff
Checkpoint: Orientation Diagnostic
The 60-word master list of Duet values terms
Core Values Vocabulary
A 70-word drill on clinical-care values words in context
Vocabulary: Care and Safety
A 72-word drill on justice-family values words in context
Vocabulary: Fairness and Equity
A 74-word drill on integrity-family values words in context
Vocabulary: Honesty and Integrity
A 76-word drill on resource-values words in context
Vocabulary: Stewardship and Cost
A 78-word drill on the connective words every ranking needs
Vocabulary: Comparison Words
An 80-word bank of priority-claim phrases typed as prose
Phrase Bank: Stating Priority
An 82-word bank of tension-naming phrases typed as prose
Phrase Bank: Naming the Tension
A 75-word drill on public-facing values words in context
Vocabulary: Community and Policy
A 155-word timed passage weaving the module's vocabulary into live reasoning
Checkpoint: Values Vocabulary in Context
Opening stems that structure a written Duet justification
Rationale Stems
An 85-word drill on first-sentence templates for any ranking
Opening Templates
An 88-word drill on sentence shapes that compare two profiles
Comparison Templates
An 84-word drill on the connective tissue between ranking moves
Transition Drills
A 90-word drill on the concession sentence that closes strong rationales
Tradeoff Sentences
An 86-word drill on final sentences that land the rationale
Closing Templates
An 88-word drill on acknowledging the other side without folding
Concession Stems
A 92-word no-pause drill typing complete four-value orderings
Full Ranking Sentences
A 95-word drill on commas, colons, semicolons, and dashes in ranking prose
Punctuation Flow for Rationales
A 160-word timed passage assembling the module's templates into one response
Checkpoint: Stems to Full Rationale
A 110-130 word healthcare-scenario rationale
Short Rationale: Clinic Priorities
A 110-130 word educational-scenario rationale
Short Rationale: Education Policy
A 105-word clinical rationale on safety versus efficiency
Short Rationale: Night-Shift Handover
A 108-word academic rationale on fairness versus seniority
Short Rationale: Lab Authorship
A 106-word workplace rationale on honesty versus loyalty
Short Rationale: Deadline Disclosure
A 110-word community rationale on urgent need versus sustainability
Short Rationale: Shelter Funding
A 104-word clinical rationale on consent versus throughput
Short Rationale: Translator or Timeline
A 107-word workplace rationale on impartiality versus friendship
Short Rationale: The Referral Favor
A 165-word timed block -- two short rationales typed back to back
Checkpoint: Two Short Rationales
A 150-180 word response weighing competing values
Trade-off Analysis
A 145-word clinical rationale ranking four values under pressure
Medium Rationale: The Overbooked Clinic
A 140-word academic rationale on transparency versus discretion
Medium Rationale: The Curved Exam
A 150-word workplace rationale on accountability versus self-preservation
Medium Rationale: The Whistle and the Ladder
A 145-word community rationale on inclusion versus economic growth
Medium Rationale: The Park or the Parking
A 135-word continuous drill -- four mini-rankings, zero pauses
No-Hesitation Drill: Rapid Rankings
A 130-word continuous drill on typing concessions without stalling
No-Hesitation Drill: Concessions at Speed
A 148-word clinical rationale on education versus patient preference
Medium Rationale: The Student on the Ward
A 170-word timed rationale demanding every mid-length skill at once
Checkpoint: The Full Middle Game
A 180-220 word ranking and defense
Full Ranking and Defense
A 190-word sustained rationale on public safety versus company survival
Endurance: The Recall Decision
A 185-word sustained rationale on merit, need, and the donor's wishes
Endurance: The Scholarship Committee
A 195-word sustained rationale on confidentiality inside a small community
Endurance: The Volunteer Board Conflict
Two complete rationales, 200 words total, typed in one sitting
Back-to-Back Block I
Two complete rationales, 205 words total, at real test cadence
Back-to-Back Block II
A 200-word sustained rationale on housing, heritage, and who gets heard
Endurance: The Zoning Vote
A 210-word timed defense mixing every endurance skill in the module
Checkpoint: Endurance at Full Depth
Two full rationales, 250 words total, under one continuous clock
Full Simulation 1 of 5
Two full rationales, 260 words total, academic and community scenarios
Full Simulation 2 of 5
Two full rationales, 265 words total, clinical and workplace scenarios
Full Simulation 3 of 5
Two full rationales, 270 words total, policy and education scenarios
Full Simulation 4 of 5
Two full rationales, 275 words total, the hardest pairings in the course
Full Simulation 5 of 5
A 290-word graded final -- one scenario, one full ranking, every skill
Final: The Complete Duet Defense
A 110-word reflective review to close the course
Cooldown: What Your Fingers Now Know
Lesson Stage
Snapshot Written Follow-up Prep
Part of the SureTyping guided lesson path.
55 lessons
A 100-word orientation to the written side of Snapshot
Why Typing Matters for Snapshot
A timed 65-word reflection -- type it once, note your speed and accuracy
Diagnostic Mini-Simulation
A 135-word timed passage that sets your starting numbers
Checkpoint: Your Baseline
High-frequency words for one and two minute reflections
Quick Response Vocabulary
A 55-word bank of the action words reflective answers run on
Verbs of Reflection
A 55-word bank of honest emotional vocabulary
Naming How It Felt
A 55-word bank for talking about progress without cliches
Growth and Habit Vocabulary
A 65-word bank of the glue words that hold short reflections together
Connector Phrases
A 55-word bank of the people and settings your stories live in
People and Places
A 55-word bank of value words worth having in your fingers
Values Vocabulary
A 55-word bank spanning clinical, academic, workplace, and community life
Settings Across Domains
A 75-word bank of ready-made phrases for reflective answers
Phrase Bursts
A 125-word timed passage built from this module's word banks
Checkpoint: Vocabulary in Motion
Short hooks that buy you time to think on Snapshot follow-ups
Opener Phrases
A 105-word drill on the three-sentence shape that fits any window
Position, Reason, Tradeoff
A 100-word drill moving smoothly between ideas mid-response
Transitions in Real Sentences
A 95-word bank of endings that land instead of trailing off
Closing Lines
A 95-word drill on extending an answer you just gave out loud
Bridging from Video to Writing
A 100-word drill on sounding truthful without undermining yourself
Honest Qualifiers
A 95-word drill on landing a concrete example in one sentence
Introducing an Example
A 100-word drill on naming the cost of your own choices
Tradeoff Sentences
A 110-word run combining openers, transitions, tradeoffs, and closers
Mixed Template Drill
A 140-word timed passage chaining every template in the module
Checkpoint: Templates Under Pressure
A tight 60-80 word reflective paragraph
One-Minute Response I
A tight 60-80 word reflective paragraph
One-Minute Response II
A 75-word reflection from a free-clinic waiting room
One-Minute Response III
A 78-word reflection on an academic setback
One-Minute Response IV
A 74-word reflection on a workplace disagreement
One-Minute Response V
A 72-word reflection on ordinary service
One-Minute Response VI
A 70-word reflection on a daily habit
One-Minute Response VII
A 74-word reflection on the shortest feedback I ever received
One-Minute Response VIII
Three back-to-back 55-word reflections, 165 words in total
Checkpoint: Three One-Minute Rounds
A 130-160 word deeper reflection
Two-Minute Response I
A 150-word reflection on a manager who shaped my standards
Two-Minute Response II
A 155-word reflection on disagreeing without damage
Two-Minute Response III
A 150-word reflection on a research failure and its lesson
Two-Minute Response IV
A 150-word reflection on values observed in a clinical setting
Two-Minute Response V
A 150-word reflection on teamwork during a community project
Two-Minute Response VI
A 135-word steady passage -- type straight through, no backspacing
No-Hesitation Drill I
A 140-word reflective passage typed straight through, no backspacing
No-Hesitation Drill II
A 170-word timed reflection mixing the module's themes
Checkpoint: Two Minutes, No Stalls
Two paired responses totaling 200-240 words
Paired Responses I
Two back-to-back reflections totaling about 190 words
Paired Responses II
Two back-to-back reflections totaling about 200 words
Paired Responses III
A single 200-word response held at steady cadence
Sustained Reflection I
A single 205-word response held at steady cadence
Sustained Reflection II
Three quick follow-ups at test rhythm, about 195 words total
Real Cadence Drill
A 210-word paired block mixing the module's themes at test rhythm
Checkpoint: Full Cadence Block
Three written follow-ups at full length, about 250 words
Full Simulation 1 of 5
Three written follow-ups at full length, about 255 words
Full Simulation 2 of 5
Two longer written follow-ups, about 250 words total
Full Simulation 3 of 5
Three written follow-ups at full length, about 260 words
Full Simulation 4 of 5
Three written follow-ups at full length, about 265 words
Full Simulation 5 of 5
The graded final -- three follow-ups, about 270 words at full test cadence
Final: Snapshot Written Follow-up Assessment
A relaxed 95-word review lap -- no timer pressure, just smooth typing
Cooldown: What You Trained
Lesson Stage
GRE Analytical Writing Typing Prep
Part of the SureTyping guided lesson path.
55 lessons
A 100-word orientation to the AWA typing workload
What the 30-Minute Essay Asks of Your Hands
A timed 110-word essay block to set your baseline
Diagnostic Sprint
A timed 150-word block mixing claim, evidence, and close
Checkpoint: Baseline Essay Block
Formal vocabulary expected in a 30-minute GRE essay
Academic Writing Vocabulary
A 60-word rotation of argument-analysis terms
Reasoning and Logic Vocabulary
A 60-word rotation of evidence-handling terms
Evidence and Data Vocabulary
A 70-word drill on qualifiers that keep claims defensible
Hedging and Qualification
A 65-word drill on the language of disagreement
Contrast and Concession Vocabulary
A 75-word drill of phrase pairs that recur in strong essays
Academic Collocations
A 75-word drill placing precise verbs in short sentences
Strong Academic Verbs
A 100-word drill weaving formal vocabulary into flowing prose
Vocabulary in Full Sentences
A timed 150-word relay mixing every vocabulary drill in this module
Checkpoint: Vocabulary Under the Clock
Connecting phrases that move an essay forward without clutter
Formal Transitions
An 85-word drill of thesis shapes you can adapt to any prompt
Thesis Statement Templates
A 90-word drill of openers that announce a paragraph's job
Topic Sentence Templates
An 85-word drill of phrases that introduce and interpret support
Evidence Transitions
A 90-word drill of concede-then-answer sentence pairs
Concession and Rebuttal Frames
An 85-word drill of closings that resolve without repeating
Conclusion Frames
A 95-word drill of first sentences on varied Issue themes
Opening Sentences Across Topics
A 110-word passage showing pivots inside real paragraphs
Transitions in Context
A timed 160-word relay chaining thesis, topic, evidence, and close
Checkpoint: Template Relay
A 130-160 word original introduction on an Issue prompt
Essay Introduction Paragraph
A 110-word thesis-plus-support paragraph on a technology prompt
Short Response: Automation and Work
A 110-word paragraph staking a qualified position on testing
Short Response: Standardized Testing
A 105-word paragraph arguing from a concrete civic example
Short Response: Urban Green Space
A 110-word paragraph testing a claim against its strongest objection
Short Response: Public Funding for the Arts
A 110-word paragraph reasoning about unpredictable payoffs
Short Response: Funding Basic Research
A 105-word paragraph on a governance prompt with a clear close
Short Response: Civic Participation
A 100-word burst of complete claims -- type without pausing
No-Hesitation Drill: Claim Sentences
A timed 210-word double block on two unrelated prompts
Checkpoint: Two Short Paragraphs Back-to-Back
A 180-220 word original body paragraph with analysis
Body Paragraph with Evidence
A 180-220 word paragraph analyzing an argument's flaws
Argument Analysis Paragraph
A 185-word body paragraph built on a historical comparison
Body Paragraph: Historical Evidence
A 180-word body paragraph tracing incentives to outcomes
Body Paragraph: Economic Reasoning
A 175-word paragraph granting the objection its full strength first
Body Paragraph: Concede and Rebut
A 180-word paragraph that earns its general claim from one case
Body Paragraph: Example-Driven
A 120-word conclusion that resolves without restating
Conclusion Paragraph
A 140-word unbroken analytical passage -- keep the cursor moving
No-Hesitation Drill: Continuous Analysis
A timed 220-word block chaining a body paragraph into a close
Checkpoint: Body Plus Conclusion
A 320-380 word combined essay opening for the 30-minute drill
Full Intro + One Body
A 200-word double paragraph typed at steady essay pace
Two Paragraphs at Cadence I
A 205-word double paragraph on a policy prompt
Two Paragraphs at Cadence II
A 190-word drill pairing an introduction with its conclusion
Opening and Closing Pair
A 215-word set of two unrelated blocks with no reset between
Back-to-Back Essay Blocks
A 180-word single paragraph -- hold one even pace throughout
Steady Cadence Block
A 165-word passage typed the way a final read-through sounds
The Editing Voice
A 190-word relay moving from word bank to frames to full prose
Mixed Relay: Vocabulary to Paragraph
A timed 230-word sustained block -- half a real essay's length
Checkpoint: Fifteen-Minute Feel
A timed 290-word block -- one section of the real 30-minute essay
Full Simulation 1 of 5: The Apprenticeship Claim
A timed 280-word block -- one section of the real 30-minute essay
Full Simulation 2 of 5: The Heritage Argument
A timed 300-word block -- one section of the real 30-minute essay
Full Simulation 3 of 5: Technology and Attention
A timed 290-word block -- one section of the real 30-minute essay
Full Simulation 4 of 5: The Survey Argument
A timed 310-word block -- one section of the real 30-minute essay
Full Simulation 5 of 5: Progress and Its Critics
A graded 320-word finale at full 30-minute cadence
Final: The Complete Essay Block
A slow 75-word accuracy pass -- precision over pace
Cooldown: Accuracy Reset
Lesson Stage
LSAT Writing Sample Typing Prep
Part of the SureTyping guided lesson path.
55 lessons
A 100-word orientation to the LSAT Writing typing workload
What the 35-Minute Essay Asks of Your Hands
A timed 110-word decision block to set your baseline
Diagnostic Sprint
A timed 150-word block with a choice, a reason, and a concession
Checkpoint: Baseline Argument Block
Vocabulary that signals clear legal-style reasoning
Argumentative Vocabulary
A 60-word rotation of terms from the law's neighborhood
Legal-Adjacent Vocabulary
A 65-word drill on the language of stated standards
Criteria and Objectives Vocabulary
A 70-word drill on comparative judgment phrases
Weighing and Balancing Vocabulary
A 75-word drill placing precise argument verbs in short sentences
Argument Verbs
A 75-word drill of phrase pairs that recur in strong samples
Decision-Essay Collocations
A 70-word drill on qualifiers that keep a recommendation honest
Qualification and Precision
A 100-word drill weaving decision vocabulary into flowing prose
Vocabulary in Full Sentences
A timed 150-word relay mixing every vocabulary drill in this module
Checkpoint: Vocabulary Under the Clock
Sentence frames for announcing and defending a choice
Framing Phrases
An 85-word drill of first sentences that commit immediately
Decision Openers
A 90-word drill of sentences that measure options against standards
Criteria Application Frames
A 90-word drill of honest acknowledgments of the other option
Concession Frames
A 90-word drill of sentences that answer the concession
Rebuttal Frames
An 85-word drill naming what each option buys and surrenders
Tradeoff Frames
An 85-word drill of endings that resolve the weighing cleanly
Closing Frames
A 110-word passage that walks the five-block essay shape
The Essay Structure, Typed
A timed 160-word relay chaining opener, criteria, concession, and close
Checkpoint: Frame Relay
A 130-160 word paragraph announcing and framing a choice
Decision Statement Paragraph
A 105-word response defending the reversible option
Short Response: Hours or a Second Site
A 110-word response weighing this year against next
Short Response: The Museum Season
A 105-word response measuring the six weeks against the eighteen months
Short Response: Generalist or Specialist
A 105-word response on cost, timing, and postponement
Short Response: Repair or Bypass
A 115-word response that answers its own strongest objection
Short Response: Longer Days or a Summer Term
A 110-word response on recoverable and unrecoverable losses
Short Response: A Second Location or Deeper Roots
An 85-word drill of openers typed without pausing
No-Hesitation Drill: Commit in One Sentence
A timed 155-word block chaining two complete short responses
Checkpoint: Short Responses Under the Clock
A 180-220 word paragraph building the affirmative case
Supporting Reasons Paragraph
A 180-220 word paragraph acknowledging and rebutting the alternative
Addressing the Counter-Option
A 175-word body block that lets a stated ranking do the work
Applying the Criteria in Order
A 170-word body block built only from supplied facts
Grounding Reasons in the Scenario
A 165-word body block choosing the recoverable mistake
Weighing Risk and Reversibility
A 180-word block that refuses to weaken the objection
Stating the Other Side at Full Strength
A 175-word block that rebuts without dismissing
Answering the Objection
A 130-word ending that finishes the weighing instead of restating it
The Close That Resolves
A 100-word drill of concessions that pivot in the same breath
No-Hesitation Drill: Concede and Turn
A timed 195-word relay running support, counter, and close
Checkpoint: Body Blocks Under the Clock
A 185-word run from the opening commitment through the first reason
Frame Plus Decision, Back to Back
A 190-word run pairing the affirmative case with its best objection
Two-Block Run: Support and Counter
A 185-word run from ranked criteria to a resolved ending
Two-Block Run: Criteria and Close
A 180-word run that commits early and resolves cleanly
Opening and Closing in One Pass
A 185-word run resolving three unrelated decisions in sequence
Back-to-Back Scenarios
A 195-word passage on pacing the session, typed at that pace
Real Cadence: Thirty-Five Minutes in Miniature
A 180-word passage on the five moves of the last four minutes
The Revision Pass
A timed 215-word block running frame, decision, counter, and close
Checkpoint: Endurance Block
A timed 410-word full draft -- framing, decision, counter, and close
Full Simulation 1 of 5: The Vendora Grant
A timed 315-word decision essay on access and irreversible risk
Full Simulation 2 of 5: The Ferry and the Causeway
A timed 315-word decision essay on stability against capability
Full Simulation 3 of 5: The Interim Director
A timed 320-word decision essay weighing depth against completion
Full Simulation 4 of 5: The Language Requirement
A timed 315-word decision essay on concentration against diversification
Full Simulation 5 of 5: The Watershed Easement
A graded 350-word essay -- the full 35-minute workload end to end
Final: The Pro Bono Commitment
A 150-word review passage to type slowly after the final
Cooldown: What the Reader Is Looking For
Lesson Stage
Coding Assessment Typing Prep
Part of the SureTyping guided lesson path.
55 lessons
A 110-word orientation to what the clock actually charges you
The Typing Tax on a Timed Assessment
A timed restatement plus a short Python solution to set your baseline
Diagnostic Sprint
A timed 150-word block mixing restatement, code, and a complexity note
Checkpoint: Baseline Hybrid Block
Common assessment function signatures across languages
Function Signatures
Imports and class skeletons every assessment begins with
Boilerplate Openers
A 16-line drill of declaration shapes in Python, Java, and Go
Type and Collection Declarations
A 15-line drill of stdin parsing, the mini problem before the problem
Input Parsing Rituals
A 20-line drill of the linked-list and tree definitions you retype constantly
Node and Struct Skeletons
A 18-line drill of the main blocks that prove a solution runs
Test Harness Blocks
A 70-token drill of the symbol runs that slow every language down
Operator Glyph Clusters
A 16-line drill of the dense bracket work that costs the most keystrokes
Collection Literals and Comprehensions
A timed 22-line relay from empty editor to a running, tested skeleton
Checkpoint: Cold Start Under the Clock
An 85-word drill of the sentences that prove you read the prompt
Problem Restatements
A 90-word drill of the limits that decide which approach fits
Constraint Statements
A 95-word drill explaining running time the way a reviewer wants to read it
Complexity in Words
An 85-word drill of the cases that separate a passing submission from a partial one
Edge Case Enumerations
A 16-line drill of comments in four comment syntaxes
Comment Lines
A 17-line drill of the plan you sketch before you commit to syntax
Pseudocode Blocks
An 80-word drill of the questions worth asking before you type
Clarifying Questions
A 100-word drill of the paragraph that frames a solution before the code
Approach Summaries
A timed 160-word relay chaining restatement, constraints, plan, and complexity
Checkpoint: Explanation Under the Clock
A working two-sum on a sorted array in Python
Two-Pointer Pattern
Longest substring without repeating characters in JavaScript
Sliding Window Pattern
An 18-line Python drill on the exact-match and lower-bound variants
Binary Search and Its Boundary Form
A 17-line Java drill on frequency maps and anagram grouping
Hash-Map Counting
A 19-line Python drill on running totals and subarray counting
Prefix Sums
A 20-line TypeScript drill on the classic validity check
Stack and Bracket Matching
A 18-line drill on custom orderings in Python, Java, and Go
Sorting With a Comparator
A 20-line C++ drill on swapping without extra allocation
In-Place Reversal and Rotation
A timed 26-line relay chaining a window, a binary search, and a counter
Checkpoint: Core Patterns Under the Clock
A reusable breadth-first search template in Python
BFS Template
Bottom-up coin change in Python
Dynamic Programming Template
A 22-line Python drill on depth, path sums, and traversal order
Recursive DFS on a Tree
A 24-line Python drill on flood fill and connected-component counting
Grid Traversal
A 21-line Python drill on top-down caching and grid paths
Memoized Recursion
A 23-line Python drill on subsets, permutations, and the undo step
Backtracking
A 20-line drill on the k-largest pattern in Python and Java
Heaps and Priority Queues
A 22-line Python drill on disjoint sets with path compression
Union-Find
A timed 27-line relay chaining a graph build, a search, and a DP table
Checkpoint: Graphs and DP Under the Clock
A 170-word block running the full answer shape without a pause
Restate, Solve, Explain
A 34-line Python program with a helper, a solver, and a harness
Multi-Function Program
A 180-word block narrating a bug and typing the corrected function
Debugging a Failing Case
A 175-word block retyping a working solution into its cleaner form
A Refactor Pass
A 200-word block solving two short problems without stopping between them
Back-to-Back Problems
A 30-line block typing the parsing ritual and the solve in one run
Input-Heavy Setup
A 185-word block alternating prose and code at even pace
Steady Cadence Block
A 190-word block typing the same solution twice, in Python and in Go
Mixed Language Block
A timed 210-word block with restatement, edge cases, solution, and analysis
Checkpoint: Full Answer at Real Cadence
A timed 250-word answer -- restatement, solution, and analysis
Full Simulation 1 of 5: Interval Scheduling
A timed 260-word answer in JavaScript with a full test harness
Full Simulation 2 of 5: String Compression
A timed 280-word answer -- a topological sort with cycle detection
Full Simulation 3 of 5: Course Ordering
A timed 270-word answer -- parsing, counting, and formatted output
Full Simulation 4 of 5: Word Frequency Report
A timed 290-word answer -- a dynamic programming table with a space reduction
Full Simulation 5 of 5: Matrix Path Cost
A graded 320-word block -- clarify, restate, plan, implement, analyze
Final: The Complete Assessment Answer
A 130-word prose review to close the course at an easy pace
Cooldown: What the Drills Bought You
Get the course
Save $18 · 32%Go beyond the basics on Colemak
3 courses · 200 drills · ~17.2 hrsThese beginner lessons are free. Complete Colemak Mastery adds the intermediate, advanced, and punctuation & numbers courses — one-time purchase, lifetime access.
$57 if bought separately — this bundle is $39, saving you $18.
One-time purchase · lifetime access · first 2 lessons free · 30-day money-back guarantee
Or buy one Colemak course on its own
Each stage of the Colemak path sells separately. The bundle above costs less than any two of them together.
Colemak IntermediateBuild real typing fluency on Colemak. Practice common words, phrases, and sentences, then master capital letters and proper Shift technique for both hands.$19Colemak AdvancedThe deep-dive Colemak mastery course. Speed drills, accuracy gauntlets, real-world typing (emails, essays, code, legal docs, academic citations), endurance runs, and comprehensive mastery challenges.$19Colemak Punctuation & NumbersMaster every number, symbol, and punctuation mark on Colemak. From the number row to special characters, emails, dates, and code — type it all with confidence.$19