Voice dictation for Claude Code and Cursor

Explaining a coding task can take longer than making the change. The difficulty is not getting words onto the screen. It is giving the agent enough context without losing the exact details.

Voice is useful for the full thought. The keyboard is still useful for the parts where one character matters.

The short answer

Speak goals, background, constraints, edge cases, and the result you want. Type or paste commands, code, paths, URLs, credentials, version numbers, and exact identifiers.

Claude Code and Cursor both have built-in voice input. Start there when the prompt stays inside one tool. Use Cue when you want one voice-input layer across Mac apps, an on-device transcription option, or a workflow that begins in a note and continues somewhere else.

In every case, review the transcript before the agent acts.

Built-in or system-wide

There is no universal winner. Choose the narrowest input method that fits the job.

| Need | Better starting point | Why | | --- | --- | --- | | One prompt inside Claude Code | Claude Code voice dictation | It is already in the terminal tool, with hold and tap recording modes. | | One prompt inside Cursor Agent | Cursor voice input | It is already in the Agent prompt field. | | The same voice layer across Mac apps | Cue | The dictation workflow follows the text cursor instead of belonging to one coding tool. | | Exact syntax or a one-line edit | Keyboard or paste | Exact characters are easier to inspect and control. | | A long explanation with several constraints | Voice, then review | Speaking can capture the whole thought before you shape it. | | A thought that should remain useful later | A Markdown note | Keep the context outside one temporary prompt. |

As of August 24, 2026, Anthropic documents voice dictation in Claude Code, and Cursor documents voice input in its Agent prompt field. Cue is not a replacement for those built-in microphones when they already solve the job.

Cue is useful when the boundary is wider. A task may begin as a note, continue as a prompt in Cursor, turn into a review request in Claude Code, and end as a message. One system-wide dictation layer keeps the input gesture consistent across those surfaces.

For the wider product idea, read Voice input should work like a keyboard.

Speak vs type

A coding agent needs two kinds of information.

The first is intent: what should change, why it matters, what must stay the same, and how you will judge the result. This is usually natural to speak.

The second is exact state: a filename, command, error, selector, version, regular expression, or line of code. This is usually safer to type, paste, attach, or reference directly.

A practical split looks like this:

Speak the goal.
Speak the background and user impact.
Speak the constraints.
Speak the important edge cases.
Speak what proof you expect.
Type or paste file paths, commands, URLs, code, secrets, and exact identifiers.
Attach logs, screenshots, diffs, or files instead of reading them aloud.

Cursor supports explicit context through @ mentions for files, folders, terminals, chats, diffs, and browser state. Use that when the source itself matters. Saying “look at the authentication file” is weaker than attaching or typing the exact file reference.

The rule is simple:

Speak to express the full thought. Type to make the precise correction.

Prompt framework

Use seven parts when the task is more than a quick question.

Goal — What should change?
Context — Where is the problem, and why does it matter?
Inputs — Which files, screenshots, logs, or data should be used?
Constraints — What must remain unchanged?
Edge cases — What could fail?
Proof — What should be tested or shown?
Output — Do you want a plan, an explanation, a minimal diff, or a completed change?

You do not need to announce the labels while speaking. They are a check that keeps a prompt from becoming a long transcript with no decision inside it.

Here is a complete example:

Update the onboarding screen so the next action is obvious. New users currently see three buttons with similar emphasis, and support has to explain which one to choose. Inspect the existing screen before editing. Use the current design tokens and preserve the authentication flow. Check the empty, loading, and returning-user states. Show me the smallest safe change, run the focused UI tests, and summarize what you verified.

After dictating, add the exact screen file or screenshot with the tool's normal context controls. Then read the final prompt once.

Longer is not automatically better. Include the context that changes the work. Remove the rest.

Real workflows

Debug a reproducible problem in Cursor

A rough spoken prompt often starts like this:

The login is broken after the last change. Can you fix it?

The agent has to discover what “broken” and “last change” mean. A more useful prompt gives it the symptom, boundary, evidence, and proof:

Fix the login loop that happens after an expired session is refreshed. The user signs in successfully, reaches the dashboard for a moment, and is sent back to the login screen. Inspect the session-refresh path before editing. I will paste the exact error and attach the relevant network trace. Preserve the existing provider flow and do not change unrelated authentication UI. Cover a valid refresh, an expired refresh token, and a network failure. Make the smallest safe change, run the focused authentication tests, and explain the cause.

Now type or attach the exact log, route, and file references. In Cursor, use the prompt field's @ context when you know the relevant file, terminal output, diff, or prior chat.

Voice handled the explanation. Cursor's explicit context handled the evidence.

Plan a change in Claude Code

Voice is particularly useful when you want Claude Code to understand the shape of a task before it edits.

Plan a small change to the account settings screen. The current save action gives no visible feedback, so users click it twice. Inspect the existing component and its tests before proposing anything. Preserve unrelated work in the repository. Do not change the API contract or add a new dependency. Consider a slow request, a failed request, and a second click while saving. First give me a short plan. After I approve it, make the smallest change and run only the focused tests.

