← Resources

Dictating into VS Code with Parakeety

Short answer: with Parakeety running in the menu bar, click into any VS Code text input (Copilot Chat, the commit message field, a doc comment, a Markdown file), hold the section key (§), talk, release. The transcript pastes at the cursor. VS Code is an Electron app that accepts macOS clipboard input like any other Mac app, so Parakeety works in every VS Code surface without configuration. A surprising share of the VS Code day is typing prose rather than typing code: Copilot Chat prompts, commit messages, doc comments, README sections. All of it is English, not syntax, and dictation handles it faster than the keyboard.

Where dictation fits inside VS Code

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.

A worked example

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 behavior 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 behavior."

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.

Tips specific to VS Code

  • 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.
  • Backtick and the section key. Code fences and Markdown lean on those characters, and Parakeety holds that key while it runs. Flip on Dev mode in Settings: a tap types the character, only a hold starts dictation.
  • 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.
  • VS Code's own Copilot Chat documentation. The VS Code Copilot Chat docs explain how the panel handles file context; that shapes how you structure dictated prompts.

NDA-bound code and Copilot privacy

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 organization'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, the deeper Cursor workflow (Composer-style prompting) is in Dictating into Cursor with Parakeety, and the reasoning behind keeping dictation on the device is set out in full elsewhere.

FAQ

Does Parakeety work inside VS Code?
Yes. VS Code is a native Electron-based macOS application that accepts text input the way any other Mac app does. Parakeety pastes at the cursor wherever you are: the editor, Copilot Chat, the source-control commit message field, the integrated terminal, the search box, the settings JSON editor. There is no VS Code-specific configuration.
Should I dictate code or just the prose around it?
Prose. Code identifiers (camelCase variables, snake_case names, dotted member access, generic-type angle brackets) are faster to type than to dictate, and speech models tend to drop the casing and punctuation cues that matter for code. The hybrid pattern most engineers settle into is: type the code, dictate the prose. Copilot Chat prompts, commit messages, doc comments, PR descriptions, code review remarks. Those benefit. Dictating a for-loop does not.
Does Parakeety work with GitHub Copilot Chat?
Yes. Copilot Chat is just a text input inside the VS Code window. Click into the chat input, hold the section key, dictate the prompt, release. The Copilot inline chat (the one you trigger with a keyboard shortcut inside the editor) also accepts dictation the same way. The audio path stays on the Mac; Copilot only sees the text that lands in the prompt.
What about NDA-bound code names and customer references?
The audio path stops at the Mac. Internal product names, customer names, in-progress feature names that appear in your prompts and commit messages stay out of the audio chain entirely. Copilot itself still sends the prompt text to GitHub's model provider; that is a separate decision managed in Copilot's settings and enterprise agreements. The audience-side piece is Parakeety for engineers and developers.

Try it

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 →