Dopa Drill: How Claude Opus 5.5 Turned a Math Worksheet Into a Dopamine-Style Game

Key Takeaways

• Dopa Drill (ドパドリル) is a browser-based arithmetic game created as an experiment with Claude Opus 5.5.
• The creator described it as close to a joke app made to test the model, but said the project unexpectedly attracted interest from people in education.
• The public project includes 58 arithmetic skills across Japanese elementary grades 1–6, adaptive placement, mastery tracking, review, trophies, collections, daily quests, combos, and an Extra mode.
• The game's Dopa value is an exaggerated game-effect variable, not a medical measurement of dopamine.
• Progress is stored locally in the browser, with no account required by the current implementation.
• The code is MIT-licensed, but the Dopa Drill name, logo, and Dopakichi mascot are excluded from the MIT grant, which matters for commercial forks.
• The repository is also a useful Claude Opus 5.5 coding case study because it includes a detailed behavioral specification rather than only source code.

Dopa Drill started with a deliberately absurd premise: what if a normal children's arithmetic worksheet behaved like a high-feedback arcade game?

The original viral post showed a math drill where correct answers trigger increasingly intense effects, the displayed Dopa value rises rapidly, and a successful basic round can unlock an even more chaotic Extra mode.

The creator later explained that the project was originally close to a joke app built to test Claude Opus 5.5. The unexpected part was the response: people connected to education began asking about it, and the source code was released so others could experiment with the concept.

That makes Dopa Drill relevant beyond the meme. It is simultaneously an educational-game experiment, a lightweight browser-game architecture, and a public example of how AI coding agents can implement a fairly detailed product specification.

Play Dopa Drill in Your Browser

The public build can be opened directly in a modern browser:

https://dopa-drill.tanosix.com/

A publisher can also try embedding the public game inside an article:

<iframe
  src="https://dopa-drill.tanosix.com/"
  title="Dopa Drill browser math game"
  loading="lazy"
  style="width:100%;min-height:760px;border:0;border-radius:16px;"
  allow="autoplay; fullscreen"
></iframe>

Whether the iframe works in production depends on the destination CMS, browser security rules, and the response headers used by the hosted game. If framing is blocked, use a normal play link or self-host a permitted fork instead.

What Is Dopa Drill?

Dopa Drill is an arithmetic-practice game built around escalating audiovisual feedback.

Its basic loop is straightforward:

• Answer a calculation.
• Receive immediate feedback.
• Build a combo by continuing to answer correctly.
• Watch the mascot, background, particles, music, and celebration effects intensify.
• Complete the normal round.
• If performance is high enough, enter the Extra challenge.

The important design decision is that a wrong answer does not immediately end the session. Instead, the game can offer another attempt and increasingly explicit help while preserving most of the player's visible progress.

This creates a very different emotional loop from a conventional worksheet. A mistake becomes a temporary interruption rather than a hard failure state.

58 Skills Across Grades 1–6

The public specification defines 58 arithmetic skills across six elementary grade levels.

The content includes areas such as:

• addition and subtraction;
• multiplication and division;
• written arithmetic;
• decimals;
• fractions;
• rounding;
• factors and multiples;
• order of operations;
• percentages;
• ratios;
• evaluating numerical expressions involving variables.

The current project is not a complete mathematics curriculum. It focuses heavily on calculation practice and does not attempt to replace lessons involving geometry, measurement, graphs, or broader word-problem reasoning.

That distinction matters. Dopa Drill is best described as a gamified arithmetic practice system, not a full elementary mathematics course.

How the Adaptive Learning System Works

The project includes more than fixed grade buttons.

A self-level mode can place players into suitable skills and then mix mastered material with unlocked material that still needs practice.

The system also tracks errors for review. Questions that caused mistakes can reappear later, and a successful first-attempt answer can remove them from the review queue.

Mastery is based on recent performance rather than a single lucky answer. The specification uses a rolling history requirement so that players need multiple successful attempts before a skill is considered mastered.

There is also a long-term refresh mechanic. Previously mastered skills can be marked as needing another pass after enough time has elapsed.

These mechanics create a lightweight learning loop built around four ideas:

1. placement;
2. practice;
3. mastery;
4. review.

That underlying structure is arguably more important than the visual effects.

Dopa Is a Game Number, Not a Dopamine Measurement

The word Dopa makes the project memorable, but it can also create confusion.

The application is not measuring dopamine, estimating neurotransmitter release, or providing a medical signal.

Dopa is an intentionally exaggerated in-game number used for spectacle.

