For a developer, the impulse is delightful: a tiny command-line tool that greets you each morning with a random character to practice. It is a quick build and a real habit cue, and there is nothing wrong with making it. The honest part is what a CLI can and cannot be. It can choose a character; it cannot watch you write, correct you, or remember what you keep failing. And tracing what it prints is recognition, not recall.
The build is easy and genuinely useful
A daily-character CLI is a few lines: read a list of characters, print a random one, optionally seed the choice by the date so the same character shows all day, and wire it to your shell startup. As a prompt it works, it puts a character in front of you every day, which beats meaning to practice and forgetting. That habit value is real, and it sits naturally alongside other terminal-friendly tooling like a Yomichan or Pleco-integrated workflow or running practice software on a Steam Deck via a compatibility layer.
What a terminal cannot do
A CLI prints; it does not perceive. It cannot see your strokes, so it cannot tell you the order was wrong or a component was mis-proportioned, and it has no model of your performance, so it cannot decide which characters to resurface and when. Those two gaps, feedback and scheduling, are exactly the parts that make practice improve rather than merely repeat. The terminal is a launcher, not a tutor, even when the underlying character structure looks like a tidy object graph.
Recognition is not recall
There is a deeper issue than feedback: tracing a printed character is the easy, cued version of the task. The shape is already there and your hand follows it, so memory is never tested. Writing is the uncued version, producing the character from nothing. The testing effect shows that retrieval, not re-exposure, builds memory, so a daily character to trace is a prompt, not the practice. To make it count you have to reproduce it from memory, the same reason components are worth learning algorithmically rather than just looking at them.
What actually makes a daily character stick
Three things the CLI lacks. Produce it from memory, because for Chinese handwriting beats typing for learning and recall beats recognition. Get feedback, so a wrong stroke order is corrected rather than ingrained. And space it, because the spacing effect and decades of distributed-practice research show spread-out, performance-driven review is what holds. A random pick each day, with none of these, is a nudge without a loop.
CLI launcher versus practice loop
| Daily-character CLI | Practice loop |
|---|---|
| Picks and prints a character | Makes you produce it from memory |
| No view of your strokes | Stroke-order and structure feedback |
| Same odds every day | Performance-driven spacing |
| A habit cue | The learning itself |
Keep the CLI for the cue; hand the practice to something that closes the loop, the way a Linux-native spaced-repetition writing app does.
A plan for the developer-learner
- Build the CLI as your daily nudge, seeded by date.
- Treat the printed character as a prompt, not the lesson.
- Reproduce it from memory, not by tracing the print.
- Get stroke-order and structure feedback on the attempt.
- Let a spacing schedule, not a coin flip, choose repeats.
How Hanzi Write Practice fits
Hanzi Write Practice is the loop your CLI should hand off to. It hides the character, you produce it from memory, and it checks stroke order and structure with spaced repetition, the feedback and scheduling a terminal cannot do. It is honest about that division of labor: a daily-character CLI is a charming habit tool, and the practice that actually builds writing is from-memory production with correction. Build the launcher, then let the loop teach. The app is in early access.
Bottom line
A random-character CLI is an easy build and a fine daily nudge, but a terminal can only show a character, not grade your writing or schedule your memory, and tracing a printed character is recognition, not recall. The learning needs from-memory production with feedback and spacing. Hanzi Write Practice supplies that loop, and it is in early access, so join the list.
Frequently asked questions
Can a command-line tool teach me to write Chinese characters?
A CLI can pick and display a daily character, which is a good habit cue, but it cannot watch your hand, check stroke order, or schedule review by how you did. Tracing a character it prints is recognition, not recall. So a CLI is a fine launcher, while the actual learning needs from-memory production with feedback, which a tool like Hanzi Write Practice provides.
How hard is it to build a random-character CLI?
Not hard. A few lines that read a character list and print a random entry, optionally seeded by the date so it is stable per day, gets you a daily-character command. The build is satisfying and useful as a prompt, but it only chooses what to practice; it does not evaluate or schedule the practice itself.
Why is tracing a printed character not enough?
Because tracing is recognition: your hand follows a shape that is already in front of you, so memory is not tested. Recall is producing the character from nothing, which is what writing actually requires. A printed character to trace is a starting prompt, but the learning happens when you reproduce it from memory and get corrected.
What should the CLI hand off to for real practice?
To a tool that makes you produce the character from memory, checks stroke order and structure, and spaces the repeats by performance. The CLI handles the daily nudge; the practice tool handles feedback and scheduling. Hanzi Write Practice is built for that production-and-spacing loop.
Built the CLI already? Join early access and give it a real practice loop to call.