MacBook Dictation: Code camelCase snake_case

Why is dictating code on a Mac so painful by default?

Three things conspire against you. First, identifiers are not natural English — getUserById is three words mashed together in a way nobody says out loud. Second, every programming language has its own bracket, quote, and operator dialect, and plain dictation just sees "open paren" where you wanted (. Third, most built-in dictation (Apple Dictation, Google Docs voice typing) is tuned for prose, so it tries to format your speech as sentences and silently "fixes" things that aren't broken.

That's the wall people hit. They say "get user by id" and get back "Get user by id." with a capital G and a period. They say "open bracket" and get the words, not the character. The fix is to use a transcription engine that gives you exactly what you said, plus a post-processing layer that knows what code looks like. That's the job dictation in Cursor and other editors is supposed to do — and it works once the right pieces are in place.

Can Whisper transcribe camelCase and snake_case correctly?

Out of the box, Whisper large-v3-turbo transcribes what you say. If you say "camel case variable", you'll get the words "camel case variable" back — not camelCaseVariable. So the model is doing its job; it just isn't a compiler. You need to bridge the gap.

This is also where the choice of tool matters. Apple Dictation is free, but it's online-only on older macOS and consistently mistranscribes identifiers in my own testing. The 7-app head-to-head I ran on the same audio file earlier this year put MetaWhisp at 3.7% WER versus Apple Dictation at 11–14% — which is the gap between "useable for code" and "rage-inducing".

Pro tip: Say identifiers as if you're naming a function for a junior dev. "Get user by id, takes a string, returns a user" becomes a one-sentence function spec you can edit. Trying to say each token separately ("get underscore user underscore by underscore id") is a trap — Whisper hears the underscores as gaps and you end up with five words instead of one identifier.

What does "camelCase" actually need from a voice tool?

It needs three things, in order of importance: accurate word boundary detection, predictable casing, and a clean handoff into the editor. Word boundaries come from how the model tokenizes speech — Whisper is good at this. Predictable casing comes from a deterministic post-processor, not the model: once you decide "snake case" means snake_case and "camel case" means camelCase, the rule doesn't change between sessions. The handoff is the part most people forget — your text has to land in the active editor at the cursor, not in a separate app.

That last point is where the global hotkey approach pays off. MetaWhisp defaults to Right Option (⌥) held to talk, released to paste. The text shows up wherever your cursor is — VS Code, Cursor, Xcode, Terminal, a Jira ticket. You're not switching windows to copy from a notepad.

How MetaWhisp handles camelCase, snake_case, and brackets

There are two layers. Layer one is the on-device Whisper model that runs in local mode — it produces the same text the model would produce anywhere else. Layer two is the Structured processing mode in Pro, which is a small language model rewrite step that runs after transcription. The Structured mode is designed for exactly this kind of mess: it takes "open curly close curly" and gives you {}, takes "get user name" and gives you getUserName, and strips the filler words ("uh", "let me think", "actually") that your mouth produces but your code does not need.

Local mode stays free forever. Cloud features — Structured mode and translation — are Pro. The split is intentional: recognition itself is solved by the open-source model, and the post-processing polish is what you pay for. You can see the full feature list on the pricing page.

Custom vocabulary: teaching the dictation tool your code

Whisper's vocabulary is whatever was in its training data. If you work on a private codebase with words like GraphQL, xUnit, or your company's internal product names, Whisper will sometimes normalize them to something more common ("graph QL" → "graph Q L"). Custom vocabulary is the fix.

MetaWhisp's Pro tier exposes a custom vocabulary list where you can add project-specific terms. Once added, the post-processor will treat them as proper nouns and preserve their casing. It's a simple feature but it's the difference between dictating a test name and watching the editor autocorrect your work. For a deeper walkthrough of building project-specific voice workflows, the guide on dictating prompts to Claude Code covers a similar pattern.

Founder's note: I keep a small vocabulary list of our internal product names and a few API terms (Stripe webhook names, Supabase table names). It cuts the post-edit pass from ~30 seconds to almost nothing. If your project has its own jargon, write it down once and stop re-fixing it forever.

How does MetaWhisp compare to Talon for voice coding?

Talon is the heavyweight here. It's an open-source voice platform with its own Python-based scripting language for commands — you literally write code to define new voice commands. It can do almost anything: navigation, editing, window management, custom grammar per language, even eye tracking integration. It is not a dictation tool in the Whisper sense; it is a programmable voice control surface.

The tradeoff is setup time. Talon needs you to learn its scripting layer, install community filesets (often hundreds of lines of Python), and tune recognition for your voice. It is genuinely powerful once it's tuned, and a serious Talon user is faster than most people with a keyboard. But the "serious Talon user" part is doing a lot of work in that sentence.

Honest reading: if you want to dictate and have full keyboard-free control of your editor — moving cursors, selecting tokens, triggering refactors by voice — Talon is more capable. If you want to dictate text well, drop it into your existing editor, and keep using your keyboard for navigation, MetaWhisp is faster to get started with and produces better raw transcripts thanks to Whisper.

Cursorless vs MetaWhisp: different jobs, not rivals

Cursorless is a voice-coding layer built for the Cursor editor (and its VS Code fork). It focuses on structural editing: refer to code by token, scope, or visual position ("the third function below this one", "the air under that") and apply edits by voice. It is genuinely good at that job and worth learning if you live in Cursor.

What Cursorless does not do is dictation — it doesn't transcribe natural speech into new code. It assumes you'll either type the new content or generate it through other means. For pure dictation, you still need a Whisper-style tool alongside it, and many Cursorless users pair it with Talon (which handles both the recognition and the command layer).

A real voice coding workflow on a Mac

Here is the workflow I actually use. Open the editor (Cursor, VS Code, whatever). Cursor is on a new line. I hold Right Option and talk:

"function get user by id, takes id string, returns user. open curly. if not user, throw new error, open quote user not found close quote. return await db dot users dot find first, open curly where colon id. close curly. close curly."

I release the hotkey. With Structured mode on, the post-processor turns that into something close to:

function getUserById(id: string): Promise<User> {
  if (!user) throw new Error("user not found");
  return await db.users.findFirst({ where: { id } });
}

It is not perfect on the first pass. The structured output occasionally drops a token or mis-nests a bracket. I correct those with the keyboard, not by re-dictating the whole thing. That correction pass is fast — usually under ten seconds for a function this size. The point is that the heavy lifting of "type 200 characters of correctly-cased identifier names" is now a voice task, not a finger task.

For longer sessions, I keep MetaWhisp running in the background and trigger the hotkey with a single key. The whole pipeline — speech to text to paste — is fast enough that the bottleneck becomes how fast I can think of the next line, not how fast I can type it.

Pro tip: Dictate the structure first, then the content. "Function, takes user, returns result, opens curly" gets you the skeleton. Then dictate inside it. Two short dictations are more reliable than one long one, because Whisper's error rate grows with utterance length.

Tips that actually work when dictating code

After months of doing this daily, here is what I would tell a developer trying it for the first time.

• Say identifiers as phrases, not letters. "Get user name" beats spelling "G-E-T underscore U-S-E-R underscore N-A-M-E". Whisper's word boundary detection is good for the first form and bad for the second.
• Name brackets and operators with their symbols when you can. "Open paren" and "close paren" usually work, but saying the symbol directly — "left paren", "right paren" — is more reliable in Structured mode.
• Use short utterances. One function per dictation, not one file. Whisper's accuracy tends to degrade with long continuous utterances.
• Add a custom vocabulary list. Project names, library names, internal terms. The first time you skip a manual correction is when dictation starts paying for itself.
• Keep your keyboard close. Dictation is for the heavy text. The keyboard is for fast corrections and navigation. Trying to do 100% voice coding is a slow path; mixing the two is the fast one.
• Use a good microphone. The MacBook's built-in mic is fine in a quiet room. In a coffee shop, the AirPods mic is much better. Bad audio is the single biggest source of transcription errors.

The last one is underrated. People blame the model when most of the error is acoustic. Apple's own AirPods Pro, or any decent USB headset, will cut your edit-pass time dramatically. The model is already good — the bottleneck is the room.

Frequently asked questions

About the author: Andrew Dyuzhov is the solo founder of MetaWhisp. He is a marketer and builder with ADHD who assembled MetaWhisp using AI coding tools on top of open-source Whisper. He dictates daily in Russian and English, ran a 7-app head-to-head transcription test earlier this year, and uses voice-first workflows to get past writing paralysis. He is not an ML researcher — he just shipped the tool he wanted to use. Find him on X.

Related reading

• How to Dictate in Cursor on Mac
• How to Dictate Prompts to Claude Code
• Global Hotkey: Hold Right Option to Dictate Anywhere
• Processing Modes: Local, Structured, Translation