Dictating into Cursor with Parakeety

The mechanics of typing prose are slower than the mechanics of typing code, for most engineers. You touch-type identifiers all day; you do not touch-type rich explanations of intent. Watch how long it takes to type "refactor this function so that the caching layer is injected rather than imported, and add a parameter for the cache key prefix" versus how long it takes to say the same sentence out loud. The gap is typically four or five times.

The other effect is on prompt quality. Typed prompts tend to get clipped; spoken prompts tend to be more complete. You say what you actually want, including the context the model needs, and you say it in natural sentences. AI-assisted coding sessions where the human dictates the prompt and types the code identifiers run noticeably tighter than sessions where the human types everything.

The natural places to dictate, in order of payback:

• Composer prompts. Multi-paragraph descriptions of what you want changed across multiple files. The single highest-value place to dictate; longer prompts equal better results, and spoken prompts get longer.
• Chat panel. Iterative back-and-forth with the model. Spoken follow-ups stay specific.
• Inline comments to the model. The "ask Cursor about this code" pattern, where you select a block and ask a question.
• Commit messages. The thing every engineer under-invests in. Dictate the why; type the prefix.
• PR descriptions. Same. Type the structural elements (links, references); dictate the narrative.
• Code review comments. Whether on Cursor’s built-in review or in GitHub, dictated comments are usually clearer than typed ones.

Less natural: dictating actual code. Identifiers, syntax, indentation, types. Most engineers settle into a hybrid pattern: code is typed, English about the code is dictated. The full engineer-side framing is in Parakeety for engineers and developers.

A typical prompt sequence in Composer, dictated rather than typed, sounds like:

"Look at the way we handle retries in the upstream client. Right now the backoff is hardcoded to two seconds. I want this to take a backoff configuration object with initial delay, max delay and jitter, defaulting to the current behaviour. Update all the call sites to pass the default config explicitly, and add a unit test that exercises the jitter."

That is fifty seconds of typing, easily, and around fifteen seconds of dictation. The information density is roughly the same; the time cost is not.

Once Composer responds, the iteration ("change the default jitter to be a fraction of the delay, not an absolute value") is another two seconds of dictation versus another fifteen of typing. Across a working session, the difference compounds.

• Click into the panel first. Cursor has multiple input fields; the cursor needs to be where you want the text to land before you hold the key.
• Type identifiers, dictate prose. When you need to refer to RetryConfig by name, type it. When you need to explain what RetryConfig is for, dictate.
• Use longer prompts. Now that prompts cost ten seconds instead of a minute, write longer ones. Models reward context.
• Edit briefly, send. Spoken prompts occasionally pick up a word wrong. A two-second read-over before sending catches the obvious cases.
• Hold-the-key discipline. Push-to-talk means the model is only listening when you say so. Useful in shared workspaces and on calls.

The audio path matters for NDA-bound code. With Parakeety, audio is captured to memory on the Mac, transcribed on the Apple Neural Engine and discarded. Internal product names, customer names, in-progress feature names and unreleased work that show up in your prompts stay out of the audio path entirely.

Cursor itself still sends the prompt text to whichever model provider you have configured. That is a separate decision (managed in Cursor’s settings, and increasingly with enterprise zero-retention agreements). Parakeety covers the audio leg; Cursor’s model setting covers the text leg. The audience piece Parakeety for engineers and developers walks through the NDA framing in more detail.

Cursor is the obvious place because of Composer, but the same pattern fits VS Code with its Copilot Chat panel, JetBrains IDEs, Zed and any web-based AI tooling. Slack threads, GitHub issue comments, Linear ticket descriptions, design docs, customer-support replies and post-mortems all benefit from the same hold-key-and-talk loop. The full set of engineering surfaces sits in the audience piece.

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. 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 →