Voice typing patterns for Claude Code on Mac

THE PATTERNS

Seven prompts that show up every morning

Seven voice prompt patterns recur every morning when Halopen users dictate into Claude Code on Mac: the migration spec, the file-path-first prompt, the error-message paste-and-explain, the test-contract prompt, the multi-file refactor, the rollback-safe migration, and the read-only audit. Each one fits a recurring shape of work — Supabase migrations, AVAudioEngine refactors in Swift, Xcode build errors, pre-commit reviews — and each one rewards voice because the constraint clauses are free to include.

The flagship piece on voice typing for Claude Code makes the case for why spoken prompts beat typed ones. This piece is the muscle memory — the seven prompt shapes that recur day after day in a real Claude Code morning, and the voice-shaped pattern that wins each one.

The patterns are not templates. They’re not phrasings to memorize. They’re the rhythm of how you actually talk through a piece of work when an engineer is sitting next to you, applied to the prompt input where Claude is doing the work. Once the function key is under your hand, the patterns stop being patterns and start being how the morning sounds.

A note before the list: every example below comes from real Claude Code sessions on the Halopen codebase. None of them are constructed for the post. The agent ran on each one and produced a diff that shipped or got close enough to ship that one round of cleanup finished it.

PATTERN 1

The migration spec

The most common first-prompt-of-the-morning is a database migration. Add a column. Add a table. Add a row-level security policy. Each one has a recognizable shape: schema, identifiers, constraints, the trigger or policy that goes with it, and the test or rollback path. Typed, that shape compresses into “add a customers table to the meria schema.” Spoken, it expands to the spec Claude can execute on the first pass.

The pattern is schema + columns + constraints + side artifacts (triggers, policies, indexes) + the migration file path. Five clauses. Each one stops a different class of misread.

PATTERN 2

The file-path-first prompt

When the work is “go look at this file and do something to it,” the prompt that wins names the file path before the verb. Claude Code reads the file the moment it sees the path; the rest of the prompt then operates on a file the agent has already loaded. The shape is path + selector + change + constraint.

The trick to dictating file paths is to speak them the way you read them. Slashes are pronounced “slash.” Dots inside filenames are pronounced “dot.” Dashes are “dash.” Halopen’s cursor-context biasing prefers the directory tree and the casing of paths already in the buffer, so common identifiers land in the right idiom. For unusual segments, watch the live partial and spell out the misread mid-sentence.

PATTERN 3

The error-message paste-and-explain

When something is broken, the prompt that wins to Claude Code is the error message itself, pasted first, then the spoken context. Pattern is paste error → hold fn → “this happens when… I’ve already tried… don’t refactor X.” Three short sentences. Twenty seconds.

The reason this pattern matters is that the error string is the keyword Claude needs to find the right region of the codebase. The spoken context is what stops the agent from over-correcting. Without the context, Claude proposes a refactor; with the context, Claude proposes the surgical fix.

PATTERN 4

The test-contract prompt

When the work is to add a feature, the prompt that wins names the test before the implementation. Pattern is what the test should do → where the test should live → the implementation that makes the test pass. The test contract pins the agent’s interpretation of “feature” — Claude can’t drift toward a plausible-but-wrong shape if the test is the contract.

This pattern is hard to type because the test is the longest clause and the implementation is the shortest. Engineers under typing cost lead with the implementation; spoken prompts lead with the test because saying it first feels natural. The agent reads the test as the spec.

PATTERN 5

The multi-file refactor

When the work touches three or more files, the prompt that wins is the multi-clause spec. Pattern is change + scope + architectural constraint + test contract + negative constraints. The full case for this shape sits in the Cursor Composer companion; the same shape works in Claude Code’s terminal because the agent’s interpretation of intent is what’s load-bearing, not the surface.

What changes between Cursor Composer and Claude Code is the file enumeration. Composer infers the file set from the workspace; Claude Code wants the paths spoken or accepts a glob. Pattern in Claude Code: name the files explicitly, or name the directory and let the agent enumerate.

PATTERN 6

The rollback-safe migration

When the work is a database migration on a production schema, the prompt that wins names the rollback before the change. Pattern is forward migration + rollback statement + verification query + the safety clause that prevents data loss.

This is the pattern engineers leave out under typing cost — the rollback gets written later, or doesn’t, and the migration ships without one. Spoken, the rollback is one extra clause; the cost is twenty seconds of articulation; the value is a migration that’s safe to revert.

PATTERN 7

The read-only audit

The last pattern is the prompt that asks Claude Code to look at something without changing it. Pattern is scope + question + format of answer + the prohibition on edits. The agent’s instinct is to fix what it sees; the prohibition keeps it in read-only mode.

This pattern is the one I run before every commit. Look at the diff. Tell me what’s risky. Don’t edit anything. Spoken, it’s eight seconds; typed, it’s the kind of meta-prompt that gets skipped because the friction of typing it exceeds the time saved by running it.

UNDER THE HOOD

Why the patterns hold across surfaces

The patterns above all rest on the same architectural choice in Halopen: the dictation pipeline is system-wide. The function key is detected by a session-level event tap; the audio is captured by AVAudioEngine; the live partial is rendered by Apple’s on-device speech recognizer; the final pass streams to Halopen’s transcription edge function. The text lands at the cursor through the macOS Accessibility API, which every Mac terminal accepts as standard input. The same hotkey behaves identically in Claude Code, Cursor, Aider, Continue, and every other terminal-based agent on macOS.

That architecture is why the patterns hold. The migration spec works in Claude Code’s terminal because Claude reads the verbatim text Halopen lands at the prompt input; the same spec works in Cursor’s Cmd+I Composer because Cursor reads the same verbatim text. The wedge isn’t the integration; it’s the absence of one. Halopen doesn’t know which agent is reading the prompt. The agent reads exactly what was said.

The full engineering walk-through — live-preview self-correction, cursor-context biasing, the audit log of every cloud call — is in the Claude Code flagship. The whole verbatim contract is what makes the patterns ship-grade — what was said is what arrives at the cursor.

QUESTIONS

Frequently asked questions

Hold the function key. Say the next prompt the way you’d dictate it to an engineer.

The patterns are not a checklist; they’re the shape of the morning once the function key is under your hand. Say the migration the way you’d describe it to a teammate. Say the file path the way you read it. Say the error message context the way you’d explain it to the person sitting next to you. Claude reads the verbatim text Halopen lands at the prompt input, and the constraint clauses you used to skip start coming back. The diff quality follows.