Dictating Multi-Step Instructions to a Coding Agent

A step-by-step method for speaking ordered instructions and checking results

Voiskey Voiskey Team
Voice Vibe CodingAI Code PromptsDictating Multi-Step Instructions

Break Work Into Ordered Steps

Dictating Multi-Step Instructions to a coding agent works best when you stop thinking of the request as one sentence. A multi-step task is a short procedure, and a procedure needs an order, an owner for each step, and a check before the next step begins. Before you speak, list the steps on paper in the sequence you would explain them to a new teammate. Aim for three to seven steps; fewer usually hides a missing decision and more usually needs to be split into two sessions. Read the list once, correct the order, and only then start speaking.

Name each step with a verb and an object so the sequence is unambiguous. Create the settings row, wire the row to the store, add the empty state, and update the check are four steps that cannot be confused with one another. Avoid vague steps like handle the rest or clean things up, because they hide decisions the agent will make on your behalf. If you cannot name a step with a verb and an object, it is probably a note to yourself rather than an instruction. Move notes out of the sequence and keep the sequence for actions only.

Decide where the human checkpoints belong before you dictate. A checkpoint is any step where a wrong result would make the next step pointless or expensive. Shared state, public interfaces, and the shape of returned values usually deserve a checkpoint. Cosmetic details usually do not. Mark each checkpoint on the list with a short note about what you will inspect. When you speak the sequence, say checkpoint out loud at those points so the agent pauses and so you remember to look. Without explicit checkpoints, multi-step work tends to run to the end before anyone notices the second step was wrong.

Write the sequence in a scratch note before you speak it, even if the note is only five lines. The note is your reference when a step fails and you need to resume without repeating the whole request. Keep the step numbers stable; if you insert a step later, give it a letter rather than renumbering everything. Stable numbers make it possible to say go back to step three without ambiguity. When the session ends, the note becomes the outline of your handoff. A sequence you can point to is much easier to debug than a paragraph you have to reread from the top.

Prepare Names, Paths, and Commands

Collect the names, paths, and commands before the first spoken step. Multi-step work fails most often at a step that depends on an exact string, such as a route, a function name, or a build command. Put every exact string in the scratch note next to the step that uses it. Say the exact string once slowly when the step begins, and paste it if it is long or contains symbols. This preparation turns a fragile dictation into a reliable sequence, because the parts that cannot be guessed are already resolved before you start talking. Exact strings are where dictation most often goes wrong, so they deserve this attention.

Introduce each name with its role the first time you use it. Say the settings panel component, not just the panel. When a later step refers to the same thing, the short name is safe because the role has already been established. If two names sound alike, add a distinguishing word and keep using it. Ambiguous names are especially dangerous in multi-step work because an error in step two may only surface at step five, and by then the cause is hard to find. A clear name at the start saves a long hunt at the end. Established roles are what let short names stay safe later.

Speak commands as separate sentences and never bury one inside a description. Run the check, then read the output is two instructions, not one. When a command includes flags or arguments, say them in the order they appear in the help text, and pause before and after the command so the app does not merge it into the surrounding prose. If a command is long, paste it. The goal is a transcript where every command is visibly distinct from the explanation around it, because a merged command is the most common reason a multi-step prompt produces an unexpected result.

Keep a small glossary for the project and update it after every session. The glossary lists the names the project uses, the paths that recur, and the commands that are easy to mistype. Read it before a session that touches unfamiliar areas, and add new entries while the context is fresh. Over time the glossary becomes the part of the workflow that makes dictation reliable across people, since a new teammate can speak the same names without guessing. A shared glossary is also the easiest way to keep a team's spoken instructions consistent. A glossary also shortens the next session, because nobody has to rediscover the names.

Dictate Step by Step With Checkpoints

Dictate one step at a time and wait for the result before speaking the next. This is the core discipline of multi-step work, and it is also the hardest habit to keep when the sequence is clear in your head. Speaking ahead feels efficient, but it removes your ability to catch a wrong turn early. Wait, read the diff, and confirm the step did what you intended. Then say next step and continue. The pause costs seconds and prevents the cascade where every later step builds on a mistake you did not see. One step at a time is slower to say and faster to finish.

Open each step with its number and its verb so the agent knows exactly where it is. Say step two, wire the row to the store, then the constraint, then the check for that step. Repeating the number is not redundant; it anchors the instruction to the written sequence and makes a later correction easy to phrase. If the agent asks a clarifying question, answer with the step number in the reply. This keeps a long procedure navigable and prevents the drift that happens when instructions arrive without a shared index. An indexed step is easy to correct, while an unindexed one invites a rewrite.

Pause at every checkpoint you marked and inspect before continuing. At a checkpoint, say checkpoint and then describe exactly what you are looking at, such as the shape of the returned value or the label on the new row. If the result is wrong, stop and fix it before the next step; do not let a small error travel. If the result is right, say confirmed and move on. Spoken confirmations create a clean record of which steps were verified and which were assumed, which matters a great deal when you resume later. The checkpoint is where a spoken sequence earns its reliability.

