Wondika AI Math Adventures

The product bet

Most math products for children wrap a standard quiz in cartoons. Wondika took the opposite approach: math drove the plot. Building a bridge required calculating its length, and starting a party meant dividing supplies equally. A wrong answer changed the immediate story consequence, but it never stopped progress.

The product was built for children aged six to eleven, especially those disengaged from math. The main challenge was making each adventure feel personal without allowing a probabilistic model to choose learning goals or evaluate answers.

Personal before the prompt

Personalization started in product state rather than in a prompt sent to a model. A Bayesian Knowledge Tracing model tracked skill mastery. The learning engine selected the next eligible skill, flagged review or struggle, and picked a fresh scenario. The child then selected a character and a world.

These choices formed a deterministic scene plan. Grade level set story length. Mastery set challenge difficulty, which shifted down if the child struggled. Locale, reading level, character personality, world rules, scenario variables, and exact challenge inputs were all set before generation started. When the LLM was called, the educational structure was already fixed.

A deterministic spine

The LLM never evaluated the math. Challenges kept their variables, correct answers, plausible mistakes, and difficulty independent of the narrative. Application code validated the arithmetic and updated mastery after every answer. The model turned that fixed problem into a vivid situation inside the plot.

The prompt contract prevented the narrative from revealing solutions. It could include operands, but never the correct answer or any option value. Structured output, placeholder checks, scene-count validation, answer-concealment rules, and readability checks rejected any episode that violated the contract. Creativity stayed grounded in facts the system had already verified.

One generation pipeline

A single call produced the narrative arc and scene instructions as typed output, after which image and narration work ran in parallel. Character consistency came from reference images or LoRAs instead of repetitive text descriptions. Image prompts excluded challenge numbers so visual assets remained reusable across different math values.

The pipeline parsed the first complete scene from the model stream and sent it to image and speech services before the rest of the episode finished generating. This allowed the child to start the opening scene while later scenes were still processing, turning perceived latency into a pipeline problem rather than a model benchmark.

Reuse before generation

Generating fresh content was the fallback path rather than the default. The orchestrator first checked for a completed adventure suitable for the free tier, then looked for an unseen story template matching the target skill, world, scenario, grade, and locale. The system generated a new episode only when no match existed.

Reusable templates preserved the narrative structure while substituting character identity and challenge state. Media was hydrated again only when needed. This separated personalized elements from reusable assets, while every newly generated story expanded the pool for the next child.

Safe enough to ship

Building for children required validation beyond simple JSON parsing. Child-controlled input was isolated from system instructions, and schemas constrained model output. Programmatic checks verified math, placeholders, scene structure, and reading levels. A separate evaluation step scored narrative coherence, age appropriateness, engagement, pedagogical correctness, and image relevance.

Generation also had operational failure modes. Model calls used retry and fallback policies, media could degrade without killing the story, AI cost was tracked per adventure, and failed quota reservations could be refunded. The system was built to surface a usable result or a known failure, rather than leave a child inside a half-generated session.

What shipped

I built the React Native app, Bun and Hono API, MongoDB data model, Next.js web and admin interfaces, subscriptions, analytics, observability, content tooling, and release automation. Wondika launched on the App Store in May 2026 and received a 1.0.1 update one week later.

The service has since been shut down. I include this case because building it exposed the core technical work behind an AI product: defining model boundaries, evaluating output, hiding latency across several media systems, and recovering from generation failures. The archived App Store listing remains a record of the product that reached production.