In short: Élan is a French school I built for myself. It takes a learner from the alphabet to C2 and the TEF and TCF Canada exams, with explanations in English and optional Nepali.
I did not type most of the code. I acted like a tech lead for a team of AI agents. I wrote a detailed spec, broke the work into named phases, had separate agents review the writers, and let nothing through until tests, type checks and lint passed. I approved every level before the next one started.
Élan is not published yet. I use it every day to prepare for my own exam. The screenshots below come from a demo account on my laptop.
What Élan is
Most French apps teach phrases. Few take you all the way to an immigration exam. Élan has a guided path of short lessons, a spaced repetition review, a verb trainer, stories you play through, and full mock exams that give an estimated NCLC score, the scale Canada uses for language results.
- Interactive lessons from A0 to B2. Every lesson follows the same seven teaching rules, such as "guess first" and "explain mistakes right away".
- 325 short stories. You play a character, choose what to say and practise the phrases you need most.
- 10 TEF and TCF mock exams with listening, reading and writing sections, timed like the real test.
- An offline phone app that carries the whole course, including 27,247 audio clips, so it works with no internet.
For engineers: how it is built
An npm workspaces monorepo with four parts:
- Web: React 19, Vite, Tailwind CSS v4, TanStack Query.
- Server: Express 5, Mongoose on a local MongoDB, Zod validation, about 38 feature modules. Sessions with argon2id passwords, CSRF checks, roles and plan entitlements enforced in the data layer.
- Mobile: an offline-first Expo app. The course is compiled at build time into 1,056 JSON files plus a 322 MB audio pack. Progress lives in SQLite and syncs through a shared contract.
- Shared package: Zod schemas, the spaced repetition scheduler, the sync contract, the lesson compilers and the content QA rules, used by both server and mobile.
Lessons are not written by hand screen by screen. Compilers turn structured grammar and vocabulary content into lesson steps, and tests fail the build if any rule, exception, example or common mistake is left out.
Screens
Captured from the web app with a demo account. Select a screen to open it full size.
Decision 1: write the spec before any code
An agent does exactly what you ask, quickly, including the wrong thing. So the first piece of work was mine: a 5,021-word spec in 71 sections. It described the learner, the content model, every feature, and the order to build them in.
Two parts mattered most. A list of non-goals, such as "do not build pages that are giant walls of text" and "do not build an AI parser". And a product decision rule: when choosing between more features and a simpler, clearer experience, choose the simpler one unless the feature directly helps learning.
Agents make hundreds of small choices that nobody reviews one by one. A written rule lets each agent make the same choice I would have made, without asking me.
Before writing code, I asked the first agent to read the whole spec and list where it contradicted itself. It found 11 conflicts. For example, one section listed five lesson statuses and another listed seven. Each conflict and its resolution went into the architecture document, so later agents built on settled answers instead of guessing.
Decision 2: split the work so agents could run in parallel
One agent working for weeks loses track. Many agents working at once collide. I broke the project into named phases, each with its own plan document, and only ran work in parallel when the pieces did not touch the same files.
| Phases | What they built |
|---|---|
| Auth and security | Accounts, sessions, roles, plans, a security review |
| P1 to P9 | The interactive lesson engine and lessons from A0 to B2 |
| R1 to R6 | The offline phone app, from content bundle to backups |
| T0 to T2 | The story format, the QA rules and 325 stories |
Before big phases I used plan mode, so an agent proposed the approach and I approved it before anything changed. Eight research documents, written by agents and read by me, covered the content we already had, learning science and the market.
Over the whole build I ran 195 sub-agents. Most were fresh agents given a short, self-contained brief. Some were forks that kept the conversation so far. Writers of stories and lessons worked from one shared brief, so many writers produced work in one consistent voice and format.
The agent loop
Every phase went through the same loop. Step through it, or press play.
- Agents
- 195
- Tool calls
- ~12,200
- Tests
- 1,100+
- Stories
- 325
- Mock exams
- 10
Spec, plan, parallel builders and writers, reviewers, automated checks, a checkpoint, then my approval and a commit. A token limit sends work back to the same agent with its progress intact.
Decision 3: ask for proof
An agent will say "done" with confidence when it is not done. I treated that like any status update from a new team member: I asked for proof. No agent could report a step as finished until four checks passed: the test suite, the type checker, the linter, and the content QA rules.
The QA rules were the key idea. Teaching quality is hard to check by eye across hundreds of lessons, so I turned it into code. The seven teaching rules became tests: every rule, exception, example and common mistake must be shown and then practised; a section has at most four new rules and takes three to seven minutes; the right answer is never always in the same position. Stories had their own rules, such as "never more than two lines without an interaction". If a writer agent broke one, the build failed and the agent had to fix it.
Checks catch broken code. They cannot tell whether the French sounds natural or a screen is confusing. So writer output went to separate reviewer agents that had not written it, much like a second person reading a draft. I also had one agent do a security review, which found 19 issues, all fixed with tests, and another walk through the app as a learner persona and report every confusing moment with screenshots.
Surviving token limits and laptop shutdowns
A long build with agents stops often. The session runs out of tokens, or I close the laptop. The risk is that a new session starts from zero and redoes or breaks finished work. I designed for that from the start:
- A "RESUME HERE" progress log. One file said what was done, what was in progress and the exact next step. Every agent updated it after each step.
- Per-agent checkpoint logs. Each writer appended one line per finished story. On resume it read its log and continued after the last finished item.
- A shared writer brief. New or resumed writers read the same rules, so the style did not drift.
- Resume instead of restart. I resumed existing agents 96 times, so they kept their context instead of starting over.
Forks inherit the whole conversation, which made them slow and expensive once the context was large. I wrote a rule into the progress log: use fresh agents with self-contained briefs, at most about three at once, and resume them one at a time after a stop.
Where I stayed in charge
The agents did the volume. The decisions stayed with me.
- One level at a time. Content went level by level. I tried each level myself and approved it before work on the next one started, for example A2 before B1.
- Direction changes. When the text lessons felt boring, I changed direction to interactive lessons and prototyped them in a staff-only Labs area first. When I needed the course on my phone without internet, I moved the mobile plan to an offline app.
- A decisions log. Settled choices went into a "don't re-litigate" list, so a new agent could not reopen them.
- Commits. I reviewed and committed the work myself. Every agent brief said: do not commit.
The tools I leaned on were plain ones: plan mode, resuming agents, a browser automation skill to look at real pages, a charting skill, and the Claude API reference. There were no custom skills or hooks. The structure came from the spec, the logs and the tests.
Results
In five weeks, with 17 days of active work, about 205 prompts from me and about 12,200 tool calls by agents, Élan went from a spec to a web app, an API and an offline phone app. My part was the engineering lead's job: a clear spec, work cut into pieces that fit, quality made measurable, and the important calls kept for myself.
What I would do next
Finish the C1 and C2 content, run the mobile app through a real exam season on my own phone, and then decide whether to publish. If I publish, payments need a provider that supports a business in Nepal, which is already on the list.