Type or paste exact paths, commands, and version numbers after the transcript appears. If the prompt contains a negation such as “do not change,” check that line carefully before pressing Enter.

Claude Code's current built-in dictation supports mixing voice and typing in the same prompt. Its official documentation says hold mode can insert a transcript without sending it by default; tap mode is designed to submit after the second tap. Check your configured mode before relying on a pause for review.

Carry context between tools

Some thoughts do not belong to one prompt.

Suppose you notice a recurring bug while reviewing a support message. Dictate the observation into a Markdown note:

Password-reset failures appear to share one pattern: the user opens an older email after requesting a second link. We should inspect whether issuing a new token invalidates the first one, confirm the intended behavior, and add a user-facing message for an expired link. Do not assume this is the cause until the logs confirm it.

Then tighten the note:

Add the exact support ticket or error reference.
Remove personal or unnecessary customer information.
Add the repository and feature boundary.
List what evidence is still missing.
Write the decision you need from the agent.

Later, bring that note into Cursor or Claude Code by attaching it, pasting the relevant section, or using an approved connection. Cue Notes can keep the text as readable Markdown. Cue's Model Context Protocol page describes the separate, opt-in setup that lets compatible external agents read allowed Cue context.

Dictation does not move the context automatically. Cue MCP is not required for dictation, and it is not a proprietary Claude Code or Cursor integration. The user chooses what is saved, attached, pasted, or exposed to an agent.

Privacy and connection

Voice input is not one privacy mode.

Claude Code's official documentation says its built-in voice feature streams recorded audio to Anthropic's servers for transcription. It also lists current account, version, and environment requirements. If those requirements fit your workflow, the built-in option is direct and convenient.

Cursor's official prompting guide confirms voice input and recommends reviewing the transcript. That page does not explain enough about transcription processing or retention to make a local-versus-cloud claim here.

Cue offers both on-device and cloud transcription choices. Select an on-device model when you want the transcription step to remain on the Mac. Select a cloud model only when you want that connected processing. Review Cue's current model and data-handling settings before using sensitive material.

The next boundary is the agent itself. A locally transcribed prompt can still be sent to Claude Code, Cursor, or another model when you submit it. Local transcription does not make the rest of the workflow local.

Cue MCP is a separate connection. It requires explicit registration and gives compatible agents access to the Cue vault through that configured interface. Do not register it merely to dictate a prompt.

For current Cue setup and model choices, read Free voice-to-text for Mac and the Cue dictation page.

When typing is better

Use the keyboard, paste, or a direct attachment for:

terminal commands;
code and regular expressions;
URLs and file paths;
credentials and private identifiers;
package and operating-system versions;
tiny corrections;
final formatting;
work in a noisy or shared space.

Speech recognition can produce a plausible-looking character or name that is still wrong. A spoken path can also lose punctuation or capitalization that the tool needs.

Voice is strongest when the task needs explanation. Typing is strongest when the task needs exact characters.

Limitations

Voice will not repair a vague task by itself. A long transcript can still omit the relevant file, hide the actual error, or mix several jobs together.

Built-in voice can also be the better choice. If you only need to speak one Claude Code prompt or one Cursor Agent prompt, adding a system-wide app may create more setup than value.

Cue is currently a Mac product. App-specific text fields, terminal behavior, permissions, and shortcuts can vary. Test the exact surface you use before making voice the default for an important workflow.

Finally, review before sending. Pay special attention to names, numbers, negations, paths, and the definition of done.

FAQ

Does Claude Code already support voice dictation?

Yes. As of August 24, 2026, Claude Code documents hold and tap recording modes, mixed voice and typing, supported versions, and Claude.ai-account requirements. Anthropic also states that the audio is streamed to its servers for transcription.

Does Cursor already support voice input?

Yes. Cursor's current Agent prompting guide includes a microphone in the prompt field, and its April 2026 changelog describes upgraded voice input. Review the transcript and add exact files or other context with Cursor's normal attachment and @ tools.

Does Cue integrate directly with Claude Code or Cursor?

Cue can insert dictated text into ordinary Mac text-entry surfaces, including coding tools. That is system-wide input, not a proprietary integration. Cue also has a separate, explicit MCP setup for compatible agents that you choose to connect.

Should I speak code aloud?

Usually not. Speak the intention, constraints, edge cases, and expected result. Type, paste, or attach exact code, commands, paths, URLs, identifiers, and secrets.

Can I use local transcription for coding prompts?

Cue offers on-device transcription choices. That can keep the transcription step on the Mac. Submitting the resulting text to a cloud coding agent is a separate data boundary, so review both the Cue mode and the agent's current data handling.

Sources

All sources rechecked August 24, 2026.

Try the workflow

Download Cue for Mac when you want one voice-input layer across prompts, notes, messages, documents, and the work that continues after transcription.

Start with one prompt. Speak the goal, context, constraints, edge cases, proof, and output. Type the exact details. Read it once. Then send it.