From Sentences to Software
The Weekend I Stopped Saying “Voice Might Be Next”
“I haven’t tried voice input yet, but I’m planning to experiment soon. Given that I’ve always been able to speak more easily than write, this could be another game-changer.” — me, about a year ago, at the end of
From Squirrels to Sentences: How AI Finally Silenced My 40-Year Writing Critic
"Words.....words......words, signifying nothing and often written in a garbled 'Darryl-speak'."
I didn’t try voice input.
I built a voice tool instead. Local-only, runs entirely on my own machine, designed around the exact way my brain fails. It’s called Sermo, it’s in the hands of beta testers as I write this, and whether it’s any use to anyone but me is still an open question I’m refusing to answer prematurely.
This isn’t a piece about whether Fable 5 — Anthropic’s new model — is good or bad, or what it means for the future of anything. The internet has enough of that. This is just the honest account of what I did with it the week it landed. What I made, how it came together, and the one thing about the process that genuinely stopped me in my tracks.
Let me start with the part I find hardest to admit.
It started because the interest was ready, not because I was
I didn’t open my laptop that Wednesday night because I had a plan and a clear run at it. I opened it because I’d had the idea, the idea was interesting right now, and I have learned — the slow, expensive way — that interest is the most perishable resource I own. If I don’t act on a thing while the wanting-to is hot, the wanting-to evaporates, and the idea goes to the graveyard with the other ten thousand.
The note I made to myself, more or less verbatim, was: I need to kick this off before I lose the train of thought and interest to do so.
That sentence is the whole engine of this story. Not “I scoped a project.” Not “I assessed the market.” Just: catch it before it’s gone. Everything that follows happened because I obeyed that instinct on a weeknight instead of sensibly going to bed and “looking at it properly at the weekend” — which, for my wiring, is a synonym for never.
I’d been using another local dictation tool, Superwhisper, for a few months. It’s good. Local already, which I liked. But there was an itch it couldn’t reach, and — being honest, because the whole point of writing these things is to be honest — I didn’t have the itch fully articulated when I started. I had a vague sense of more than a thing I talk at. A place to put thoughts before they’re gone forever. Something I could shape over time rather than a finished product living inside someone else’s idea of what dictation is for. I discovered most of the actual reasons while building, not before. The build was the thinking.
So: itch, a brand-new model, thirty years of knowing how to make software, and a Wednesday. I went.
A confession about how I remembered this
When I sat down to write this article, I’d have told you — with confidence — that I built Sermo using a mix of Fable 5 and Sonnet.
I was wrong. I only knew I was wrong because I went back to the primary sources instead of trusting my own recollection: the git history and the actual Claude Code session logs, which timestamp every turn and record which model did it. I’m glad I did, because the truth is better than the version my memory had already tidied into shape.
There’s an irony here I can’t resist pointing at. One of Sermo’s core features is a “Trust view” — a little tag that shows you exactly what the AI cleanup changed in your words, so the machine can never quietly rewrite you without you seeing the diff. It exists because memory and machines both edit silently, and you deserve to see the edit.
The logs were the Trust view on my own story. They showed me my memory had kept the two bookends and quietly deleted the middle. There wasn’t one model, or two. There were three, and they ran a relay.
Act I — Sonnet wrote the plan
Before I touched any code, before that Wednesday night, I’d sat with Claude (Sonnet) in the desktop app and written a proper Product Requirements Document. Not a sketch — a real one. Problem statement, target users, functional requirements down to priority labels, a technical architecture, a competitive analysis, the lot. Fifteen sections. It even had a name: VoxLocal. (The folder on my disk still says daz-whisper; the code module is voxlocal; the shipped app is Sermo. Three names for one thing, depending which layer you’re standing on. Software is like that.)
This document matters for a reason I’ll come back to at the end, so hold one detail in your head: the PRD laid out the work as a twelve-week project. Milestone zero, the technical spike, was pencilled in as “Week 1–2.” The final milestone — polish and distribution — was “Week 11–12.” A full quarter of work, scoped sensibly by a model that knows how these things go.
Hold that. Twelve weeks. We’ll need it later.
Act II — Opus did the spike and the architecture
That Wednesday night, the relay handed off. In Claude Code, the model in the driver’s seat was Opus 4.8, and it stayed there through the hardest third of the whole build.
The first thing it did was a spike — a deliberately rough probe whose only job is to answer “is this even possible?” before you waste days building UI on top of a fantasy. And the elegant part: the PRD I’d written with Sonnet had a table of open questions, each one marked “decide at the spike.” Tauri or Electron for the shell? Which Parakeet model? Will the auto-paste even work into Terminal, VS Code, Slack? The spike’s literal purpose was to walk down that list and close every question with a real answer instead of a guess.
It worked. Inside about half an hour on a weeknight, the pipeline was proven end to end — speak, transcribe locally, clean up locally, paste into the focused app — and two further milestones were already committed. The probe didn’t just prove the idea. It tested the plan and found it sound.
Thursday was the architecture day, and this is where Opus earned its keep. The genuinely hard structural decisions — making the desktop shell the host process with a Python engine running underneath it, the packaging into a proper signed installer, the groundwork to make the whole thing cross-platform rather than Mac-only — all of that got reasoned through and built across one day. This is the unglamorous load-bearing stuff. Get it wrong and nothing above it stands up.
By Thursday night, the skeleton was solid. And then the relay handed off one more time.
Act III — Fable built it out and shipped it
Friday morning, the model in Claude Code was Fable 5, and Friday is where Sermo became itself.
There’s an hour that Friday — roughly 7:45 to 8:45am — where, if you read the commit messages back, you’re not reading an engineering log. You’re reading a manifesto. “A walk’s worth of thoughts lands as one note.” “The words that matter most stop being mangled.” “No streaks, ever.” “Tell the truth at every step.” In about sixty minutes, a dozen features landed: read-back, the Trust view, the Thought Inbox, the personal dictionary, the comfort controls, and the modes that are the soul of the thing — Brain Dump (ramble in, organised bullets out), Untangle (circling thoughts to the message you actually meant), Say It For Me (a stressful message made polite and complete and ready to send).
And here’s the inversion that I only saw by laying the PRD next to the shipped app.
In the plan, neurodivergent users were the tertiary persona. Number three. A footnote: “likely to be a power user of the modes system.” In the shipped Sermo, neurodivergence isn’t a persona — it’s the entire identity. The thing is built, deliberately and explicitly, around how ADHD, dyslexic and autistic minds work, on the principle that designing for those failure modes makes dictation better for everyone.
Somewhere across those Friday sessions, the tool stopped being a privacy-first dictation app that happened to help neurodivergent people, and became a tool about my own brain that happens to help everyone else too. It got more personal as it got built. I didn’t decide that in advance. It surfaced.
The wall, because it wasn’t all downhill
If I left it there it’d read like a victory lap, and that’s not the shape of it.
The building was the easy, giddy part. The grind showed up later, and it was almost all in the handoff — the unsexy work of getting an app to survive contact with a machine that isn’t mine. “Fix the Windows fresh-install Service offline.” “Wizard dead-ends.” The continuous integration and code-signing fights. “First-run funnel overhaul: tell the truth at every step.” Writing the app was fast. Getting it ready for a stranger’s computer was the slog.
And this is the thing that actually stopped me — not the speed. The surprise wasn’t that Fable was quick at the GitHub Actions plumbing and the release management. It’s that it worked patiently through exactly the class of tedious, low-reward, soul-sapping yak-shaving that I would normally bounce straight off. CI pipelines. Signing certificates. Release automation. This is the precise category of work where, left to myself, I get frustrated, lose interest, and quietly abandon the project — if I could be bothered to attempt it at all.
That’s the honest confession buried in here. The tool didn’t just save me days. It routed around the failure mode that has killed more of my projects than any lack of skill ever has. It’s not a speed story. It’s a frustration-tolerance story. And for a brain like mine, frustration tolerance is worth more than speed every single time.
The reckoning: an estimate in old money
Now cash the chip I asked you to hold.
The PRD scoped twelve weeks. From a Wednesday-night spike to a signed, notarised, auto-updating public beta took roughly forty-six hours. A quarter of planned work, done in two days.
The easy read is “the model got its estimate wrong.” But that’s not it, and the real version is far more interesting.
The PRD didn’t overestimate. It priced the job accurately — in the only currency it has ever seen. Those twelve weeks came from a training set full of human-authored plans, statements of work, and project schedules, every single one of them written to cost human execution. Twelve weeks is the correct price for a team of people to build this. The estimate is a fossil of the pre-amplification world’s economics. It was quoted in old money.
And then the same intelligence that handed me the twelve-week quote turned around and paid the bill in two days. It mispriced its own capability, because the only rate it knows is the human one. A model gave me an estimate in old money — and then settled the account in new.
I’m not dressing that up as a claim about what’s happening inside the model. It stands perfectly well as a thing I watched happen on my own desk.
Which brings me to the point I’ve been circling, and the reason I keep saying this isn’t a hype piece. None of this is democratisation. Fable didn’t make me a developer. It amplified thirty years of being one. Every handoff in that relay — knowing to write a PRD first, knowing what a spike is for, knowing which architectural decisions are load-bearing, knowing when the CI grind was nearly done versus hopeless — every one of those judgements is the thing the model can’t supply. I wasn’t replaced by the relay. I conducted it. The capability was already in the room; the tools just let me spend all of it at once instead of bleeding it out over a quarter.
So here’s where it honestly stands. Sermo builds and runs on my own Macs and on a Windows install under Parallels. The handoff grind is real and mostly done — but whether it survives hardware I’ve never seen is exactly what the beta is for. Cross-platform in principle; tested narrowly in fact. And whether it has any value to anyone but me? Genuinely undetermined. I’ll tell you when the testers do.
A year ago I wrote that voice might be next, and that speaking has always come easier to me than writing.
It turns out “next” didn’t mean trying a dictation app. It meant building one — around my own brain, in a weekend, by conducting three models and thirty years through a single sustained burst of interest I had the sense not to waste.
I still can’t quite believe the squirrels got me here. But the git log doesn’t lie, even when my memory does.
Sermo is a local-only dictation tool: hold a key, speak, release, and clean text lands in whatever app you’re using. Speech recognition, AI cleanup, everything — on your own machine. No cloud, no account, no telemetry, no network calls while you dictate. A sermo is spoken discourse — everyday speech — in Latin; the name is Stoic in spirit, because the tool keeps your words on your own machine.
If you’d like to be a beta tester, you can fill out the form at the following location.