Building Common Mistakes Exercises: A Template System That Scales

Started building english-exercises.org by manually writing each grammar exercise. That worked for about 50 exercises, then I realised the maths didn’t add up.

Each exercise was taking 45-60 minutes. Writing questions, testing them, adding explanations, checking SEO. If I wanted 650 exercises, that’s somewhere between 500-650 hours of work. Not happening.

Needed a way to scale content creation without turning exercises into generic fill-in-the-blank rubbish.

The Problem: Good Exercises Take Time

The hardest part isn’t writing sentences. It’s making sure they’re pedagogically sound. Good grammar exercises need:

Real errors: Distractors that match mistakes students actually make
Clear progression: Questions get harder as you go
Context: Sentences that feel natural, not textbook examples
Self-correction: Explanations that help students understand why, not just what

When you’re manually creating every exercise, you cut corners. Especially on exercise 47 at 11pm. The quality drifts.

The Template System

Built a structured approach that enforces quality whilst cutting creation time to 10-15 minutes per exercise.

How It Works

Templates capture the pattern of an exercise type, then let you fill in the specifics. For common mistakes exercises, the template defines:

1. Grammar Point & Error Patterns

What concept you’re teaching (e.g., Present Perfect vs Past Simple)
Common mistakes students make (using Past Simple when Present Perfect is needed)
Why the mistake happens (time marker confusion)

2. Sentence Structures

Natural contexts where the error occurs
Correct form and common wrong forms
Explanation for each distractor

3. Quality Checks

Does it target a real student error?
Is the context natural and clear?
Can students self-correct from the explanation?

The system won’t let you publish unless all checks pass. Forces consistency.

The Pedagogical Checklist

Every exercise goes through a seven-point check before it ships:

✅ Grammar coverage: Does it test the stated concept clearly? ✅ Difficulty progression: Do questions build from simple to complex? ✅ Error authenticity: Are distractors based on real mistakes? ✅ Context variety: Do sentences cover different situations? ✅ Cultural appropriateness: Works for a global audience? ✅ Answer defensibility: Is there only one correct answer? ✅ Explanation quality: Can students learn from feedback?

This is what prevents the quality drift. When you’re tired or rushing, the checklist catches lazy choices.

Why Common Mistakes Work

Most grammar exercises test whether you know a rule. Common mistakes exercises test whether you can avoid the traps that actual students fall into.

Example: Present Perfect with time markers.

Generic exercise: “I ___ (see) that film.” → Answer: “have seen”

Common mistakes exercise: “I ___ that film yesterday.” Options: “saw” / “have seen” / “see” / “was seeing”

The second one is pedagogically stronger because it forces students to notice the time marker (“yesterday”) and choose Past Simple instead of Present Perfect. That’s the real skill—knowing when not to use Present Perfect.

The template system makes it easy to create these exercises consistently. You define the error pattern once (Present Perfect with definite time markers), then generate sentences that test it.

The Technical Setup

Built this into Next.js 15 with static generation. All exercises live as JSON files, and the template system compiles them at build time.

Exercise metadata looks like this:

{
  "grammarPoint": "present-perfect-vs-past-simple",
  "errorType": "time-marker-confusion",
  "distractors": [
    {
      "form": "have seen",
      "reason": "Students use Present Perfect with definite time markers",
      "explanation": "We can't use Present Perfect with 'yesterday'. Use Past Simple: 'saw'."
    }
  ]
}

The template fills in sentence patterns, generates SEO metadata, and enforces the quality checklist. Everything compiles to static HTML at build, so it’s fast and search engines love it.

Results So Far

Speed: Cut creation time from 45-60 minutes to 10-15 minutes per exercise. That’s a 3-4x improvement.

Quality: Every exercise passes the seven-point checklist. Before templates, about 30% of exercises had missing or incomplete explanations. Now it’s 0%.

Scale: Went from 50 manual exercises to 650+ templated exercises in a few months.

SEO: Templates auto-generate optimised titles and descriptions. “present perfect exercises” and “past simple vs past continuous” both ranking in top 5. 12,000+ monthly visits from organic search.

What I Learnt

Templates Don’t Mean Generic

Worried the template system would make everything feel robotic. Opposite happened. Having a structure forced me to think harder about what makes a good exercise. The constraints improved quality.

Checklists Are Underrated

When you’re creating content at scale, fatigue makes you sloppy. The checklist doesn’t get tired. It catches mistakes I would have shipped.

SEO Automation Compounds

Spent two weeks building automated SEO metadata. That’s saved 100+ hours since. Every exercise gets proper titles, descriptions, and keywords without thinking about it.

Error Patterns Are Reusable

Once you identify a common mistake pattern (like Present Perfect with definite time markers), you can generate dozens of exercises from it. The pedagogical work is in finding the pattern. The template does the rest.

What’s Next

Planning to add AI-assisted template expansion. Workflow would be:

Define the error pattern (e.g., article usage with countable/uncountable nouns)
AI generates 12 sentence patterns that test it
Review, edit, and approve
Publish

Target is 5 minutes per exercise. Hit that and I can reach 1,000+ exercises by end of year.

The template system already works. AI just speeds up the sentence generation part.

Follow the build: X @charliecrowley