The public specification separates the normal performance score from the Dopa display. This is a smart design decision because the conventional score can remain understandable while the reward number is free to become absurdly large.

The documented progression uses nonlinear curves so the feedback can accelerate dramatically as the session continues.

For example, the specification describes curves such as:

Basic:
B(f) = 2.3 × clamp(f, 0, 1)^1.15

Extra:
X(n) = 2.3 + 3.0 × (1 − exp(−n / 10))

Extra-mode scoring is handled separately:

Score = 100 + 10 × n + 5 × n × (n − 1) ÷ 2

The key product lesson is the separation between performance and spectacle.

A serious learning system should not distort its useful metrics just to make the screen more exciting.

Why the Game Feels More Intense Over Time

Dopa Drill's visual escalation is systematic rather than completely random.

The public specification defines intensity curves for the normal round and additional tiers for Extra mode.

As intensity rises, the game can add or strengthen elements such as:

• changing backgrounds;
• larger correct-answer effects;
• particles;
• confetti;
• stars;
• flowers;
• fireworks;
• coins;
• crowds;
• lights;
• screen movement;
• increasingly dramatic finale effects.

Audio escalates too.

The project synthesizes sound through the Web Audio API instead of depending entirely on prerecorded music files. Tempo and arrangement can rise with the current effect tier.

This is one reason Dopa Drill feels more like a game than a worksheet with badges attached afterward. The reward layer changes continuously during the task.

Why the Learning Design Is More Thoughtful Than the Meme

The public presentation emphasizes chaos, but several implementation choices are relatively restrained.

Mistakes do not erase everything

A wrong answer can break a combo, but the player does not lose all accumulated progress.

Review is tied to errors

Mistakes are useful signals. They can cause questions to reappear in later review instead of simply lowering a score.

Mastery requires repeated success

The system does not treat one correct answer as proof that a skill is mastered.

Rewards are progression-based

The experience focuses on achievement conditions rather than paid random rewards.

Motion can be reduced

The application includes motion controls, and the specification takes the user's reduced-motion preference into account.

These choices matter because high-feedback game design can easily become unusable when visual stimulation is treated as the only goal.

Does Gamification Automatically Improve Learning?

No.

Dopa Drill is an interesting educational experiment, but its public materials should not be interpreted as proof that more particles, higher numbers, or more intense sound automatically produce better learning outcomes.

Gamification research is mixed and highly dependent on implementation, population, subject matter, and what is being measured.

A player doing more questions can be a useful engagement signal, but engagement is not the same thing as long-term retention.

A stronger evaluation of a Dopa Drill-style system would measure:

• first-attempt accuracy;
• error reduction over time;
• delayed retention;
• transfer to unassisted worksheets;
• session completion;
• voluntary return rate;
• whether visual intensity helps or distracts different learners.

That is the gap between an entertaining prototype and a validated educational product.

Privacy: A Local-First Model

One of the more practical aspects of Dopa Drill is its simple data model.

The current specification stores progress in browser localStorage.

That means the basic project does not require:

• a child account;
• cloud authentication;
• public rankings;
• cross-device synchronization;
• an advertising identity;
• a large backend database.

This architecture dramatically reduces complexity.

The tradeoff is that browser-local progress can disappear if the user clears site data, changes browsers, changes devices, or moves to a different origin.

For a small educational app, this can be a reasonable privacy-versus-convenience compromise.

A fork that adds accounts and cloud synchronization gains convenience but also inherits additional responsibilities around authentication, data security, child privacy, parental consent, and account recovery.

How Dopa Drill Is Built

The project is intentionally lightweight.

The repository describes a browser application based on dependency-free ES Modules with no conventional application build step required for the core experience.

Major parts of the codebase are separated into modules for:

• problem generation;
• skill definitions;
• session planning;
• mastery;
• scoring;
• Dopa calculations;
• combos;
• quests;
• trophies;
• unlockables;
• local persistence;
• mascot rendering;
• Canvas effects;
• WebGL backgrounds;
• Web Audio synthesis.

This separation is useful for AI-assisted development because individual rules can be changed without forcing the agent to rewrite the entire application.

Why Dopa Drill Is an Interesting Claude Opus 5.5 Case Study

The strongest AI-development lesson is not simply that Claude generated code.

The repository includes a detailed specification describing product behavior, formulas, modes, progression, accessibility, persistence, tests, and debug behavior.

That creates a far better environment for a coding agent than a vague prompt such as:

Make a fun math game for children.

A specification can instead define things like:

• what unlocks Extra mode;
• how mastery is calculated;
• what happens after a wrong answer;
• how visual intensity progresses;
• what data is stored;
• what must never be stored;
• how reduced motion behaves;
• what tests must continue passing.

This is closer to AI-assisted product engineering than one-shot vibe coding.

The broader lesson for developers is simple: the more explicit the behavioral contract, the easier it becomes for an AI agent to extend the product without silently breaking important rules.

Running the Open-Source Version Locally

Because the application uses browser modules, it should be served through HTTP instead of being opened directly with file://.

A simple local server is enough:

python3 -m http.server 8000 --bind 0.0.0.0

Then open the relevant application path in the browser.

The repository also includes automated tests that can be run with a modern Node.js installation:

node --test tests/*.test.mjs

The project exposes debug and testing parameters as well, which is useful when validating deterministic scenarios or asking an AI coding agent to reproduce a bug.

Open Source Does Not Mean the Brand Is Free to Use

This is the biggest licensing detail to understand before creating a fork.

The software source is released under the MIT License, but the repository's license terms separately exclude the original branding assets.

The Dopa Drill name, logo, and Dopakichi mascot are not granted under the normal MIT software license.

For a commercial derivative, a safer approach is:

• reuse only code that is actually covered by the software license;
• preserve the required MIT notices;
• create a new product name;
• create an original mascot;
• create an original logo;
• avoid implying that a fork is the official Dopa Drill;
• request permission if commercial use of the original brand is necessary.

This is a common open-source pitfall: code licensing and trademark or character rights are not the same thing.

Why the Concept Is Easy to Adapt

The underlying pattern is not limited to arithmetic.

A Dopa Drill-style reward shell could be applied to short tasks with objectively checkable answers, including:

• vocabulary recall;
• spelling;
• kanji practice;
• multiplication tables;
• geography;
• country flags;
• music theory;
• language conjugation;
• coding syntax;
• exam review;
• flashcards.

The key is to keep the educational model separate from the visual escalation system.

A useful fork architecture would contain:

1. a skill graph;
2. problem generators;
3. answer validators;
4. mastery rules;
5. review scheduling;
6. a conventional score;
7. a separate spectacle or excitement variable;
8. audiovisual tiers;
9. accessibility controls;
10. deterministic testing tools.

That structure makes the concept reusable without copying the original brand.

Common Pitfalls When Copying the Formula

1. Treating dopamine as a product metric

Do not imply that an animation system can measure dopamine or directly quantify a user's neurological state.

2. Maximizing stimulation without accessibility controls

Heavy movement, flashing, particles, and audio can become distracting. Reduced-motion, volume, mute, and effect-strength controls should be core features.

3. Confusing engagement with learning

More playtime is not automatically better learning. Track retention and error reduction, not only session length.

4. Copying protected branding

MIT-licensed code does not automatically grant rights to every name, mascot, logo, or other brand asset in the repository.

5. Adding cloud sync without considering privacy

Moving from local storage to accounts changes the compliance and security profile of the product.

6. Assuming iframe embedding will always work

A public URL can be placed in iframe markup, but production embedding still depends on framing headers, browser policy, and the CMS. Self-hosting a permitted fork gives developers more control.

What Developers Can Learn From Dopa Drill

Dopa Drill demonstrates several useful patterns for small AI-built products:

• Use AI to implement a specification, not replace one.
• Separate core metrics from entertainment metrics.
• Keep the architecture simple enough to understand.
• Create deterministic tests before repeatedly asking agents to modify the product.
• Use browser-native APIs when they remove unnecessary dependencies.
• Design failure behavior as carefully as success behavior.
• Treat accessibility and privacy as product architecture, not launch-day polish.

These patterns apply far beyond educational games.

Conclusion

Dopa Drill looks like a joke about turning homework into a dopamine machine, but the public project is considerably more sophisticated than the premise suggests.

It combines 58 arithmetic skills, adaptive placement, mastery tracking, review, escalating audiovisual effects, local-first persistence, accessibility controls, tests, and a detailed product specification inside a lightweight browser application.

Its most important lesson is not that learning software needs more confetti.

The stronger idea is that boring but useful repetition can be redesigned around immediate feedback, visible progression, forgiving failure states, and clearly specified rules.

For AI developers, Dopa Drill is also a useful Claude Opus 5.5 case study: detailed requirements give coding agents something concrete to reason about, test, and preserve.

For indie developers, the best opportunity is not to clone Dopa Drill exactly. It is to identify another repetitive task with objective answers, build a stronger mastery loop around it, and create an original reward system and brand on top.