Handle a failed step with a short, local correction rather than a restatement of the whole sequence. Say the step number, what went wrong, and what you want instead. Keep the correction to the step where the failure occurred, and only revisit earlier steps if the failure clearly started there. This localization is what makes multi-step dictation practical, because a long sequence with one bad step does not require a full replay. After the fix, repeat the check for that step before continuing to the next. A local fix also keeps the written sequence valid for the next person.

Verify Each Step Before the Next

Verification is what turns a spoken sequence into finished work. After each step, run the smallest check that can fail, and record the result next to the step number in the scratch note. A step without a check is an assumption, and a sequence built on assumptions is fragile no matter how well it was dictated. If you use Voiskey, the spoken confirmations land at the insertion point and become part of the note automatically, which makes the record easy to keep without extra typing. Verification should be routine, not ceremonial. Verification is the habit that keeps a spoken sequence honest.

Choose checks that are cheap enough to run after every step. A unit check, a manual look at the rendered output, or a quick query against the interface is usually enough at the step level. Save the full suite for the end of the sequence. The point of step-level checks is early detection, not complete coverage, so a fast check that catches the common failure is more valuable than a slow one you skip under pressure. Write the check into the step before you speak it, so you never have to invent a verification method mid-session. A cheap check that runs every step beats a thorough one that runs rarely.

Record failures with enough detail to reproduce them later. Note the step number, the expected result, the actual result, and the smallest input that shows the difference. If the failure only appears with a particular name or path, include it. This record is more useful than a general sense that the step felt wrong, because it can be replayed after a fix. When you download the latest Voiskey build, rerun the recorded failures to confirm the fix and to notice whether the new version changed anything unexpected in the sequence. A failure you can replay is a failure you can actually close.

Close the verification loop by comparing the whole sequence against the original goal. Step-level checks can all pass while the assembled result misses the intent, so reserve a final check that exercises the feature end to end. Walk through it as a user would, and write down any difference between what you expected and what you saw. If the sequence is sound but the intent is off, the failure is in step design rather than execution. Fix the sequence before the next session, and keep the end-to-end check as the last line of the note. An end-to-end check is the only one that sees the assembled feature.

Recover and Resume Multi-Step Work

Multi-step work will be interrupted, so design the resume path before you need it. The resume path has three parts: the step that last passed its check, the step that was in progress, and the next action. Keep those three lines at the top of the scratch note and update them as the sequence advances. When you return after a break, read them before you speak. This costs under a minute and prevents the most common resume error, which is repeating a step that already succeeded and creating a duplicate change. The note is the difference between a verified sequence and a hopeful one.

Resume by re-running the check for the last passed step before continuing. A passing check tells you the state is what the note claims; a failing check tells you something changed while you were away. Do not skip this confirmation, even when the break was short. Code, dependencies, and open files can all shift between sessions, and a stale assumption is worse than a slow restart. Once the check passes, say the next step number and continue from there, keeping the original numbering intact. A confirmed starting point makes every later step cheaper. That confirmation is the cheapest insurance in the whole procedure.

Keep a short log of which steps were skipped and why. Some steps are genuinely unnecessary for a particular change, and skipping them is fine as long as the skip is recorded. An unrecorded skip looks identical to a forgotten step when the next person reads the note. Write one line: step four skipped, not needed for this path. The log also helps you notice patterns, such as a step that is skipped so often it should become optional in the standard sequence. A recorded skip is a decision, while an unrecorded one is a risk. Write the skip down before you move on.

End a multi-step session by writing the handoff in sequence form. List the steps, their check results, the skipped steps, and the single next action. If the sequence will be repeated, save it as a reusable procedure and note where the checkpoints are. A handoff written in the same order as the work is far easier to follow than a summary written as prose. The next person should be able to start at the next action without reconstructing the whole session from memory. A sequence-shaped handoff is the fastest way to restart work. The next session should begin with action, not archaeology.

FAQ s

Voiskey works at the system level in your code editor: press a shortcut, speak a step, and the text appears at the insertion point. It removes filler words, stutters, false starts, self-corrections, and grammar slips, and it adapts punctuation and formatting to the task. You can speak one step, wait for the result, then speak the next, which keeps a long sequence easy to follow.

Collect the names, paths, and commands the sequence will need and put each one next to the step that uses it. Mark the human checkpoints, keep the step numbers stable, and write the sequence in a scratch note before you speak. Say exact names once slowly, and paste long paths or commands so the transcript stays accurate. Preparation is what keeps a spoken procedure reliable.

When you say checkpoint or confirmed, Voiskey places that text at the insertion point, so the spoken confirmation becomes part of your scratch note without extra typing. It removes filler words, stutters, false starts, and self-corrections, so the record stays readable. Each step can carry its own confirmed or failed line, which makes the sequence easy to resume after an interruption.

Each spoken step appears at the insertion point in whatever app or text field you are using, including your code editor. Voiskey turns spoken requests into AI-ready prompts, including file names, paths, and commands, and it learns names, jargon, acronyms, and spelling preferences. It supports 100+ languages and translation, so you can speak the sequence in the language you think in.

Say less. Get more
Say less. Get more
Say less. Get more
Say less. Get more
VoiskeyVoiskey

Your voice, amplified.

Download Voiskey for Mac and Windows and dictate ordered steps one at a time.

Use it across macOS, Windows, iOS, and Android

Use it across