Exercism gives you puzzles. zuzu.codes gives you a curriculum.
I've been trying Exercism for two months. I open an exercise, read the problem, and just stare at it. Is that normal?
Very common, and it says nothing bad about you. Exercism is designed around discovery learning — the idea that you grow by wrestling with problems independently. That works well when you already have the tools. If you haven't been taught what to reach for yet, staring is the only possible response. There's nothing to discover when the tools themselves are unknown.
So it's not a beginner platform despite how it's marketed?
Not really. Exercism is excellent as a practice platform once you know Python reasonably well. But it assumes you arrive with enough knowledge to at least attempt the problem. zuzu assumes you arrive with zero. The gap shows up immediately: if you open Exercism's "Two Fer" exercise and don't know what a default parameter is, you can't solve it. If you open zuzu's lesson on default parameters, you learn what they are through dialogue and then face a challenge using them. Concept before test, not after.
How does zuzu teach differently, in practice?
Every lesson starts with a dialogue — a student character asks the question you'd probably ask, the teacher explains with embedded code examples, then you face the challenge. The lesson teaches, then tests. Exercism just tests. For someone who knows the language, that's fine — the solving is the learning. For someone who doesn't, the blank problem statement is a wall.
Exercism has real human mentors who review your code. That sounds genuinely valuable — something automated platforms can't replicate.
It is genuinely valuable, and it's one of Exercism's real strengths that I won't minimise. Automated tests tell you whether your output is correct. A human mentor tells you why your working solution has code quality issues — "your solution works but this could be two lines with a comprehension," "you're checking the same condition twice," "this function is doing three things, not one." That code quality signal is something zuzu's automated tests can't provide. That's an honest gap.
Is there a smart way to use both instead of choosing?
There's a natural sequence. Do the free Python Fundamentals track on zuzu — 30 days, one lesson per day. When you finish, Exercism's exercises will feel completely different. Instead of staring at a blank, you'll have actual tools to reach for. Exercism becomes significantly more useful once the foundation exists — and the mentor feedback becomes more valuable when you have working solutions to be critiqued, rather than nothing to submit at all.
Learn with zuzu, then practice and get reviewed on Exercism. That actually makes sense as a sequence.
Exactly. They're not competitors if you use them that way. You get guided learning from zuzu and code quality feedback from Exercism's mentors after you have working solutions. Two stages of the same journey, not two alternatives.
Exercism is one of the few genuinely thoughtful free resources in the programming education space. It's open source, community-maintained, covers 60+ languages, and has a mentor program where real humans review your code and give you quality feedback. That last feature is rare and valuable, and no honest comparison should downplay it.
zuzu.codes is a different product with a different assumption about what learners need. Understanding the assumptions helps you pick the right one — or use them in the right sequence.
Exercism is built on the premise that the act of wrestling with a problem — even if you fail at first — is where learning happens. This is a legitimate theory of learning called productive struggle or discovery learning. When it works, it works well: the learner builds genuine problem-solving intuition because they've actually had to think, not just follow a template.
The failure condition is when the learner lacks the foundational vocabulary to even form an attempt. You can't productively struggle with a problem that requires understanding what a dictionary is if you've never encountered a dictionary. The struggle becomes unproductive — not challenging, just blocked.
zuzu is built on the opposite premise: that conceptual teaching should precede the challenge. The lesson gives you the vocabulary, then the challenge asks you to use it in a new context. This is lower-risk and more accessible to true beginners, at the cost of some of the exploratory depth that comes from wrestling with problems cold.
Exercism's human mentor program is genuinely unique. Most coding platforms give you automated feedback — tests pass or fail, sometimes with a hint about what failed. A skilled Exercism mentor gives you something different:
collections.Counter would communicate intent more clearly here"None of this is available from automated tests. This kind of code quality feedback is normally something you only get from a senior developer at a job. Exercism democratises it, for free, for any exercise in any of the 60+ supported languages.
The trade-offs: mentor availability depends on volunteers, so wait times vary. Some exercises get rapid feedback; others might wait days. And the quality varies with the mentor — a thoughtful mentor is transformative, a brief mentor is just a stamp of approval.
zuzu has automated test results only. Fast, always available, tells you nothing about the quality of your working solution.
| Dimension | Exercism | zuzu.codes |
|---|---|---|
| Languages | 60+ | Python only |
| Python exercises | ~130 | 30 per track × 12 tracks |
| Sequential curriculum | No | Yes — each lesson builds on the last |
| Teaching content | None (solve and discover) | Dialogue before every challenge |
| Human feedback | Yes — volunteer mentors | No |
| Daily structure | None | One pre-assigned lesson/day |
| Price | Free | Free starter + $14.99/mo |
| Best for | Practicing once you know basics | Learning from zero |
If your goal is polyglot proficiency — comfortable switching between Python, Go, TypeScript, Rust, Elixir, and more — Exercism's breadth is a genuine advantage. It's one of the best places to get comfortable with the idioms of a new language you're learning on the side.
If your goal is Python mastery specifically, Exercism has ~130 Python exercises. zuzu has 360 (12 tracks × 30 lessons), all sequentially structured with conceptual teaching built in at every step.
The debate between discovery learning and direct instruction is old in education research. The current evidence suggests a nuanced picture:
Exercism is closer to discovery with optional mentoring. zuzu is closer to guided instruction followed by unscaffolded practice (no hints, just test results). Neither is a full-spectrum approach.
For someone starting Python from zero, zuzu's guided start is likely faster and less frustrating. For someone who already has the basics and wants to sharpen, Exercism's exercise library plus mentor feedback is likely more valuable.
Exercism has no concept of daily practice. You open it when you're motivated, pick an exercise from the library, and work on it. This works for self-directed, highly motivated learners. It doesn't work for learners who need a pull to return.
zuzu's streak mechanics exist specifically for that second group: the learner who intends to practice daily but finds the blank canvas of "what should I do today" too easy to defer. A 15-day streak is a surprisingly effective psychological lever. The small anxiety of breaking it gets you to open the app on days when nothing else would.
Rather than choosing, most learners benefit from using these platforms in order:
By month 3, you'll open Exercism's "Word Count" or "Robot Name" exercises with actual approaches in mind. The mentor feedback will be more valuable because you'll have working solutions to be critiqued rather than blank submissions. You'll understand what the mentor means when they suggest a list comprehension, because you learned those in the zuzu dialogue that introduced them.
Used in that sequence, both platforms are more valuable than either alone.
Choose Exercism first if:
Choose zuzu first if:
They're not alternatives for most learners. They're a sequence.
| Feature | zuzu.codes | Exercism |
|---|---|---|
| Format | Dialogue lessons + challenges | Code exercises + mentor reviews |
| Structure | 30-day sequential tracks | Exercise library (any order) |
| Price | Free starter + $14.99/mo | 100% free (donations welcome) |
| Teaching | Built-in dialogue lessons | Community mentors review your code |
| Languages | Python + AI | 60+ languages |
| Gamification | XP, streaks, quizzes | Reputation, badges |
| Daily Structure | One lesson/day | No daily structure |
zuzu.codes takes you through a structured 30-day path where each lesson builds on the last. Exercism gives you a collection of exercises you can do in any order. If you need a guided path, zuzu. If you want practice problems, Exercism.
Every zuzu lesson teaches the concept through dialogue before the challenge. Exercism expects you to figure it out, then a community mentor reviews your solution. Different approaches — guided learning vs. discovery learning.
zuzu has 12 Python tracks going from basics to AI agents. Exercism has exercises across 60+ languages. Choose based on whether you want depth or breadth.
You want to practice across many programming languages
You value human mentor code reviews
You prefer solving problems independently (discovery learning)
Budget is your top priority — Exercism is free
Not syntax — just thinking. How would you solve these?
1.You've written `char_frequency` and it works. A colleague asks you to add a `case_sensitive=True` parameter so callers can opt into case-insensitive counting. What's the minimal change to support `char_frequency('AaBb', case_sensitive=False)` returning `{'a': 2, 'b': 2}`?
2.You call `char_frequency('abc')` and want to find the most frequent character. Which expression correctly returns it?
3.An Exercism mentor looks at your `char_frequency` solution and says 'this is correct but Python has a built-in for exactly this pattern.' What are they likely referring to?
Build real Python step by step — runs right here in your browser.
Count Character Frequencies
Write a function called `char_frequency` that takes a string and returns a dictionary where each key is a character and the value is how many times it appears. Include spaces and all characters — do not filter anything out.
# char_frequency("aab")
{
"a": 2,
"b": 1
}Start with the free Python track. No credit card required.