Suno

76% of India's Class 3 kids can't read a Class 2 text. Suno levels a child reading in 90 seconds

Comment

Suno — we taught the phone to listen

The phone that listens to children read, so every teacher can teach at the right level.

Inspiration

We didn't start with an idea — we started with a graveyard. Before writing a line of code, we researched why AI-education products die: Chegg lost ~99% of its value when free chatbots ate its business; Byju's collapsed on broken trust; and a PNAS field study of ~1,000 students found that unrestricted chatbot help made students score 17% worse on exams once it was removed — while a guardrailed version erased the harm. The pattern was clear: thin wrappers die, trust wins, and AI without pedagogy actively hurts.

Then we found the number that became this project: ASER 2024 reports that 76% of Class-3 children in rural India cannot read a Class-2 text. The fix has existed for twenty years — Teaching at the Right Level (Pratham/J-PAL), one of the most rigorously validated interventions in education: assess every child orally, group by reading level instead of grade, teach each group at its level, re-assess, regroup. The World Bank's 2025 Nigeria RCT showed AI tutoring in low-resource classrooms can deliver ~2 years of learning in 6 weeks at ~$48/student.

So why doesn't it happen? Because the thermometer is too expensive: levelling one child means listening to them read one-on-one for 8–10 minutes. A teacher facing India's 47:1 senior-secondary pupil–teacher ratio would lose a week of instruction per assessment round. ASER itself needs 25,000+ volunteers to measure a sample of children once a year.

While ~44,000 hackathon participants built tools for students who can already type into a chat box, we built for the 76% who can't read one. The cure was proven; we automated the thermometer.

What it does

A teacher hands her phone to a child. A level-matched passage appears; the child reads aloud. Ninety seconds later, every word is marked like a teacher's pen — skipped words struck through, substitutions wavy-underlined ("heard: sit"), hesitations dotted — with words-correct-per-minute, accuracy, a suggested ASER-style level (letter → word → paragraph → story), and a plain-language summary. The AI only drafts: the teacher taps any word to correct it, then confirms. Confirmed levels regroup the whole class for Teaching at the Right Level, and one tap prints a level-matched practice card — paper-first, because these classrooms run on photocopiers, not iPads. A 10-minute assessment becomes 90 seconds, per child, per round.

How we built it

Method: we orchestrated Codex rather than typed. Before the first prompt we wrote a complete spec set — product/architecture, an execution plan with pre-decided edge cases, a UI spec with exact hexes and copy strings. The whole set became the opening brief of one main Codex session (its /feedback Session ID is in this submission), which built essentially the entire codebase through a strict ticket loop: one ticket per message with a done-criterion, "propose your approach in 5 bullets first" for anything big, verification by running it (never trusting "done"), raw errors pasted verbatim, one commit per ticket. Hard gates kept us honest — hour one was the risk spike: a real child's consented recording through the transcription API before any product code existed. Then walking-skeleton before UI, a mock-to-live swap (the UI was built against a frozen sample JSON, so integration took minutes), and a feature freeze before the demo video, where we instructed Codex to refuse new features even from us.

Architecture: three short calls, nothing heavy. The browser gets a short-lived signed URL and PUTs audio directly to Supabase Storage (recording bytes never touch our server). Then /api/transcribe runs whisper-1 with word-level timestamps behind a guard layer, and /api/analyze hands the server-loaded passage plus the timestamped transcript to GPT-5.6 with strict structured outputs: one ordered mark for every passage word (correct | substituted | skipped | hesitation | unclear), heard_as, per-word confidence, WCPM, accuracy, level, and a teacher summary. The server validates both the JSON schema and exact passage-word order; invalid output gets one retry with the validation error attached. Nothing enters a child's record until the teacher confirms — and the confirm endpoint recomputes everything server-side, idempotently.

The math that ships. Fluency and accuracy are recomputed from teacher-corrected marks, with hesitations counted as correct for accuracy (they signal automaticity, not decoding failure):

$$\text{WCPM} = \frac{N_{\text{correct}} + N_{\text{hesitation}}}{T_{\text{seconds}}} \times 60, \qquad \text{accuracy} = \frac{N_{\text{correct}} + N_{\text{hesitation}}}{N_{\text{passage words}}}$$

