# How to Dictate in Cursor: Every Input, Not Just the Agent

> Cursor's voice mode fills the Agent prompt and nothing else — and won't send on a keyword. Speech-to-text for every Cursor input, on Mac, Windows and Linux.

- URL: https://www.getvoibe.com/resources/dictate-in-cursor/
- Author: Ayush
- Published: 2026-06-09 · Updated: 2026-10-12

**TL;DR:** To dictate in [Cursor](https://cursor.com), run a system-wide speech-to-text app, put your cursor in any Cursor input — the Agent or Composer prompt, a Cmd+K inline edit, the chat panel, the integrated terminal, or the code editor itself — hold your dictation hotkey, and speak. Cursor has its own voice mode (start and stop it with `Cmd+Shift+Space`, then send with `Cmd+Return`), but it drops text into the Agent prompt and nowhere else. A system-wide voice-to-text tool like [Voibe](https://www.getvoibe.com) types into every surface, can keep your code on your machine, and resolves your project’s file and folder names as you speak. This guide covers both paths on Mac, Windows and Linux.

This is the killer use case for voice on a Mac: dictation is faster than typing for prose, and AI prompts _are_ prose. Speaking a multi-file Composer instruction is far quicker than typing it — once your tool can spell your file names correctly.

> **Key takeaway:** Dictate in Cursor with a system-wide on-device tool: hold a hotkey and speak into any surface — Agent/Composer prompt, Cmd+K, chat, or the editor. Developer Mode resolves your workspace's file and folder names so prompts reference the right files.

> **Tip:** The fastest setup: install a system-wide dictation tool, enable Developer Mode, set a hotkey you can hold while typing, and dictate your Composer and Cmd+K prompts instead of typing them. Speaking a 40-word multi-file instruction takes seconds; typing it takes a minute.

## Where You Can Dictate in Cursor

Cursor is an AI-first code editor (a fork of VS Code) with several places you type — and therefore several places you can dictate. A system-wide dictation tool works in all of them because it inserts text wherever your cursor is, exactly like a keystroke:

| Cursor surface | What you dictate | Cursor native voice? |
| --- | --- | --- |
| **Agent / Composer prompt** | Multi-file change requests, feature descriptions, refactors | Yes (its primary target) |
| **Cmd+K inline edit** | Targeted edits on a selected block ("add error handling here") | No |
| **Chat panel (Cmd+L)** | Questions about the codebase, debugging back-and-forth | No |
| **The code editor** | Comments, docstrings, Markdown/README, string literals | No |
| **Integrated terminal** | Commands, commit messages, branch names | No |

Cursor's **Cmd+K** turns a selection into a diff from a natural-language instruction, **Composer** (Composer 2 shipped in 2026) makes coordinated edits across multiple files, and **Agent** can read the codebase, run shell commands, and iterate until a task is done. All three are driven by prose you write — which is exactly what dictation accelerates. The catch is that Cursor's built-in voice mode only fills the Agent prompt, so to dictate into Cmd+K, the chat, or the editor itself you need a system-wide tool.

## Cursor's Native Voice Mode vs a System-Wide Dictation Tool

Cursor shipped a native voice mode in 2.0, and it is still here in the 3.x builds. You start it, speak, stop it, and the text lands in the Agent input. It is genuinely useful for firing off a quick agent prompt without typing. But it is scoped narrowly, and three things about it matter before you lean on it.

**It only targets the Agent prompt.** Cursor’s voice mode does not type into Cmd+K, the chat panel, the editor, or the terminal, and users on the [Cursor community forum](https://forum.cursor.com/t/voice-mode-no-live-transcript-submit-keywords-never-send-finalize-on-stop-only/165822) report it does not support @-file mentions, model selection, or mode switching by voice. It is prompt dictation, not editor control.

**There is no live transcript.** While you are speaking you get a microphone waveform and nothing else — the transcription only appears once you stop the mic. If you are used to watching words land as you talk, the silence reads like a failure when it is just how the feature works.

**Its processing location is undocumented.** Cursor has not published whether its voice transcription runs on-device or streams audio to a server, and there is no voice section in Cursor’s docs to check. For a tool you point at a proprietary codebase, that matters: your spoken prompts routinely contain file names, function names, and architecture details. A cloud transcription step sends all of that off your machine.

A system-wide tool addresses all three. It types into every surface (and every other app), it shows you the text where you are typing, and it gives you a choice of where audio is processed — on-device, where nothing leaves your machine, or a private zero-retention cloud that never stores or trains on your data. Here is the honest comparison:

| Dimension | Cursor native voice | System-wide dictation (e.g. Voibe) |
| --- | --- | --- |
| Works in the Agent prompt | Yes | Yes |
| Works in Cmd+K / chat / editor / terminal | No | Yes |
| Works in every other app | No | Yes |
| Live transcript while speaking | No — waveform only | Yes |
| Processing location | Undocumented | On-device, or a private zero-retention cloud — your choice; never stored or trained on |
| Resolves your workspace’s file names | No | Yes (Developer Mode) |
| Custom vocabulary for libraries / APIs | No | Yes |
| Platforms | Wherever Cursor runs | Mac and Windows |
| Setup | Built in | Install + grant 2 permissions |

The pragmatic answer: use Cursor’s native voice for throwaway agent prompts if you like it, and a system-wide tool as your primary driver for everything else. Here is how to set up the system-wide path.

## How to Start, Stop, and Send in Cursor's Voice Mode

This trips up more people than any other part of Cursor voice input, because the control you would reach for — saying “submit” — is the one that does not work. Here is the actual sequence.

| What you want | How to do it |
| --- | --- |
| **Start recording** | `Cmd+Shift+Space` on Mac, or click the microphone icon in the chat input. `Ctrl+M` is also reported as a shortcut. |
| **Stop recording** | Press the same shortcut again. It is a toggle, not a held key — and stopping is what makes the transcript appear. |
| **Send the prompt** | `Cmd+Return` after you have stopped. Stopping the mic does not submit. |
| **Discard instead** | Cancel from the voice control, which stops recording and throws the audio away. |

**The submit keywords do not work.** Cursor lets you configure a spoken keyword such as “submit” in settings, and it should end the recording and send. As reported on the [Cursor community forum](https://forum.cursor.com/t/voice-mode-no-live-transcript-submit-keywords-never-send-finalize-on-stop-only/165822) against version 3.11.19, saying it “does nothing; the mic just keeps listening,” even after several seconds of silence. The reporter notes this is a regression of an earlier issue that had been fixed in 2.0.32. Until it is fixed again, the working sequence is the one above: **stop with `Cmd+Shift+Space`, then send with `Cmd+Return`**.

None of this applies to a system-wide dictation tool, which is worth saying plainly because the two get conflated. There, the hotkey you hold is the recording, releasing it inserts the text at your cursor, and sending is whatever that app’s send key already was — there is no separate voice state to get stuck in.

## Step 1: Install a System-Wide Dictation Tool

Any system-wide Mac dictation tool will type into Cursor. This guide uses [Voibe](https://www.getvoibe.com) because it can run entirely on-device on an Apple Silicon Mac and has the workspace-aware Developer Mode that makes voice-prompting Cursor reliable; the same steps apply in spirit to alternatives covered at the end.

1. Download Voibe from [getvoibe.com](https://www.getvoibe.com) (or the [direct .dmg](https://voibe.s3.us-east-1.amazonaws.com/releases/current/voibe.dmg)) and drag it to Applications.
2. Launch it. On Apple Silicon (M1–M4, macOS 13+) it downloads a local Whisper model (~2 GB) on first run.
3. There is no account to create and no internet needed after the model downloads.

For the full install walkthrough including the first-launch security prompt, see our [Voibe setup guide](https://www.getvoibe.com/resources/getting-started-with-voibe/).

> **Info:** Requirements: a Mac running macOS 13 Ventura or later. Voibe works on all Macs (Intel and Apple Silicon); its on-device mode requires an Apple Silicon Mac (M1 or later) and about 2 GB of free disk space for the local model. On an Intel Mac, use Voibe's private, zero-retention cloud mode.

## Step 2: Grant Permissions and Set a Hold-to-Talk Hotkey

A system-wide tool needs two macOS permissions to work inside Cursor:

1. **Accessibility** — lets the tool insert text into Cursor (System Settings > Privacy & Security > Accessibility, then enable the app).
2. **Microphone** — lets it capture your speech (granted on first use, or System Settings > Privacy & Security > Microphone).

Then pick a hotkey you can comfortably _hold_ while your hands rest on the keyboard. This is push-to-talk: the microphone is live only while the key is down, so there is no voice state to toggle in and out of and nothing listening when you are not holding it. Voibe defaults to holding the **Fn** key: press and hold, speak, release, and the text appears at your cursor. If Fn conflicts with your keyboard layout, set a different key in settings — a held right-Command or a custom combination works well. For a deeper look at hotkey options and conflicts, see our [Mac dictation keyboard shortcuts guide](https://www.getvoibe.com/resources/mac-dictation-keyboard-shortcuts-guide/).

Hold-to-talk is the right pattern for coding: you keep one hand on the hotkey, dictate a prompt or comment, release, and your hands are already back on the keyboard to edit.

## Step 3: Enable Developer Mode for File and Folder Resolution

This is the step that makes voice-prompting Cursor actually work, and it is the feature no native editor voice mode offers. Open Voibe's settings and toggle **Developer Mode** on. Once enabled, Voibe detects your open Cursor (or VS Code) window and resolves file names, folder names, and project-specific terms from your workspace as you dictate.

The problem it solves: spoken identifiers don't transcribe cleanly. Say "update user service dot t s" and a normal dictation tool writes exactly that. Developer Mode matches the words against your actual workspace and inserts `userService.ts`. The same applies to folders, components, and any term that appears in your project tree.

Why it matters for Cursor specifically: the single biggest friction in voice-prompting an AI editor is getting it to reference the _right_ files. A prompt like "refactor the auth handler in userService and update its test" only works if "userService" lands as the real filename. Developer Mode turns that from a manual cleanup step into something automatic.

## Real Voice-Prompt Examples for Cmd+K, Composer, and Agent

Here is what dictating into each Cursor surface looks like in practice. Hold your hotkey, speak the instruction, release, and (where relevant) submit.

### Cmd+K — Targeted Inline Edit

Select a block of code, press Cmd+K, then dictate the change:

- _"Refactor this function to use async/await instead of callbacks, and add error handling with a try-catch block."_
- _"Extract these three validation checks into a helper called validateInput and call it here."_

### Composer — Coordinated Multi-File Change

Open Composer and dictate a change that spans files. This is where voice wins most, because multi-file instructions are long to type:

- _"In the checkout flow, add a loading state to the Pay button and disable it while the request is in flight. Update the button component and the checkout page that uses it."_

### Agent — Delegated Task

Dictate a task and let the agent plan and execute:

- _"Add a rate limiter to the public API routes, write tests for it, and run them."_

### The Editor and Terminal

Outside the AI surfaces, dictate directly: a docstring above a function, a Markdown section in your README, or a commit message in the terminal (_"fix: prevent duplicate submissions on the checkout button"_).

Keep prompts to short, structured chunks — voice transcription handles a focused two-sentence instruction far better than a 60-word run-on. For a repeatable structure to dictate by, use the **Five-Part Voice Prompt** framework (Goal, Inputs, Constraints, Example, Output) from our [voice-prompt AI guide](https://www.getvoibe.com/resources/voice-prompt-ai/), and pair it with the Talk-Draft-Polish loop in our [voice input workflow guide](https://www.getvoibe.com/resources/voice-input-workflow/).

If the same voice workflow also drives Claude Code, there is one prompt worth recognising before you answer it on autopilot: the post-rating question asking whether Anthropic can look at your session transcript. Yes ships the whole session, including files a subagent read that you never opened yourself — [what the transcript prompt actually uploads](https://www.getvoibe.com/resources/claude-code-session-transcript-privacy/) breaks down all three answers.

## Tips for Dictating in Cursor More Accurately

- **Add a custom vocabulary for your stack.** Library names, API endpoints, and product terms (e.g. "Tanstack", "Supabase", "useMutation") are the words dictation gets wrong. Add them once so they transcribe correctly every time.
- **Let Developer Mode handle file names.** Don't spell out paths — say the file name naturally and let workspace resolution map it to the real identifier.
- **Speak the goal, then the constraints.** "Add pagination to the users table — twenty per page, server-side" lands better than narrating implementation detail.
- **Dictate in short bursts.** Ten-to-thirty-word phrases transcribe most accurately. Pause between thoughts rather than chaining clauses.
- **Use a decent microphone.** Even a basic USB mic cuts errors on technical terms versus the built-in mic in a noisy room.
- **Edit with your hands.** Voice is fastest for the first draft of a prompt or comment; fix the last 5% by keyboard. The hold-to-talk hotkey keeps your hands in position.
- **Keep proprietary code on-device.** If your codebase is confidential, use an on-device tool so spoken file and function names are never transmitted.

## Try Voibe on Your Next Composer Prompt

Everything above works with any system-wide dictation app. This section is the one place the guide argues for ours, because two of the problems this page describes only have one fix.

**Spoken file names that actually resolve.** This is the difference between voice being a novelty in Cursor and being the way you work. Say “update the user service and the auth middleware” and Developer Mode matches those against the files in your open workspace, so they land as `userService.ts` and `authMiddleware.ts` rather than as four English words your agent then has to guess at. No general speech model does this, because none of them can see your project.

**No voice state to get stuck in.** Cursor’s voice mode is a mode: you enter it, the transcript hides until you leave it, and the spoken submit keyword that should end it is broken. A held hotkey has none of that shape. The microphone is live while the key is down and dead when it is up, the text appears where you are already typing, and Cursor’s own send key still sends. There is nothing to toggle out of.

**And it covers the other four surfaces.** Cmd+K inline edits, the chat panel, the code editor itself, the integrated terminal — plus every app outside Cursor, which is where the PR description and the Slack update live.

**On the question this page keeps raising:** Cursor has not published where its voice transcription runs. Voibe has, because it is a setting you control — on Apple Silicon (M1–M4, macOS 13+) it runs Whisper fully on-device, so the recording never leaves your Mac and only the finished text reaches Cursor. On Windows and Intel Macs it uses a private zero-retention cloud: audio is never stored, sold, or used to train AI. For a tool you point at a proprietary codebase, that is the whole argument.

**What it costs.** $199 once for a lifetime licence, or $9.90/month, or $99/year, with a free plan (limited words, one device) if you only dictate occasionally (the category comparison is in our [dictation app pricing breakdown](https://www.getvoibe.com/resources/dictation-app-pricing/)). Against Wispr Flow’s $144/year subscription — the cloud option in the tools list below — the lifetime licence pays for itself in about 17 months and then keeps working. There is a 7-day free trial and no account required to start; full plan details are on [Voibe pricing](https://www.getvoibe.com/pricing).

**[Download Voibe for Mac](https://voibe.s3.us-east-1.amazonaws.com/releases/current/voibe.dmg)** — or grab the Windows installer from [getvoibe.com](https://www.getvoibe.com). Then open Composer, hold your key, and say the multi-file change you were about to type out.

> **Tip:** The honest test for Cursor specifically: turn Developer Mode on, then dictate a Composer prompt that names three real files in your project. If the identifiers come out spelled correctly, that is the feature doing the thing no general dictation app can.

## Going the Other Way: Having Cursor Transcribe a Recording

Everything above sends your voice into Cursor. The reverse works too — **Cursor's agent mode can transcribe audio you already have**, which is useful when the spec you need to implement was a call rather than a ticket.

Voibe's speech-to-text API runs a hosted MCP server at `https://api.getvoibe.com/mcp`; add it as a remote MCP server in Cursor's settings, or have the agent call the three REST endpoints over plain HTTP. Either way you get four tools — `create_transcription_job`, `get_transcript`, `list_transcripts`, `get_balance` — and a request like _“transcribe yesterday's planning call and turn the decisions into a task list”_ becomes one instruction.

Billing is per second and charged only on a delivered transcript, so an agent's retries cost nothing, and the audio is deleted the moment the text exists. If you would rather not touch a config file, the same server connects in **Claude Cowork, Claude desktop or Claude web** under _Customize › Connectors › Add custom connector_. The full walkthrough is in [transcribing a Zoom recording](https://www.getvoibe.com/resources/how-to-transcribe-zoom-recording/).

## Cursor Voice Input Not Working: Fixes for Both Paths

Two different systems fail in two different ways here, so the first question is which one you are using: Cursor’s built-in voice mode, or a system-wide dictation app typing into Cursor.

### Cursor’s voice mode records but no text appears

Usually not a bug. Cursor shows only a waveform while recording and finalizes the transcript when you stop the mic, so nothing appears until you press `Cmd+Shift+Space` a second time. If you were waiting for a live transcript, that is the whole explanation.

### Saying “submit” does nothing

Cursor’s spoken submit keywords are broken as of version 3.11.19 — a regression of an issue that was fixed back in 2.0.32, reported on the [Cursor community forum](https://forum.cursor.com/t/voice-mode-no-live-transcript-submit-keywords-never-send-finalize-on-stop-only/165822). Stop the recording with `Cmd+Shift+Space`, then send with `Cmd+Return`.

### Voice mode sends empty or wrong prompts

Users have reported the native voice mode mis-firing on submit keywords and sending empty messages. If you hit this repeatedly, switch to a system-wide dictation tool for prompt entry — you keep voice input without the Agent-prompt-only constraint or the separate voice state.

### Text isn't appearing in Cursor at all (system-wide tools)

This is almost always a missing Accessibility permission. Open System Settings > Privacy & Security > Accessibility and confirm your dictation app is enabled. If it is enabled but still not typing, remove it from the list and re-add it to reset the permission — this fixes most cases after an app update.

### File names aren't resolving

Confirm Developer Mode is toggled on and that Cursor is the frontmost window with the workspace open. Resolution works against the files in your open project; a file that isn't part of the workspace won't be matched. Adding the term to your custom vocabulary is the fallback.

### Technical terms are mis-transcribed

Add the offending library, framework, or API names to your custom vocabulary. General-purpose speech models don't know "Zod" or "Drizzle" until you tell them.

### Dictation feels slow

On-device transcription uses the Neural Engine, which is shared with other apps. Close memory-heavy apps, or choose a smaller local model if your Mac has 8 GB of RAM. Transcription is noticeably faster on Apple Silicon than on older hardware.

## Dictating in Cursor on Windows and Linux

Cursor is not Mac-only, and neither is dictating into it. [Cursor’s download page](https://cursor.com/downloads) ships builds for **macOS** (ARM64, x64 and Universal), **Windows** (x64 and ARM64, in both system and user installers), and **Linux** (.deb, RPM and AppImage, ARM64 and x64). The setup above is written for Mac because that is where on-device transcription is available; here is what changes elsewhere.

### Windows

Cursor’s native voice mode travels with the app, so the Agent-prompt-only limit and the stop-then-send sequence are the same. For the other surfaces you need a system-wide tool, and you have two realistic options:

- **Windows voice typing (`Win+H`)** — free and built in. Put your cursor in any Cursor input, press `Win+H`, and speak. It needs an internet connection and has no custom vocabulary, so library and project names come out mangled. Our [Windows dictation guide](https://www.getvoibe.com/resources/how-to-use-dictation-windows/) covers the setting most people miss.
- **[Voibe](https://www.getvoibe.com) for Windows** — a native app (not an Electron port) with the same custom Dictionary as the Mac build. Transcription runs through a private zero-retention cloud rather than on-device, because the fully local mode is Apple Silicon only. See [Voibe for Windows](https://www.getvoibe.com/resources/voibe-for-windows/) and [the best AI dictation apps for Windows](https://www.getvoibe.com/resources/best-ai-dictation-apps-windows/).

### Linux

This is the thin one, honestly. Voibe does not ship a Linux build, and neither do most of the commercial dictation apps in this category — the practical options are the open-source local ones. If you code on Linux, Cursor’s built-in voice mode plus an open-source Whisper front-end is the realistic stack; our [open-source dictation roundup](https://www.getvoibe.com/resources/best-open-source-wispr-flow-alternatives/) covers what actually runs there.

## Tools That Make Dictating in Cursor Easier

Four practical options for voice in Cursor, with the trade-off that matters for each:

- **[Voibe](https://www.getvoibe.com)** — system-wide and on-device, with Developer Mode workspace resolution and custom vocabulary. Works in every Cursor surface and every other app; your audio is never stored, sold, or used to train AI, with a fully on-device mode available (in on-device mode, nothing leaves your Mac). $199 lifetime or $9.90/month, free plan, 7-day free trial, no account. Best fit for daily coding-by-voice on Mac. See our [best dictation software for developers](https://www.getvoibe.com/resources/best-dictation-software-for-developers/) guide.
- **[Apple Dictation](https://www.getvoibe.com/resources/apple-dictation-review/)** — free and built into macOS. Fine for occasional use, but it has a session timeout, no custom vocabulary, and no workspace awareness, so technical identifiers need manual fixing.
- **[Wispr Flow](https://www.getvoibe.com/resources/wispr-flow-review/)** — polished cloud dictation with AI formatting, cross-platform. Capable, but it is cloud-based, so weigh that against dictating proprietary code. $144/year.
- **[Superwhisper](https://www.getvoibe.com/resources/superwhisper-review/)** — on-device Whisper modes plus optional cloud LLM cleanup and a flexible per-app mode system. $249.99 lifetime. A strong on-device alternative without dedicated IDE file resolution.
- **Cursor native voice** — built in and convenient for quick Agent prompts; scoped to the prompt, with the processing-location and reliability caveats above.

Using VS Code rather than the AI-first Cursor? See our companion [how to dictate in VS Code](https://www.getvoibe.com/resources/dictate-in-vs-code/) guide, which covers Microsoft's on-device VS Code Speech extension. For the broader picture of on-device versus cloud dictation, see our [cloud vs local dictation guide](https://www.getvoibe.com/resources/cloud-vs-local-dictation/) and [offline dictation privacy on Mac](https://www.getvoibe.com/resources/offline-dictation-privacy-mac/).

Dictation is one piece of a larger agent workflow. For how it fits alongside Claude Code, browser verification with Playwright MCP, and automated pull request review, see our [five-tool agentic engineering stack](https://www.getvoibe.com/resources/best-agentic-engineering-tools/).

Dictating into Cursor's terminal usually means dictating into Claude Code — our guide to [dictating in Claude Code](https://www.getvoibe.com/resources/dictate-in-claude-code/) covers its built-in /voice mode and the system-wide setup side by side, and the [terminal dictation guide](https://www.getvoibe.com/resources/dictate-in-terminal/) handles iTerm2, Warp, and Ghostty (including the Secure Keyboard Entry trap). That side of the workflow also has settings worth two minutes of your time: the [Claude Code privacy settings guide](https://www.getvoibe.com/resources/claude-code-privacy-settings/) covers the training opt-out (on by default for Pro/Max sign-ins) and the single env var that turns off its optional network traffic.

## Frequently Asked Questions About Dictating in Cursor

### Basics

**Can you dictate in Cursor?**
Yes. Cursor 2.0 has a native voice mode that fills the Agent prompt, and any system-wide Mac dictation tool types into every Cursor surface — the prompt, Cmd+K, chat, the editor, and the terminal.

**Does Cursor have built-in voice input?**
Yes, since Cursor 2.0. You hold to speak and the transcript drops into the Agent input. It is scoped mainly to that prompt and does not support @-mentions or model switching by voice, and Cursor has not documented whether transcription is on-device or cloud-based.

### Setup

**How do I dictate code and comments in the editor?**
Use a system-wide tool (Cursor's native voice targets the Agent prompt, not the editor). Put your cursor in the file, hold your hotkey, and speak — comments, docstrings, and Markdown all work, and Developer Mode resolves file names you mention.

**What is Developer Mode?**
A Voibe setting that detects your open Cursor or VS Code workspace and resolves spoken file names, folder names, and project terms to their exact spelling — so "user service" becomes userService.ts automatically.

### Privacy

**Is voice dictation safe on a proprietary codebase?**
Only if audio is processed on-device. Cloud tools transmit your voice — including file and function names — to a server. On-device tools like Voibe run the model locally so nothing leaves your Mac and dictation works offline.

### Workflow

**How should I voice-prompt the Agent and Composer?**
Speak in short, structured chunks: goal, files, constraints. Use the [Five-Part Voice Prompt framework](https://www.getvoibe.com/resources/voice-prompt-ai/) for a repeatable structure, and a system-wide tool so you can dictate the same way into Cmd+K and the editor.

## Start Voice-Prompting Cursor

Dictating in Cursor turns the slowest part of AI coding — typing out what you want — into the fastest. Set up a system-wide on-device tool, enable Developer Mode so your file names resolve, and dictate your Cmd+K edits, Composer changes, Agent tasks, comments, and commit messages. Cursor's native voice is a fine shortcut for quick agent prompts, but a system-wide tool covers every surface and keeps your code on your machine.

[Voibe](https://www.getvoibe.com) is the on-device option built for exactly this: [download it free](https://voibe.s3.us-east-1.amazonaws.com/releases/current/voibe.dmg) (7-day trial, no account), enable Developer Mode, and dictate your next Composer prompt instead of typing it.

**Keep going:**

- [How to voice-prompt ChatGPT, Claude, and Cursor](https://www.getvoibe.com/resources/voice-prompt-ai/) — the Five-Part Voice Prompt framework
- [The voice input workflow](https://www.getvoibe.com/resources/voice-input-workflow/) — the Talk-Draft-Polish loop for developers and writers
- [Best dictation software for developers](https://www.getvoibe.com/resources/best-dictation-software-for-developers/) — the full buyer's view
- [Getting started with Voibe](https://www.getvoibe.com/resources/getting-started-with-voibe/) — complete setup guide
- [How to dictate in VS Code](https://www.getvoibe.com/resources/dictate-in-vs-code/) — the editor companion
- [How to dictate in Linear & Jira](https://www.getvoibe.com/resources/dictate-in-linear-jira/) — voice ticket-writing
- [How to dictate in Slack](https://www.getvoibe.com/resources/dictate-in-slack/) — faster messages and replies
- [Speech to text on Mac](https://www.getvoibe.com/resources/speech-to-text-mac/) — the category overview
- [How to dictate in Microsoft Word](https://www.getvoibe.com/resources/dictate-in-microsoft-word/) — the Dictate button, and the paths that work without it

> **Tip:** Try this first: open Composer, hold your dictation hotkey, and say a two-sentence multi-file change with the file names spoken naturally. With Developer Mode on, the identifiers resolve and the prompt is ready to run — in a fraction of the time it takes to type.

## Frequently asked questions

### Can you dictate in Cursor?

Yes. You can dictate in Cursor two ways. Cursor 2.0 added a built-in voice mode that drops a transcribed prompt into the Agent input. Separately, any system-wide Mac dictation tool — like Voibe, Apple Dictation, or Wispr Flow — types into every Cursor surface: the Agent and Composer prompt, Cmd+K inline edits, the chat panel, the code editor itself, the integrated terminal, and commit messages. A system-wide tool works everywhere you'd type, not just the agent prompt.

### Does Cursor have built-in voice input?

Yes, as of Cursor 2.0 (shipped alongside Composer 2 in 2026), Cursor has a native voice mode. You hold to speak and release to transcribe, and the result drops into the Agent input. It is convenient for quick agent prompts, but users report it is scoped mainly to the prompt — it does not support @-file mentions, model selection, or mode switching by voice — and Cursor has not published whether its transcription runs on-device or in the cloud. For dictating code and comments in the editor itself, or for keeping audio on your machine, a system-wide on-device tool is the more complete option.

### How do I dictate code and comments inside the Cursor editor?

Cursor's native voice mode targets the Agent prompt, not the editor, so to dictate directly into a file you use a system-wide dictation tool. Place your cursor in the editor, hold your dictation hotkey, and speak — the text is inserted at the cursor like any keystroke. This works for code comments, docstrings, README and Markdown files, and commit messages. With Voibe's Developer Mode enabled, spoken file and folder names from your open workspace are resolved to their exact spelling automatically.

### What is Voibe Developer Mode and why does it matter for Cursor?

Developer Mode is a Voibe setting that detects your open Cursor or VS Code window and resolves file names, folder names, and project-specific terms from your workspace as you dictate. Without it, saying 'update user service' produces the literal words; with it, Voibe matches the actual file and inserts userService.ts. This removes the most common friction in voice-prompting an AI editor — getting it to reference the right files — so prompts like 'refactor the auth handler in userService and update its test' land with correct identifiers.

### Is it safe to use voice dictation on a proprietary codebase?

It depends on where the audio is processed. Cloud dictation tools send your voice — which often contains file names, function names, and architecture details — to a third-party server for transcription. On-device tools like Voibe run the speech model locally on your Mac's Apple Silicon, so audio and transcripts never leave the machine and dictation works with no internet connection. For confidential or proprietary code, on-device processing keeps your codebase inside your own security perimeter. Cursor has not documented whether its native voice mode is on-device or cloud-based.

### What is the best way to voice-prompt Cursor's Agent and Composer?

Speak in short, structured chunks rather than long run-on commands, which voice transcription handles poorly. State the goal, the files involved, and the constraints — for example, 'In Composer, update the checkout flow: add a loading state to the Pay button and disable it while the request is in flight.' Use a system-wide tool so you can dictate the same way into Cmd+K, chat, and the editor. For a repeatable structure, see our Five-Part Voice Prompt framework (Goal, Inputs, Constraints, Example, Output) in the voice-prompt AI guide.

### Which dictation tool is best for Cursor on Mac?

For Cursor specifically, the best fit is a system-wide tool with workspace awareness: Voibe runs Whisper on-device on Apple Silicon (or in a private, zero-retention cloud on any Mac) at $199 lifetime or $9.90/month (with a free plan), works in every Cursor surface plus every other app, and its Developer Mode resolves your project's file and folder names. Apple Dictation is the free built-in baseline but has a session timeout and no custom vocabulary. Wispr Flow and Superwhisper are capable alternatives; Wispr Flow is cloud-based, and Superwhisper offers on-device modes. Cursor's own voice mode is fine for quick agent prompts.

### What is the keyboard shortcut for Cursor's voice mode?

Cmd+Shift+Space on Mac starts and stops Cursor's voice mode; Ctrl+M is also reported as a shortcut, and there is a microphone icon in the chat input you can click instead. It is a toggle rather than a held key: press once to start recording, press again to stop. The transcript only appears after you stop, because Cursor shows a waveform rather than a live transcript while recording. Stopping does not send the prompt — press Cmd+Return for that.

### Why won't Cursor's voice mode submit my prompt when I say the submit keyword?

Because the feature is broken, not because you configured it wrong. Cursor lets you set a spoken submit keyword in settings, but as reported on the Cursor community forum against version 3.11.19, saying it "does nothing; the mic just keeps listening" even after several seconds of silence. The reporter notes this is a regression of an earlier issue that had been fixed in 2.0.32. The working sequence is to stop the recording with Cmd+Shift+Space and then send with Cmd+Return.

### Can I dictate in Cursor on Windows?

Yes. Cursor ships Windows builds for x64 and ARM64, and its native voice mode works there with the same Agent-prompt-only limit. For the other surfaces — Cmd+K, the chat panel, the editor, the terminal — you need a system-wide tool. Windows voice typing (Win+H) is the free baseline but has no custom vocabulary, so library and project names come out mangled. Voibe for Windows is a native app with the same custom Dictionary as the Mac build, transcribing through a private zero-retention cloud; the fully on-device mode is Apple Silicon only.

### Does Cursor have speech to text?

Yes, in two senses. Cursor's own voice mode is speech-to-text for the Agent prompt specifically: start it with Cmd+Shift+Space, speak, stop it, and the transcript lands in that one input. Any system-wide speech-to-text app also works in Cursor, and covers the surfaces the built-in mode does not — Cmd+K inline edits, the chat panel, the code editor itself, and the integrated terminal — because it inserts text wherever your cursor is, exactly like a keystroke.