How I Have AI Auto-Generate My Preschooler's Hiragana Drills, Timed to a Forgetting Curve

Good morning, it’s まさきん.

With a preschooler at home, I end up buying replacement hiragana practice books pretty often. The problem is that store-bought drill books test every character equally — including the ones my kid can already write.

So I built a system that has AI auto-generate practice sheets that only repeat the characters my child gets wrong. In this post, I’ll go into detail on how I structure the question pool and the scoring data.

The Trigger: Being Made to Redo Characters They Already Know, Every Time

Most store-bought drill books have kids work through the gojūon — the standard hiragana chart — in order. Characters they can already write show up just as often as the ones they can’t.

For a kid, practicing something they’ve already mastered is boring. They’d rather spend more time on the characters that still trip them up, but the drill book’s fixed structure doesn’t allow for that.

So I built a system that records only the characters my child gets wrong, and brings them back for review right around the time they’d otherwise forget.

Splitting the Drill into Several Sections

Each sheet combines a few different kinds of practice.

• Tracing (なぞり書き): A section where the child traces over a faint pre-printed character to practice the physical motion of writing.
• Picture to hiragana (絵→ひらがな): A section where the child looks at a picture and writes the first character of the word it represents, to build the link between sound and character.
• Which one? (にた字どっち): A section for telling apart hiragana that look alike, such as さ (sa) and ち (chi), or ぬ (nu) and ね (ne).
• Write the word (ことばをかこう): A section where the child traces a 2–3 character word over a faint guide, then copies it out again on their own.

I made the number of questions per section adjustable, almost like an environment variable — something like “four tracing questions, two look-alike questions, four write-the-word questions.” Changing a number in a config file is all it takes to change how many questions a section gets. If a section’s count is set to zero, it simply isn’t drawn on the sheet, and the section numbers get renumbered so there’s no gap sitting in the middle of the page.

Turning a Section On or Off Is Just a Matter of Changing a Number in the Pool

The candidate questions for each section live in a dictionary I call the “pool,” defined near the top of the code. Adding a new character or word is just a matter of adding one line to that dictionary.

# Example question pool (keys and words simplified for this post)
POOL_TRACE = {
    "a1": {"char": "あ", "word": "あひる"},
    "a2": {"char": "い", "word": "いぬ"},
    # ...
}
POOL_WORD = {
    "w1": {"word": "くつ", "len": 2},
    "w2": {"word": "さかな", "len": 3},
    # ...
}

As long as each id stays unique, building a day’s worth of questions is just a matter of cross-referencing the pool against the review list. Expanding the range of what’s covered doesn’t require touching the rest of the code either.

The Foundation Underneath It All: The “Forgetting Curve”

At the core of this system is stage-based tracking of the characters my child gets wrong. Every time they answer correctly, the stage goes up, and the interval before that character comes up again gets longer.

Answer correctly and the stage goes up by one; answer incorrectly and it resets to 0. Once a character reaches stage 4, it stops appearing on practice sheets entirely.

I store this state in a simple JSON structure like this:

{
  "あ": {"stage": 2, "due": "2026-09-20"},
  "ぬ": {"stage": 0, "due": "2026-09-13"},
  "ね": {"stage": 4, "due": null}
}

When generating each day’s sheet, I pull out only the characters whose due date — the date they’re next scheduled for review — has already passed, and treat those as “today’s review targets.” Even as the overall pool of characters under review grows, only the ones that actually need reviewing right now ever make it onto the sheet, so it never balloons out of control.

From the command line, I update this state with commands like these:

# Generate today's drill
python3 daily_hiragana_drill.py generate

# Bump the stage for characters answered correctly (lengthens the review interval)
python3 daily_hiragana_drill.py mark-correct あ い

# Reset missed characters to stage 0 (they'll be tested again tomorrow)
python3 daily_hiragana_drill.py mark-miss の は

# List current review targets and graduated characters
python3 daily_hiragana_drill.py srs-status

What I like about this setup is that it automatically picks out exactly the characters that need reviewing on any given day. I never have to sit there thinking, “I guess it’s about time to bring this one back.”

