A lesson on writing a Python loop should have you write and run a loop. A lesson on Spanish vocabulary should have you match words to meanings fast enough that the pairing sticks. A lesson on the causes of a strike or a war should have you explain it in your own sentences. Running all three through the same four-option quiz would test the wrong thing in at least two of them, so TopicLearn doesn't do that. It picks the exercise format per topic instead.
A quiz question and a working loop test different skills
Multiple choice is good at one thing: checking whether you can recognize a correct answer when it's sitting next to three wrong ones. That's a real skill, and it matters for recall. But it's a poor stand-in for whether you can produce something from nothing, which is what coding, writing, and most real-world tasks demand. Someone can pick the right answer about a for loop's syntax and still freeze when the editor is blank and the loop won't run. The gap between recognizing and producing is exactly why a single exercise format can't cover every subject.
Different jobs, different formats
- Code runner: you type real code and run it. Syntax errors and logic bugs show up immediately, the same way they would outside a lesson.
- Drag & match: you pair terms with definitions or translations under light time pressure. Built for subjects that are dense with vocabulary, like a new language or the naming conventions in a new field.
- Recall checks: you retrieve a fact, term, or concept from memory with nothing in front of you to recognize from. This is the format closest to how you'll actually need the knowledge later.
- Written reflection: you explain a concept, argument, or decision in your own words. Fits skills without one correct output, like negotiation, historical analysis, or giving feedback.
- Video examples: you watch a worked demonstration before you're expected to do the thing yourself. Useful when seeing the process matters more than attempting it cold.
How the format gets chosen
When you type a topic into TopicLearn, the course that comes back in under a minute isn't a generic template with your topic's name swapped in. It's built around what that specific subject calls for: goals, drills, and memory checks shaped by the material. A course on Python for beginners leans heavily on the code runner, because the whole point is writing code that runs. A course on conversational Spanish leans on drag-match and recall checks, because the bottleneck there is vocabulary retrieval under time pressure, not producing original sentences from scratch on day one. A course on negotiation tactics leans on written reflection, because there's no single correct line to memorize, only a decision to explain and defend.
One course, more than one format
This isn't a choice made once for a whole course either. Someone learning data science might get code runner exercises for the parts about writing queries, recall checks for statistical definitions, and written reflection for interpreting what a result means. Each lesson uses the format that fits what it's teaching, not whatever format the previous lesson happened to use.
Why the match matters
Practicing in the wrong format wastes the rep. If you only ever answer multiple-choice questions about code, you get good at recognizing correct syntax on a page, which isn't the same skill as writing it under a blinking cursor with no options in front of you. Matching the exercise to the subject means the practice you're doing during the lesson resembles the thing you'll need to do afterward, whether that's running a script, holding a conversation, or making a case for a decision.