What hand-typing trains

Line by line, attention catches brackets, indentation, names. You cannot skim a fence the way you skim a paragraph. This is not about chasing a WPM record — it is about making syntax stop feeling foreign.

Pasting from an article or a chat saves minutes and skips practice. You get a working file and empty muscle memory. Tomorrow, without the tab, you stumble on getattr again. The trainer on this site is deliberate practice: a short fragment, accuracy metrics, no heavy libraries in the browser.

In production we do not retype libraries for sport. A lesson fragment is a scale: small, repeatable, measurable. Scales are not the concert, but without them the concert falls apart. Start from the landing page or open the trainer directly.

When AI speeds you up — and when it hurts

AI fills empty space on the screen well. It fills empty skill more poorly. If a model writes every lesson file for you, you train prompting — useful, but different. Deliberate practice is short reps with accuracy feedback, not “the model did it for me.”

AI helps when you already hold the loop: draft a test you will edit; explain a traceback you already reproduced; port a pattern you understand. It hurts early on, when you do not yet feel Python indentation or cuda → mps → cpu: autocomplete hides gaps, and you accept something that “looks right,” skipping the stumble that would have taught you.

The typing trainer is not an IDE. It does not run your code or suggest the next line. It checks whether your keystrokes match a reference from the article. Dependencies and tests stay local when the material needs them. The split is intentional: chat speeds work; the trainer trains attention.

How to read courses and posts with the trainer

Code on this site shows up in two places: course lessons and regular blog posts. The article stays an article — theory, commands, walkthroughs. Next to fragments worth typing by hand you will see an explicit Train (or “Type in trainer”) link. Other code blocks in learning material often carry a soft link to the trainer landing page.

A simple ritual:

1. Read why the fragment is in the post.
2. Open the link — the reference loads in the trainer.
3. Type to a full match; watch accuracy, not only WPM.
4. Return to the text. If the material has a companion repo or local checks, assemble the file on your machine and run tests there — not in the browser.

In courses, practice blocks are often tied to lesson files: a short slice → typing → the full file in a repo. In ordinary posts the trainer link is a way to stop skimming and lock syntax, even when there is no lab nearby. Terminal output, bash, and unmarked fences stay copy-only — they are not drills.

The trainer does not install dependencies, clone a repository, or replace your terminal. There is no language sandbox in the browser on purpose: a real environment stays local. The site links prose to typing; packages and hardware stay with you.

What an exercise is

1. Pick language, level, and mode (plus sliders when needed: how much to hide, how long to show the reference).
2. Load a bank example, generate one, or arrive from a blog block with the code already filled in.
3. Type in the input. Characters are checked against the reference: green = match, red = mistake.
4. The drill ends only on a full match. Then you see stats, the next example, or a link back to the article.

Panel metrics: accuracy, WPM, mistakes, time. For learning, a clean finish beats a WPM spike with typos. The Train button on a blog code block always opens full; you can switch modes in the setup panel afterward.

Modes: from full scaffolding to cold recall

Six modes are not “harder is better.” Each removes a different crutch.

full — first pass

The whole reference stays visible. You type alongside it.

When: first time with a snippet; unfamiliar syntax; longer blocks where structure matters.

How: one calm pass to 100% accuracy. If you stall on a name, reread that line aloud, then continue.

partial — holes in the reference

Some lines are hidden (slider sets the share). You reconstruct them from neighbors.

When: you already did full; you want to check import → function → return links.

How: try 30–50% hidden. Guessing often? Back to full. Too easy? Raise the hide ratio or move to memory.

memory — from memory

The reference shows for N seconds, then disappears. You type what you retained.

When: short snippets; preparing to write similar code without the article open.

How: start at 15–20 seconds. Do not peek at the article tab. End-of-run mistakes show what did not stick.

fillblanks — fill the gaps

Key pieces are cut out of the reference. Restore them exactly.

When: you know the shape but mix up API details.

How: one pass; note which gaps hurt — a one-day note, not a forever wiki.

hints — skeleton

You see a scaffold and hints, not a full reprint list. Closer to “rebuild from a contour.”

When: full/partial already feel solid; bridging toward your editor.

How: finish a try before opening the real file in a repo. Then diff.

implement — from a prompt

You see the task text, not the solution. Matching is against a stored reference (strict character match).

When: bank exercises with a description; checking whether you can reproduce a pattern cold.

How: do full on the same snippet first, then implement a day later. Exact match is harsh — use it on short canonical snippets; otherwise return to partial/memory.

A weekly ritual

Use Train on a blog block to jump in with code ready. Bank + mode switching live on the trainer page.

Accuracy, WPM, leaderboard

• Accuracy is the learning signal. Aim for 100% per pass.
• WPM is secondary; it rises when brackets stop feeling foreign.
• Mistakes matter by where (indent, quotes, names), not only count.
• The leaderboard blends speed and accuracy; set a nick in the progress widget. Motivation, not an exam.

Open practice: landing page, trainer, leaderboard.