Dictating into VS Code with Parakeety

VS Code has several input surfaces, in rough order of how much dictation pays back:

• Copilot Chat panel. The side-panel chat that takes multi-paragraph prompts and asks Copilot to plan changes across files. Dictate the prompt; type the file names and identifiers you want to reference.
• Inline Copilot Chat. The Cmd+I editor-overlay chat that asks Copilot to modify the current selection. Same input, dictated faster.
• Source-control commit message. The single most under-invested-in piece of writing in most engineers' day. Dictating the why rather than the what is faster and produces better commit messages.
• Doc comments and JSDoc blocks. The narrative that goes above a function. Type the /**, dictate the prose, type the */.
• Markdown READMEs and design docs. Whole files of prose. Dictation is consistently faster than typing for this shape of content.
• Integrated terminal. Prompt arguments, gh / git commit messages, longer commands where the cognitive shape is prose rather than syntax.
• Settings.json comments. The reasoning you write into a settings file for future-you to read.

You finish a multi-file refactor and stage the changes. You open the source-control panel to write the commit message. Typing, most engineers write something tight and uninformative ("refactor cache layer"). Dictated, the same engineer naturally writes the version their teammate actually needs:

"Make the retry policy in upstream client configurable. The backoff used to be hardcoded to two seconds; this PR extracts a RetryConfig with initial delay, max delay and jitter, defaulting to the previous behaviour so callers do not have to opt in. All existing call sites now pass the default config explicitly, and there is a new unit test exercising the jitter calculation. No production callers should change behaviour."

Around twenty seconds dictated. Typed, that is closer to ninety. The PR description gets the same content; the review goes faster because the reviewer does not have to reconstruct the context from the diff.

• Click into the field first. VS Code has many input surfaces overlapping; the cursor needs to be in Copilot Chat (or the commit message, or wherever) before you start holding the key, not in the editor.
• Use longer prompts now that they cost less. Spoken prompts cost ten seconds instead of a minute. The model rewards context, so write the longer version.
• Hybrid: type code, dictate prose. When referring to RetryConfig by name in a prompt, type it; dictate the explanation around it. The transducer model will mangle dotted identifiers and the corrections cost more than typing them.
• Section key conflict with markdown. If you write a lot of Markdown that uses § for actual sections, remap Parakeety's shortcut to another key you do not type often.
• Push-to-talk discipline in shared spaces. Hold the key only when you are speaking; release in between. Open offices and pair-programming sessions appreciate this.

The two data paths to think about. The audio path stays on the Mac with Parakeety: internal product names, customer names, unreleased feature names that appear in your prompts and commit messages never leave the machine in audio form. The text path is governed by Copilot's settings and your organisation's GitHub agreement: by default Copilot sends prompts to GitHub's model providers; enterprise tiers offer zero-data-retention modes and constraints on training use. Parakeety covers the audio leg; Copilot's configuration covers the text leg.

The wider engineering angle is in Parakeety for engineers and developers, and the deeper Cursor workflow (Composer-style prompting) is in Dictating into Cursor with Parakeety.

Parakeety is a Mac menu-bar app. Hold the section key, talk, release; your words paste at the cursor in whichever app you were typing into, including every input surface inside VS Code. Audio never leaves the machine. There is a free 7-day trial with no card required. After that it is $30 once.

Try Parakeety free →