Case Study: Nihongo

I was planning a trip to Japan. The usual preparation: flights, hotels, a spreadsheet of restaurants that will probably never survive contact with reality. But the language piece nagged me. I wanted to learn enough Japanese to navigate a train station, order ramen, read basic signage, and not feel completely helpless. The kind of practical, real-world fluency that makes a trip feel different.

So I tried the obvious apps. Duolingo. Memrise. A handful of others. They all had the same problem. They were games pretending to be learning tools. Streaks, gems, leaderboards, cartoon owls guilt-tripping you about missed sessions. Beautifully designed, aggressively gamified, and not particularly good at preparing you for an actual conversation in an actual ramen shop in Shinjuku.

I wanted something different. Something focused. Something built for a specific person (an adult preparing for a real trip) solving a specific problem (learning practical Japanese, not collecting virtual currency). So I built it.

The positioning decision

Before writing a single line of code, I made the most important decision of the entire project: Nihongo is a tool, not a game.

Duolingo is brilliant at what it does. It turns language learning into a dopamine loop. But optimising for daily engagement and optimising for actual learning are not the same thing. Nihongo doesn't have streaks that punish you for missing a day. It doesn't have a mascot. It doesn't send passive-aggressive push notifications. It has 192 items across four levels, a spaced repetition system that surfaces what you're about to forget, and interactive dialogues that simulate real situations you'll encounter in Japan.

That positioning decision shaped everything that followed. The design is clean and typographic, using Noto Sans JP and Noto Serif JP. The colour palette is built around Japanese flag red. The interactions are purposeful. Every feature exists because it helps you learn, not because it increases time-on-app.

What's inside

What started as a simple flashcard app grew into something significantly more ambitious. The final product is over 10,000 lines across seven JavaScript files, a CSS file, and an HTML shell. It includes:

Four levels, 192 items. Hiragana (46 characters), Katakana (46 characters), Essential Vocabulary (50 words), and Restaurant Japanese (50+ phrases). The levels progress from reading to practical application. By level four, you're ordering food, asking for the bill, and navigating a convenience store.

Five study modes. Flashcard study for learning new items. Multiple-choice quizzes for testing recall. Speed rounds (60-second challenges). Daily challenges for consistent practice. And interactive dialogue scenarios for real-world application. Each mode tests a different type of knowledge, from recognition to production to contextual use.

Handwriting practice. A canvas-based drawing surface where you practise writing characters by hand. You draw the character, compare it to the reference, and self-assess. This was the most technically challenging feature to build, and the one I'm proudest of. Writing a character from memory is fundamentally different from recognising it in a list. The muscle memory matters.

Interactive dialogue scenarios. Four complete branching conversations: ordering at a ramen shop, navigating an izakaya evening, buying from a convenience store, and taking a taxi. Each scenario has six to seven exchanges with cultural context tips. When the ramen shop dialogue explains that you order from a ticket machine before sitting down, or that slurping noodles is encouraged, that's the kind of practical knowledge no flashcard can teach.

Spaced repetition (SM-2 algorithm). Items move through four states: New, Learning, Familiar, and Mastered. Get an item right and the interval before you see it again doubles. Get it wrong and it resets. The system surfaces what you're about to forget, which means you study less and remember more. It's the same algorithm used by Anki, the gold standard of spaced repetition software.

12 achievement badges. From "First Steps" (complete any session) to "Completionist" (master all 192 items). There's a "Foodie" badge for mastering all restaurant phrases, a "Speed Demon" badge for scoring 15+ in a speed round, and an "On Fire" badge for maintaining a 7-day study streak. The badges reward genuine learning milestones, not just showing up.

The technical challenge

I want to be clear about something: I cannot write code. I'm a strategy director who spent fifteen years in advertising. Everything in Nihongo was built with Claude Code, and the process taught me something important about what "building" actually means when AI does the implementation.

The handwriting practice feature is the best example. Writing Japanese characters correctly requires specific stroke order. The strokes.js file contains reference data for how each character should be drawn. The canvas captures your input, and the writing.js module handles the drawing surface, stroke capture, and visual feedback. Getting this to work smoothly on both desktop and mobile, with touch events and mouse events, with the right level of line smoothing and canvas sizing, took dozens of iterations.

I couldn't have written any of it myself. But I could describe exactly what I wanted: "a drawing canvas where you practise writing hiragana characters, with a faded reference character behind your strokes, and a self-assessment step after each attempt." The product thinking was mine. The implementation was Claude Code's. The quality bar was mine again.

The dialogue system was similar. I knew exactly what a ramen shop ordering experience should feel like because I'd researched it obsessively. The branching conversation tree, the cultural context tips, the four-option multiple choice with specific feedback for each wrong answer: those are editorial and product decisions dressed up as code.

Works offline

Nihongo is a Progressive Web App with a service worker that caches everything locally. The entire app works without an internet connection. This was a deliberate choice, not a technical flex. If you're using this app to prepare for Japan, the most useful moment is when you're actually in Japan, probably underground on the Tokyo Metro with no signal, trying to remember the character for "exit."

The PWA architecture also means you can install it to your home screen on any device. No app store, no downloads, no updates to manage. Open the URL, add to home screen, and it's there whenever you need it.

The gap between tools and experiences

Most language learning apps optimise for retention metrics. Time spent in app. Sessions per week. Streak length. Those are engagement numbers, not learning outcomes. Nihongo optimises for something different: confidence.

When you can draw a hiragana character from memory on a blank canvas, you know it in a way that recognising it in a multiple-choice list can never match. When you've navigated a simulated ramen shop conversation, choosing the right phrase at each step, learning why slurping is encouraged and that you say "gochisousama deshita" when leaving, you walk into a real ramen shop with a completely different feeling. When the spaced repetition system tells you an item is "mastered," it means you've recalled it correctly at increasing intervals over time, not just that you got it right once.

That's the gap between a learning tool and a learning experience. The tool gives you information. The experience gives you readiness.

Duolingo is a game about language. Nihongo is a tool for confidence. The positioning decision is the product.

What it taught me

Building Nihongo confirmed something I've been circling for a while. The barrier to making software is no longer code. It's knowing what to build and why.

A year ago, building a Japanese learning app with handwriting recognition, spaced repetition, interactive dialogue trees, offline support, and 12 achievement badges would have required a team: a front-end engineer, a UX designer, probably a Japanese language consultant. It would have taken months. It would have cost tens of thousands.

I built it with Claude Code, a clear product vision, and an unreasonable amount of research into how ramen shops actually work. The product decisions (positioning it as a trip-prep tool, not a gamified engagement machine; building dialogue scenarios around real cultural situations; implementing SRS instead of simpler quiz mechanics) are strategy decisions. The same skills I've been using for fifteen years in advertising, applied to a completely different output.

The question used to be "can you build it?" Now it's "should you build it, and for whom, and why?" Those are taste questions. Strategy questions. The kind of questions that no amount of technical skill can answer.

Nihongo exists because I wanted to learn Japanese properly before a trip. It works because I spent more time thinking about the learning experience than the code. And it proves something worth saying: a non-coder with a clear vision and the right AI tools can build something that genuinely helps people learn. That's not a future prediction. It's already live.

Try Nihongo Master Japanese, beautifully Open App