I Tried Teaching CLI With Screenshots Only — Retention Was Worse

I ran a small teaching experiment I hoped would save time: rebuild a beginner Windows CLI module as a screenshot-only walkthrough. No interactive terminal. No copy-paste sandboxes. Just annotated images, arrows, and “type this” captions—optimized for people who say they learn visually.

Retention got worse. Not in a subtle A/B rounding-error way. In a “they couldn’t replay the skill cold two days later” way.

Setup

• Audience: Windows-first juniors, mixed CMD/PowerShell intro.
• Content: same objectives as my usual interactive path (navigate, create/delete, pipe/filter, exit codes).
• Treatment: screenshot storyboard + short captions.
• Control (prior cohort pattern): type-at-the-prompt drills with immediate feedback.
• Check: short practical quiz after the module + a delayed quiz ~48 hours later.

This wasn’t a massive RCT. It was honest classroom instrumentation. Still enough to kill my screenshot fantasy.

What improved (briefly)

• Anxiety dropped on minute one. Screenshots feel safe.
• Skimming speed increased. People “finished” the module faster.
• Aesthetic satisfaction from me, the author. Dangerous metric.

What collapsed

False fluency

Learners recognized screens. Recognition ≠ recall. Asked to reproduce without the image, many froze at the empty prompt—the exact opposite of what operators need.

Hidden ambiguity

Screenshots flatten shell identity. Was that CMD or PowerShell? Which profile? Where was cwd? The image looked authoritative while omitting state.

No error reps

Real CLI skill is half recovery. Screenshots mostly show the happy path. When quiz tasks forced typos and permission errors, the screenshot cohort had fewer recovery instincts.

Pace lying

Finishing a gallery isn’t practice. It’s tourism.

The mechanism (why I should have predicted this)

Motor and decision practice at the prompt builds a loop: intention → keystrokes → feedback → adjustment. Screenshots interrupt that loop and replace it with “match the picture.” Matching pictures is a different sport.

Also: CLI competence is heavily stateful (cwd, env, errorlevel, policy). A static frame under-teaches state.

What I changed afterward

• Screenshots became optional orientation, never the practice channel.
• Every objective needs at least one typed success and one typed recovery.
• I measure “can do cold” instead of “clicked through.”
• I keep lessons short enough that friction doesn’t equal dropout—because interactive has its own failure mode if prompt #3 feels cruel.

That last point is personal: when I instrumented my own drills, learners quit early when the prompt jumped difficulty without a win. Screenshots hid that quit point by never creating it—then the quit happened later, on the job.

What I kept from the screenshot experiment

Screenshots still help for:

• Orientation (“this is what Windows Terminal’s profile dropdown looks like”).
• Rare GUI steps (environment variable dialog).
• Accessibility captions alongside—not instead of—practice.

They failed as the primary practice medium. That distinction salvaged the week of work instead of trashing it.

Measurement I’d insist on next time

Don’t ask “did you like the module?” Ask:

1. Cold reproduce in an empty terminal.
2. Recover from one planted error.
3. Name which shell they used.

If they can’t do those, the module didn’t teach CLI—it taught page-turning.

Hybrid template I use now

1. One screenshot for orientation (optional).
2. Three typed successes.
3. One typed failure + recovery.
4. One cold redo without scrolling up.

That template is slower to write than a gallery. It produces operators instead of page-turners.

If you want the interactive version of this philosophy, it’s what I’m refining in CMD Master: practice in a browser terminal, not a scavenger hunt through images.

Takeaway: Visuals assist. They don’t replace reps. For CLI, the prompt is the classroom.