I'm dyslexic. Proofreading my own writing is the exact task my brain is worst at — the eye skips, autocorrects, and fills in what it expects to see. For years, that meant paying someone else to catch the errors I couldn't see, or publishing with mistakes I'd read past ten times. On 15 July 2026, I built the tool that lets me do it with my ears instead.
The tool is Cadence, a fully local desktop app that turns a folder of Markdown files into narration with synchronized highlighting. It runs entirely on my laptop — no account, no subscription, no cloud upload — and it shipped with 368 backend tests passing before I trusted it with a real manuscript.
This is the layer thesis made personal. Coding languages are increasingly plain-language layers that convert something understandable into something a machine can process: software layers on top of a browser, layering on an operating system, layering on the machine layers. Agentic coding is another layer of plain-language conversion. I can now code through English, my native language, instead of translating it into Python or TypeScript. The thesis can only be published credibly next to the measurement discipline, so here's what that looked like for Cadence.
Asking for a product when the repo shipped a model
I asked a coding agent to get an open-source speech model running, expecting it to work out of the box the way a browser does. I ended up designing all of the features I was expecting the tool to ship with, before I understood what I was actually working with. The opening prompt was 1,105 lines, and its ninth line forbade the agent from writing any code. Instead, it asked for a repo audit, a product spec, architecture decisions, a phased roadmap, design requirements, and a handoff prompt for a separate design agent. All six deliverables exist.
The resulting design went through a 19-entry reconciliation ledger grading each feature Essential, Beneficial, or Decorative, and roughly half were rejected. What survived that gate became the roadmap: the core speech and highlighting engine built across three consecutive days in July, with two later single days adding project management and a notes export.
Content-addressed blocks so everything lines up
Documents parse into stable content-addressed blocks — paragraphs get a hash based on their content — so highlighting, notes, change detection and audio caching all line up on the same units. When a manuscript is revised, only changed paragraphs re-render. Notes follow the text that moved and are flagged for review rather than silently reattached when a match is uncertain. The diff-and-reconcile engine was the riskiest component, so it was attacked first: three confirmed bugs, each fixed with a regression test, before it was declared safe to build on.
A Windows quirk that failed silently
A hidden file attribute on an entire project folder made every chapter show as stale and refuse to regenerate. The JSON writes kept succeeding so the app looked fine while the audio never updated, and the worker couldn't log the failure either. Both are fixed. That failure mode is why the test suite exists: 368 backend tests currently pass, and the count climbed from 309 at ship to where it sits now as each new component came with its own coverage.
The receipts on two real projects
Cadence has narrated 2,995 segments across two real projects: 1,869 segments from a 63,000-word manuscript, producing 6.94 hours of narration in 98.2 minutes of GPU time, and 1,126 segments from 51 company knowledge-base documents, producing 2.51 hours of audio. Zero failures in either run.
The status word is shipped, to an audience of one. Cadence has never left my machine, and it won't — it's an accessibility tool built for exactly how I read, not a product.
What the layer thesis actually means
I didn't invent a new synthesis algorithm or train a model. I directed an agent through designing, building and testing the product layer around an open-source speech model someone else built, in plain English, because that's the layer that finally speaks my native language. The agent wrote the code, the tests, and the documentation. I decided what the tool needed to do, what could be cut, and whether the output was safe to trust.
That's the accurate frame: the agent writes the code, tests and documentation; the human directs, decides, purchases and validates. Never "built entirely by AI." The verification evidence — 368 tests passing, 2,995 segments narrated with zero failures, a reconciliation ledger that rejected half the features before a line of code was written — sits next to the thesis, not pages away, because the thesis can only run credibly when the measurement discipline is right there in the same breath.
Proofreading by ear works around the problem my brain has with proofreading by eye. I can finally do the task I'm worst at, because I built the tool that does it differently, and I built it in the only language I was ever fluent in.