Guide

Voice-controlling your AI coding agent: when talking beats typing

Here's the thing nobody tells you about driving an AI coding agent: most of your keystrokes aren't code. They're prose. "Refactor the auth middleware to use the new token shape, keep the old route as a deprecated alias, and add a test for the expiry case." That's a paragraph, not syntax. You type it slowly, hunting for the right phrasing, when you could just say it in eight seconds.

Agentic coding flipped the input model. You describe outcomes and the agent figures out the edits, the file paths, the imports. The bottleneck moved from "can I write this code" to "can I express what I want fast enough." And speaking is the fastest interface humans have for expressing intent — roughly three times the throughput of typing for most people. The question isn't whether voice fits coding. It's where it fits, and how to do it without shipping your microphone to someone else's server.

Why talking fits agentic coding specifically

Voice was always a bad fit for traditional coding. Try dictating a closure with nested brackets and you'll quit in a minute — punctuation, casing, and symbols are exactly what speech is worst at. But you're not dictating code to an agent. You're dictating intent, and the agent handles the symbols. That changes the math completely.

• You speak in goals, not tokens. "Add rate limiting to the public API, 100 requests a minute per key" is natural spoken English. The agent translates it into a middleware and a config change. You never had to say "open curly brace."
• Long context is cheap by voice. The more you tell an agent up front — constraints, edge cases, what not to touch — the better the result. Typing a rich prompt is tedious enough that people under-specify. Speaking a rich prompt is effortless, so you naturally give the agent more to work with.
• It pairs with how you already think. When you explain a change to a coworker, you talk it through. Voice lets you brief the agent the same way, in one pass, instead of compressing it into a terse line you'll have to clarify three times.

This is the same shift behind vibe coding — you steer with description and let the agent do the mechanical part. Voice is just the most direct version of that loop.

The case for local, on-device speech-to-text

Most dictation tools stream your microphone to a cloud API. For coding, that's a worse trade than it looks. Your spoken prompts routinely include things you'd never paste into a random web form: internal architecture, customer names, the actual bug, sometimes a credential read aloud by accident. Cloud STT means all of that leaves your machine, gets transcribed on someone's servers, and lives in logs you don't control.

On-device transcription removes that whole category of risk. Tools like whisper.cpp run a real speech model on your own CPU — no account, no network call, no audio upload. The benefits stack up:

• Privacy by construction. If the audio never leaves the machine, there's no server-side transcript to leak, subpoena, or train on. You don't have to trust a policy; the data simply isn't there to misuse.
• It works offline. On a plane, on bad hotel wifi, behind a corporate proxy — local STT doesn't care. No round-trip latency either; transcription happens at your CPU's speed.
• No metered cost. Cloud STT bills per minute. Local is free after the one-time model download, so there's no reason to ration how much you talk.

The tradeoff is honest: a small local model is slightly less accurate than the best cloud models, and a large local model wants a decent CPU. For dictating intent to an agent — short bursts, then a quick review before you hit Enter — a fast model like base.en is more than enough.

A practical dictation workflow

Good voice coding isn't "talk and pray." It's a tight loop: speak a chunk, glance at the transcript, send it. Treat the transcript as a draft, not a command that auto-fires. A workflow that holds up day to day:

• Press to record, press to stop. A toggle hotkey beats hold-to-talk for anything longer than a sentence — your hands are free to point at the screen or grab coffee while you think out loud.
• Speak one intent per take. One change, one bug, one question. Short takes transcribe more accurately and are easier to review than a rambling minute-long monologue.
• Always review before Enter. The transcript lands in your input where you can fix a misheard symbol or function name. This one habit makes a "good enough" local model perfectly usable — you catch the rare miss before the agent acts on it.
• Say the constraints out loud. Voice makes it cheap to add "don't change the public API" or "only touch the billing module." Use that. The richer the spoken brief, the less back-and-forth later.

Setup with whisper.cpp is a one-time thing: clone and build it, download a model, and point your tool at the binary and the model file. The exact build commands shift between releases, so check the project's current README rather than copying a snippet. After that, dictation is just a hotkey.

When voice beats typing — and when it doesn't

Voice isn't a replacement for the keyboard. It's a second input you reach for when it's faster. Knowing which is which is the whole skill.

Reach for voice when you're writing a long natural-language prompt, briefing the agent on a new task, explaining a bug, or driving hands-light while doing something else — running a build, watching a deploy, or floating the terminal over an editor or a game. It also shines in approval moments: a quick "yes, go ahead" or "no, use the other approach" is faster spoken than retyped.

Stay on the keyboard when you need exact symbols, file paths, regexes, or precise edits — anything where one wrong character matters. Skip voice in a shared room or on a call where talking to your computer is awkward or noisy. And don't dictate secrets or sensitive identifiers you'd rather not say aloud at all. The right setup makes switching frictionless: talk for the prose, type for the precision, in the same session.

This pairs naturally with not hovering over the terminal at all. Once you can brief by voice and get pinged when the agent needs you, you've broken the babysitting loop — see how to actually know when your agent needs you and running Claude Code in the background.

Where Backgrind fits

Backgrind ships voice built in. Hit the record hotkey to start dictating, hit it again to stop; the audio is transcribed locally with whisper.cpp — on-device, offline, never uploaded — and the text drops into your active session for you to review before you send it. Because the agent runs in an always-on-top overlay, you can dictate to one of several parallel agents without leaving whatever's underneath. Talk your intent, glance, send. See it in action or jump to the demo.