There are things in a household budget that tend to get forgotten too if you leave them alone. Your phone bill might be one of them.

The Scoring Rule: Still Just a Checkbox

Scoring the sheets follows one consistent rule as well: whether an answer is right or wrong comes down to nothing more than whether the checkbox to its left is filled in.

Even if the shape of the character is a little off, I count it correct as long as the checkbox is filled in. A preschooler’s handwriting isn’t stable yet, and I feel that grading too strictly risks making the whole practice something they come to dread.

When I photograph a scored sheet and have AI read it, I crop out just the column of checkboxes and zoom in before letting it make the call. Leave the whole sheet shrunk down, and the filled-in marks can get too small to read clearly.

With multiple sections on one sheet, the same character can sometimes get read as “correct” in one section and “incorrect” in another. When that happens, I let the incorrect result win and apply it just once. My reasoning: it’s safer to be cautious than to let a mistake slip through as if it had already been mastered.

The answer key used to judge right and wrong, by the way, is never shown to my child. I’d rather they try writing it themselves first, instead of copying from an answer sitting in front of them.

What I Do When My Child Starts to Dread a Section

While running this system, there was one more advanced question pattern that my child came to strongly dislike. Forcing them through it risked souring them on the whole practice, not just that one part.

So I set that pattern’s question count to zero and paused it for the time being. The slots that freed up got reassigned to other, easier-to-practice sections. Since the pool and the logic behind it are still sitting there untouched, restarting it later is just a matter of setting the count back to what it was.

I chose to prioritize “not making my child hate practicing” over “sticking to the curriculum I’d decided on.” I think a system like this is meant to be adjusted based on how your child is actually doing — not followed rigidly no matter what.

What’s Actually in the Generated Sheet

Here’s a generalized version of the instructions I give the AI:

Create one hiragana practice sheet for a preschooler.

- Only choose characters and words to test from the provided "review target list"
- Follow the specified number of questions for each section
- Include both a faint traced-over character for tracing practice and a blank space for the child to write on their own
- Set the guide lines larger so it's easier to keep character proportions balanced

The review target list is built automatically from the stage-tracking system described above. The sheet itself is output in a print-ready format, and the answer key for scoring is output as a separate file. That answer key never goes to my child — it’s meant only for whoever is doing the grading.

What I’ve Noticed Along the Way

The biggest change has been how much denser the practice has become. There’s no more time spent writing characters they’ve already mastered over and over, so they can focus purely on the ones giving them trouble.

That said, I’m not trying to force more desk time out of this. If they can practice just the targeted characters in a short session, that’s plenty as far as I’m concerned.

Who This Might Be For

• People who feel that store-bought drill books “just don’t fit” their child
• People who’d like to bring a forgetting-curve-style approach into home learning
• People who don’t mind a bit of light implementation, like managing a question pool in code

Wrap-Up

I built a system that tracks only the characters my child gets wrong through stages, and brings them back for review right around the time they’d forget. The biggest advantage, I think, is being able to generate questions custom-made for this one specific kid — something a store-bought drill book simply can’t do.

When something isn’t working, I adjust the content rather than force it through. Even after you’ve turned something into a system, I think it’s important to keep adjusting it based on how your child is actually responding.

It’s not just drills — this is how I keep revisiting the systems around our house, bit by bit. Monthly fixed costs like your phone bill tend to get left alone in much the same way. It might be worth reviewing the whole setup once in a while.

This article contains affiliate advertising. If you sign up for a product or service through a link on this site, we may receive compensation from the partner company. The site operator is also an employee of Rakuten Group and may receive compensation through an employee referral program. The content and opinions here are based on the operator’s own experience and research regardless of any advertising relationship, but please read with the above in mind. See the Disclaimer & Affiliate Disclosure for details. Disclaimer & Affiliate Disclosure

This article includes machine-translated content. Please check the official Rakuten Mobile multilingual page for exact terms.

If you have concerns about Rakuten Mobile coverage or signal quality, you can consult through the official signal improvement request form .