Driving Claude Code With Your Voice: Parallel-Lane Building

Something quietly flipped in the last year of AI-assisted development: the slowest part of the loop is no longer the machine. Claude Code will happily grind through a refactor for four minutes. Cursor will draft a test suite while you're not looking. The bottleneck is you — specifically, your hands, which can only be in one window at a time.

Once you run more than one agent lane, this stops being a nuisance and becomes the shape of your day. Lane one is refactoring auth. Lane two is waiting on your review. Lane three is a Slack thread where a customer is describing a bug badly. Every one of those lanes advances on natural language — and you're producing that natural language with ten fingers and one focused window.

That's the gap voice fills. Not "dictate your novel" voice — control-channel voice. It's the part of vibecoding nobody demos: you're rarely generating the code itself by talking, you're steering the agents that do.

Prompts are prose, and prose is faster spoken

Here's the thing about driving a coding agent: the input isn't code. It's instructions. "Take the retry logic out of the WebSocket handler, move it into its own module, and make the backoff cap configurable." You can type that in twenty seconds if you're already in the window, warmed up, and not thinking about anything else.

But you're never in that state anymore. You're mid-review in another lane. You're reading the agent's last diff. You're holding a coffee. The cost of a prompt isn't the typing time — it's the context switch to get your hands and eyes into position to type it.

Speaking the prompt collapses that cost. Focus the terminal, hold a key, say the sentence you were already saying in your head, release. The words land at the cursor and the lane starts moving again while your attention returns to wherever it actually needed to be.

The workflow, concretely

I use Keebye for this — it's the tool I built when this problem ate my working life, and the specifics below are its real behavior, not aspiration.

One hotkey, held. Right ⌘ is the default. Hold it, talk, release; the transcribed text lands in whatever app has focus. For longer instructions, a single tap toggles recording on until you tap again. Esc bails out. There's no window to open, which is the whole point — the tool has no lane of its own.

Typing mode for terminals. Claude Code lives in a terminal, and terminals are hostile to clipboard-paste insertion — especially over SSH or inside tmux. Keebye can synthetically type the text instead of pasting it, with terminal-aware pacing, so the prompt arrives the way keystrokes would. This one setting is the difference between "cute demo" and "daily driver" for agent work.

A dictionary for your jargon. Speech models don't know your project's vocabulary. A custom dictionary maps what the model hears to what you meant — module names, teammate names, "pnpm", whatever your codebase makes you say repeatedly.

Local cleanup, not rewriting. Raw speech is full of "um" and false starts. Keebye strips fillers and fixes punctuation with fast rules; there's an optional local-LLM polish pass with a fidelity guard that falls back to rules if the model tries to paraphrase you. For prompts, you want your exact intent, not a creative interpretation of it.

And because all of the speech-to-text runs on-device, the prompts themselves — which describe your unreleased product in detail, lane by lane — never leave the machine.

What voice-driving is actually good at

Living with this daily, here's an honest inventory:

Redirects. The agent finished, and it's 80% right. "Keep the extraction, but revert the rename in the test files and run the suite again." Spoken, that's three seconds. This is the highest-value dictation in my day.

Queueing the next lane. While lane one builds, describe the next task into lane two. Serial hands, parallel work.

The prose around the code. PR descriptions, commit messages, Slack replies to the bug report, the email you owe. Focus the window, say it, done — your hands never left the lane they were in.

Thinking out loud, usefully. Some instructions come out better spoken because speech forces linearity. You can't nest parentheticals with your mouth.

What it's not

Honesty section. Transcription in Keebye is batch, not streaming — the text appears when you release the key, not word-by-word. That's fine for prompts (you speak, then it lands as one block) but it means this isn't a live-captioning experience. The default model is English-tuned; multilingual dictation is a separate on-device engine covering 25 languages — more on why that matters in dictation shouldn't be English-only. And no dictation tool makes a bad prompt good; voice removes friction, not the need to think.

There are also other good tools in this space — Superwhisper and Wispr Flow are the two we get asked about, and we wrote honest comparisons of both: Keebye vs Superwhisper and Keebye vs Wispr Flow.

Why this compounds

A single dictated prompt saves seconds. That's not the story. The story is what those seconds were blocking: every lane you run advances only when you feed it, so the tax on feeding a lane is a tax on all of them. Cut it, and you stop rationing your own attention — you add the third lane you weren't running because it felt like too much overhead.

The origin of all this was less elegant than a workflow essay: two kids, several high-stakes workstreams, and not enough hands. That story is here — Two kids, three startups, one voice.

Keebye is in early access for macOS. Grab a build from GitHub releases, point it at your busiest lane, and see whether your voice is faster than your context switches. Ours was.