Sound It Out

Early reading apps teach kids to guess from pictures. This one can't. The model drafts, a validator vetoes any untaught word, and words kids have trouble with get sound-by-sound coaching.

Comment

Sound It Out

This has been really fun to be a part of, and I’m blown away by how much I was able to get done in a weekend using the Codex app and GPT-5.6. Thanks for putting this together.

Inspiration

The current state of reading in the United States is not great. The 2024 National Assessment of Educational Progress (NAEP) gives a clear look at where we need to improve:

Grade At or above NAEP Proficient Below NAEP Basic
4th grade 31% 40%
8th grade 30% 33%

The national average reading scores for both grades were also not significantly different from

  1. In other words, after more than three decades, the overall picture has barely moved. The averages also hide wide differences reported across socioeconomic groups, race and ethnicity, disability status, and English-learner status.

Sources: 2024 NAEP fourth-grade reading results, 2024 NAEP eighth-grade reading results, and NAEP performance by student group.

NAEP Proficient is NAEP’s standard for solid academic performance on its assessment. NAEP explicitly says it is not the same thing as grade-level proficiency under state or district standards.

I have a two-year-old son, and I immediately felt anxiety thinking about the possibility of him struggling to read given the state of things. I wanted to see whether a tool that can leverage agentic capabilities could help kids anywhere learn to read without making the process as frustrating for them.

What it does

Sound It Out is an early-reading practice app for kids and the grown-ups working with them.

Many beginning readers are taught, explicitly or by accident, to guess: look at the picture, use the context, say the first letter, and guess the rest. Sound It Out removes those cues. The reader gets a short passage built only from the letter-sounds and words they have already been taught, with nothing else on the screen to guess from.

When a child needs help with a word, they tap or click it. When a child needs more help with a word, they tap/click it. The app does not say the word. It walks left to right through the word's graphemes one sound at a time. It then asks the child to blend them and try again. Help is opt-in, cancellable, and never supplies the answer. An accidental tap can be closed without recording a mistake.

GPT-5.6 drafts the passages. For each request, the server sends the exact cumulative word bank for the child’s level, along with one fixed parent-chosen theme, and requires Structured Outputs. What comes back is never automatically trusted. Deterministic application code tokenizes the draft and rejects any word outside the allowed bank or any unsafe content. If the draft fails, the child gets a hand-verified fallback passage instead.

The model drafts the passage; the application decides what a child may see. A public Decodability X-ray on the homepage makes that boundary inspectable by showing the tokens, the rejection reason, and the checked fallback that replaced the rejected draft.

The evidence is deliberately transparent for parents. Words the child reports reading without help stay separate from words that needed coaching and words that remain unresolved. The app stores word-level outcomes and time on task, but it does not store microphone audio or complete speech transcripts. Each session ends with a small offline exercise the grown-up can do with the child later.

A level unlocks only after at least two distinct completed passages and enough independent-reading evidence. If $I$ is the number of words read independently, $A$ is the number attempted, and $P$ is the number of distinct completed passages, the prototype rule is:

$$ r = \frac{I}{A} $$

$$ \operatorname{unlock} = (P \ge 2) \land (A \ge 5) \land (r \ge 0.85) $$

Coached and unresolved words remain visible to the parent, but they do not count as independent evidence.

How I built it

I started with a TypeScript template repository that I’ve been maintaining so I can jump into app ideas more quickly. Because that template already documented the stack and its conventions, GPT-5.6 and Codex were able to get the scaffolding running quickly for email and password sign-in, Google sign-in, Neon Postgres, database migrations, and automated Vercel deployment.

From there, I worked with Codex on the reading flow, the constrained GPT-5.6 integration, the deterministic passage validator, the parent evidence model, privacy and consent boundaries, responsive design, browser tests, and production deployment.

The passage validator can be summarized as a second boundary after the model. If $T(d)$ is the set of normalized tokens in a draft, $W_\ell$ is the allowed cumulative word bank for level $\ell$, and $U(d)$ is the set of unsafe matches, then a draft is accepted only when:

$$ \operatorname{accept}(d) = \left(\forall w \in T(d),\; w \in W_\ell\right) \land \left(U(d) = \varnothing\right) $$

Otherwise, the app rejects the complete draft and uses a checked fallback. The model is useful for variation, but it is never the final authority on whether content is appropriate for the child.

I also used Codex skills to build a repeatable usability-testing harness. It can run the same scenarios through defined personas across desktop, mobile, and tablet layouts, keep observed behavior separate from predicted human reactions, and produce structured findings that can be retested after changes.

Challenges I ran into

The biggest challenge was more on the product side than the technical side. Because this deals with education and kids, I wanted to be thoughtful about data handling and storage, legal disclosures, parent consent, and easy ways for parents to see what is happening with their data. If this were to actually go anywhere, I think you need (and should want) to earn parents’ trust. I’m going to keep researching this area so I can protect that kind of data in a best-practice way.

On the technical side, the biggest lesson was that I needed application code to moderate and validate the agentic output. Prompt instructions alone were not enough to make the desired reading practice repeatable. It was interesting learning how to combine Structured Outputs with a fixed schema, cumulative word banks, deterministic validation, moderation, and safe fallbacks.

Speech was another unexpectedly difficult area. Browser microphone support varies, and generic text-to-speech would say letter names like “pee” for p instead of the sound /p/. The final app keeps microphone listening optional, preserves a complete tap-based path, and uses small, pre-generated contextual phonics clips so the sounds stay consistent across devices.

Accomplishments that I’m proud of

Parents can use this tool with their kids right now and see if it helps. The fact that I was able to get all of this done over a weekend is incredible to me.

I’m also proud that the app does not hide uncertainty. It distinguishes model output from accepted content, completion from independent evidence, and automated usability predictions from things that were actually observed. Those boundaries took more work, but they make the result feel much more honest and will help keep constraints clear as I continue to build this out.

I’m going to keep researching and working through the design and architecture with Codex and GPT-5.6 to see how I can make this as accessible and free as possible for parents and their kids without burning through unsustainable API usage on my end.

What I learned

I got much deeper into Codex skills with this project, which was really fun to play with and see in action. The usability skill sets up an agentic framework that runs multiple focused sessions using defined personas and scenarios to get structured feedback on the application.

What I would like to do next is interview actual parents, educators, and readers, then use what I learn to ground the personas and scenarios. Agents could continue running those scenarios as the app changes, while real people tell me whether the problems and priorities actually match their experience.

I also learned how valuable it is to make an AI system inspectable. By setting the system up in that way, I was able to get the model to contribute something useful inside boundaries that the application can test, explain, and fall back from.

What’s next for Sound It Out

It would be great to expand this to schools if real-world testing shows that it helps kids learn to read. A lot of the research I’ve done points to the frustration children experience when reading is difficult, and how that frustration can affect whether they keep trying or grow to enjoy reading at all.

I want to figure out how AI can help grown-ups make learning to read less frustrating, stressful, or embarrassing for kids. I hope it can help move the current reading metrics in a better direction.

The next steps are human testing with families, review from reading specialists, accessibility testing on real devices, and continued work on keeping the product affordable. I want to learn whether this is genuinely useful before making stronger claims, then keep improving it so it can help people as much as possible.

Built With

Share this project:

Updates