Suyog Acharya
Case study · Élan · Led by me, built with AI agents

A French school built by me and 195 AI agents

I wanted one place to learn French from zero to the TEF and TCF Canada exams. I wrote the spec, split the work into phases, made every change pass tests, and approved each level myself. AI agents wrote most of the code and content.

Role
Product owner and engineering lead
Built with
Claude Code agents
Stack
React, Express, MongoDB, Expo
Time
5 weeks (Sep 25 – Nov 1, 2026), 17 days of active work
Status
Not published yet

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.

Élan Today page for a demo learner: a short guide to the app, the next journey lesson on the French alphabet, and the story of the day.
Today. One page that says what to do next.
Le Trajet, the journey map at level A0: a winding path of short lesson stops starting with the alphabet, with a review stop after four lessons.
The journey. Short stops, a review every few stops, a checkpoint per phase.
TEF Canada mock exam, listening section in exam mode: question 1 of 40, a recording that plays once, four answer choices and a running 40-minute timer.
Mock exam. Timed like the real TEF, recordings play once.
Verb conjugator showing aller: it takes être, the past participle is allé, and tables for présent, passé composé, futur proche and impératif with audio buttons.
Verb lookup. Every tense, with audio and the auxiliary.
Verb Master: a progress counter out of 342 verbs, game modes such as Smart Review, Hard words and Speed round, and the verbs grouped into sets of 15.
Verb Master. Learn 15 verbs at a time, then review them when due.
Stories library with 325 stories filtered by level from A0 to B2, showing cards for everyday scenes such as a first class, a bus stop and a café.
Stories. Four-minute scenes from everyday life.
Interactive lesson on a phone: a warm-up question asks how Priya says the letter I in French, and after the guess the answer is explained.
Lesson on a phone. Guess first, then the rule.
The story La monnaie de Réjean on a phone: the scene set-up, the two characters, and a question asking what you would say in the evening, with the answer Bonsoir explained.
Story on a phone. You choose what your character says.

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.

Why it matters

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.

PhasesWhat they built
Auth and securityAccounts, sessions, roles, plans, a security review
P1 to P9The interactive lesson engine and lessons from A0 to B2
R1 to R6The offline phone app, from content bundle to backups
T0 to T2The 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
The agent loop Spec, then plan, then parallel builder and writer agents, then reviewer agents, then automated checks, then a checkpoint. A token limit loops back to resume the same agents. After the checkpoint comes my approval, then the commit, then the next phase starts from the plan. token limit or laptop shut: resume the same agent ↺ next phase a check fails: back to the agent Spec71 sections, my rules Planplan mode, I approve Builderscode, in parallel Writerslessons, stories Reviewersfresh eyes per batch Verifytests ✓ types ✓lint ✓ QA rules ✓ CheckpointRESUME HERE log My approvalone level at a time CommitI commit myself
The whole loop

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.

The counters build up to the real totals for the whole build as you step through. The values in between are only illustrative. Agents and tool calls come from the session logs; tests, stories and mock exams are what the code base contains now.

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.

831test runs across agents
711type check runs
486lint runs
~20separate reviewer agents

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.
Lesson learned

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

A0 to B2interactive lessons, all following the same seven rules
325 + 10stories and TEF/TCF mock exams
1,100+automated tests guarding code and content

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.