The same feature, rebuilt four times: voice in Jubileus

Jubileus can be talked to. Push to talk, ask the vault a question out loud, hear it answer. The feature shipped early and then got rebuilt four times, and the reason it kept changing is the reason it’s worth a note: every rebuild was forced by a single constraint I refused to break.

That constraint is the whole project’s founding rule — localhost, my files, zero dollars a month, nothing in someone else’s cloud. Voice is the subsystem that fought that rule hardest, because good speech recognition and synthesis are exactly the things the industry wants to sell you as a cloud API.

The four generations:

Web Speech, browser-native. The fastest thing to stand up — the browser does the work. Good enough to prove the cockpit should have a voice at all, but it leans on a cloud service under the hood and the quality is uneven.

Piper, local neural text-to-speech. The first real step toward the constraint: a neural voice running on my own machine, opt-in. The hub started to sound like something instead of a system beep.

Kokoro, a better local voice tier. Same move, higher quality — swapping the synthesis engine again as local neural voices got good enough that I stopped missing the cloud ones.

A local Whisper server for the listening half. Speech-to-text is the harder direction, and moving it local closed the loop: the whole voice path, hearing and speaking, now runs without a byte leaving the machine.

Four rebuilds of one feature is the kind of churn that looks like indecision in a git log. It isn’t. It’s what happens when the interface stays fixed — “I want to talk to my notes” — and the implementation has to keep moving to satisfy a constraint that never bends. The feature didn’t change. The bar for meeting it kept rising, and each time local tech cleared the bar, the cloud dependency came out.

The lesson generalizes past voice: decide which of your constraints are sacred, write them into the project’s first design doc, and let everything else be negotiable. A fixed principle with a swappable implementation is a feature that improves for years. A fixed implementation is one that rots.