This is the long version: how a small annoyance about typing turned into a product, why we spent most of our time on the half nobody asks for, and what happened on the thirtieth of July.
It is also, unavoidably, the story of what the phrase voice coding came to mean, because it is the argument we kept having. It is written mostly for people who are building something adjacent, because the useful part is not the launch. It is the eight or nine weeks in the middle where we were fairly sure the obvious version of the idea was wrong and could not yet say why.
It started as an annoyance, not an idea
We were not trying to build a voice product. We were annoyed at ourselves.
The thing we kept catching each other doing was this: working a problem out loud, getting to a clear three-sentence version of what we wanted, and then turning to the keyboard and typing that same thing, slower and slightly worse than we had just said it. Not once. Constantly.
Anand put it in the sentence we ended up repeating for months:
“Thinking is fast. Typing is not. We kept saying three-sentence prompts out loud and then typing them anyway, so we built the thing that just listens and answers.”
That is a tidy quote after the fact. At the time it was just a shared irritation with no product attached to it.
We built the obvious version first
The obvious version is voice input. You speak, the words become a prompt, the agent does the work. We built that.
And here is the thing we could not articulate for weeks: dictation genuinely was a solution. It solved a real problem, the one everybody names, which is that typing is slower than thinking. We had fixed that. The tool worked. We used it.
And something was still missing, and not being able to say what it was is the most frustrating position to be in as a builder. You have shipped the thing you set out to ship, it does what you promised, and the day does not feel different.
And it was fine. That is the honest verdict and it took us a while to admit it, because everything worked. Speech went in, prompts came out, the agent responded. If we had shipped it we would have had a functioning product that demoed well.
The problem showed up in daily use rather than in the demo. We would speak a task, the agent would go away and work, and then we would sit there. Watching a terminal. Waiting to find out whether it had understood.
We had changed how the words got in. We had not changed the waiting at all, and the waiting was where the day actually went.
We shipped nothing for weeks because the version that worked was the version that missed the point.
The question that changed the product
The turn came from asking something different: not how do I get words in faster, but what if the agent could tell me?
Not a desktop notification. Everyone has trained themselves to dismiss those without reading them. An actual spoken sentence, the way a person sitting next to you would say it. “Tests pass, want me to commit?” And you answer, out loud, from the kitchen.
Once we said that out loud it seemed obvious, which is usually the sign that you have found the right frame rather than a clever one. It is also the moment the scope of the project roughly doubled, because the return path turned out to be where all the hard problems live.
The half nobody asks for is the half that is hard
Speech to text is close to a solved problem you can attach to anything. Getting a reply back out, in a way that does not make people mute the app within an hour, is not.
Three things ate most of the engineering time:
- Interruption. A voice you cannot talk over is a broadcast. But the moment your speakers play the agent's voice, your microphone hears it too, so without cancellation the thing interrupts itself. Full-duplex barge-in is unglamorous work and it is the difference between a conversation and a walkie-talkie.
- Deciding what is worth saying. An agent produces an enormous amount of text: file reads, diffs, tool calls, test output. Read all of it aloud and you have built the most annoying software ever shipped. Speech is linear, you cannot skim it, so everything spoken is paid for at full price by someone who cannot fast-forward.
- Knowing who is talking. Once you connect more than one project, a disembodied voice saying “done” is worse than useless. Per-project voices and an announcement like “From api-server…” came out of using it ourselves and being confused by our own product.
None of that is in a feature list anybody asks for. All of it is why the thing is usable.
The rule we set before we designed anything
One decision predates the UI entirely. John was blunt about it early:
“The rule was simple: nothing you say leaves your machine. A voice tool that shipped your prompts to someone's server wasn't something we'd use ourselves.”
So speech recognition and speech synthesis both run locally. Your voice and your code are not uploaded, and the loop works offline.
We expected that to cost us something in quality and it did constrain choices. What we did not expect was that it would also make the product feel better, because taking the network out of the loop is the only way a reply lands inside the window where it still feels like conversation. A privacy decision turned out to be a latency decision wearing a different hat.
The same instinct produced a much smaller detail we are disproportionately fond of: when you mute, the microphone is actually released rather than left open. A lot of voice apps keep the stream open and simply stop processing. That indicator is drawn by the OS and cannot be faked, which makes it one of the few honest signals on the machine.
A vocabulary problem
Somewhere in the middle of this we ran into a vocabulary problem.
“Voice coding” already meant something, and what it meant was dictation: speaking source code into a grammar-based recognizer, one token at a time, pronouncing every bracket. For decades that was a heroic accessibility workaround and a curiosity for everyone else, and it earned its reputation for being exhausting.
What we were building was not that. You do not say the code, because you do not write the code. You describe the change and the agent produces it. The unit moved from characters to intent, and that changes what the words are for.
We had two options: invent a new term nobody searches for, or take the words people already use and be precise about them. We took the second. It is slower, and it means occasionally explaining ourselves to people who remember the first meaning. But it is the honest description, and a category with a name people already use is worth more than a clever coinage nobody types.
People use it that way now, which is a strange thing to watch happen to a phrase you were arguing about in a room. That argument is the one we still make: what voice coding actually means. Everything else we have written is downstream of it.
The part that grew sideways
One consequence we did not plan: once an agent can speak, the terminal stops being the only room it can be useful in.
Meetings turned out to be next. A local recorder captures mic and system audio, transcribes on-device with speaker tagging, and hands the result to your agent to write up. Nothing joins the call, nothing is uploaded, and it is free and unlimited for the same reason the rest of the on-device loop is: it costs nobody server time.
The one thing that genuinely cannot be local is sending your agent into a live call as a participant, because a bot in a cloud meeting has to run somewhere that is not your laptop. That piece is metered, and we say so plainly every time we say “free”, because one carve-out buried in fine print is how products lose people's trust.
The thirtieth of July
We launched on Product Hunt on 30 July and finished the day as #1 Product of the Day.
Launch days are strange. The number is genuinely nice and it is also the least informative thing that happens, because it measures a day of attention rather than whether the thing is good. What we actually took from it arrived in the comments and messages, and it was not what we expected.
Almost nobody talked about the novelty of talking to a coding agent. The line that kept coming back, in various phrasings, was:
“I didn't realize how much I was tolerating the waiting until it stopped.”
That sentence is the whole product thesis returned to us by strangers, which is the most reassuring thing that can happen after eight weeks of being unsure whether the second half was worth building.
Where it stands
The on-device voice loop is free for life, no card, no word or time caps. It works with Claude Code, Codex, Cursor, Gemini CLI, Windsurf and around twenty other agents through one shared skill.
It is English only for now. Mac support is Apple Silicon only; Windows is x64; there is no Linux build yet and we are not going to promise a date. The app is free but closed source. We would rather list that here than have you find out later.
What we would still like is the awkward feedback: what breaks, what the agent says that it should not, what you wanted it to do and could not. That has been more useful to us than any metric, and it is most of how this gets better from here.
If you want the short version of the argument, it is the loop, not the line. If you want to try it, that is five steps.