The placement rule is deliberately conservative — a single read can hold a child at the attempted level or move them down one rung, never several:

$$\text{level}_{\text{confirmed}} = \begin{cases} L & \text{if accuracy} \geq 0.80 \ L - 1 & \text{otherwise} \end{cases}$$

And a guard layer rejects unusable audio before the model ever sees it: duration $< 5\,\text{s}$, fewer than $3$ timestamped words, implausible density $> 5$ words/second, a known transcription hallucination-on-silence pattern — and a read with $> 10$ words but $< 15\%$ passage accuracy is classified as "a different passage was read" rather than mislabelled as a low reading level.

Challenges we ran into

Children's speech is the hardest input in speech recognition. Accents, mumbling, classroom noise, code-switching. We didn't pretend to solve ASR — we designed around uncertainty: per-word confidence flags routed visually to the teacher, tap-to-correct as a first-class interaction, and the teacher's confirmation as the only write path to a child's record. The AI is a draft by architecture, not by disclaimer. Whisper hallucinates on silence — a shy child who says nothing could have received a fabricated "reading"; our guard layer catches the compressed-tail pattern before analysis. Serverless body limits would have silently killed audio uploads; signed-URL direct upload dodged the class of bug entirely. Structured outputs drift — the model occasionally dropped or reordered words on long passages, so we validate word order exactly and retry with the error text. The two-day clock was itself a challenge: our pre-agreed cut list (Hindi UI first, worksheet variants second) meant cutting was a 30-second decision, not a debate. And the least technical challenge was the most important: getting real, consented recordings of children reading — our seven-clip golden set (fluent adult, scripted-errors adult, real children at different levels, noisy, near-silent, wrong-passage) became the regression harness that made every prompt change measured instead of felt.

Accomplishments we're proud of

A stranger can open the live URL, record themselves reading badly (or tap the no-mic sample path), watch their skipped words get caught, fix one word, confirm, and print a practice card — with zero setup. The word-order-validated GPT-5.6 contract renders straight into the tap-to-correct UI with no fragile parsing. The guard layer means the cheapest hallucination is the one that never happens. And every statistic we cite — from the 76% to the −17% — survives a fact-check, because we built the pitch from a research whitelist.

What we learned

That with an agent as capable as Codex, the human's job shifts from typing to sequence, verification, and judgment — docs-before-code, done-criteria, and gates were worth more than any individual prompt. That assessment science (ASER's ladder, instructional-level reading, the practice effect) is a design language, not a footnote. That the PNAS guardrail finding isn't a constraint on AI products — it is the product: "AI drafts, teachers decide" turned out to be simultaneously our safety story, our trust story, and our differentiation.

What's next

The Focus Loop — a keybr-inspired adaptive layer we've fully specified: every teacher-confirmed word becomes a weighted evidence event for a small taxonomy of reading skills ("sh words", short-a words, sight words), each tracked as a Beta posterior so decisions ride the lower confidence bound rather than a flattering mean:

$$\alpha = 1 + \sum_i w_i a_i,\quad \beta = 1 + \sum_i w_i(1-a_i),\quad p = \frac{\alpha}{\alpha+\beta},\quad \text{LCB}_{90} = p - 1.28\sqrt{\frac{p(1-p)}{\alpha+\beta+1}}$$

The weakest secure-evidence skill becomes a focus with a plain-language "why", a fresh validated mini-story featuring 3–5 controlled exemplars, and a read-back that updates the recommendation — while a hard two-model boundary guarantees practice can never change a child's official level. Beyond that: a numeracy module that diagnoses classic arithmetic bugs deterministically from wrong answers ($52-38=26 \Rightarrow$ "smaller-from-larger"), Hindi behind a golden-quality gate, teacher accounts with row-level security for real-classroom pilots — and the study that matters most: validating Suno's levels against trained human ASER assessors.

Codex built Suno; GPT-5.6 is Suno; and a teacher — always — has the last word.

Built With

Share this project:

Updates