How a spoken description becomes acceptance criteria, prompts, and a checked feature

From Spoken Spec to working feature is a short path only when the speech is structured, and structure is something you can impose while talking. Use four headings in a fixed order: who needs this, what they do today, what should happen instead, and how we will know it worked. Say each heading aloud before its content so the recording carries the shape as well as the words. This is the spoken equivalent of a form, and it stops the common habit of explaining the solution before stating the problem. A four-part spec that takes three minutes to speak will save an hour of discovery later, because the missing part becomes obvious while you are still talking.
Speak the problem before the solution, and say who has the problem. A sentence such as an invoice clerk retypes the same totals twice is worth more than a request for a computed column, because it names the person and the wasted action. When you jump to the solution, the prompts that follow inherit the assumption and nobody checks it. Give the current workaround a sentence too, since the workaround often reveals a constraint the design must respect. Then state the change in one sentence with a visible result. Three sentences, in that order, are enough to start, and the rest of the spec can grow from them.
Separate what is fixed from what is open while you speak. Fixed items are decisions you will not revisit this week, such as which screen the feature appears on or which roles can use it. Open items are questions with an owner and a date. Say each open item as a question rather than a worry, and write it down before continuing. A spec that mixes decisions and questions produces prompts that answer both at once, which is how a feature acquires opinions nobody agreed to. Naming the boundary between the two is the single most useful habit in a spoken spec.
Close the spoken pass with the smallest version that would still be worth shipping. Say it as one sentence: a reader can see the monthly total without adding the rows by hand. This sentence becomes the scope guard for every later step, because anything that does not serve it can be deferred without debate. Write the sentence at the top of the spec and read it before each prompt. When the feature grows, compare the new request with the sentence and decide deliberately whether the sentence should change. A spec without a smallest version has no way to say no, and a spec that cannot say no becomes a project.
Turn the spoken description into acceptance criteria while the recording is still fresh. Each criterion should name a state, an action, and a visible result, in the given, when, then shape the ear already knows. Write one criterion per sentence and number them, because numbers give the build and the review a shared reference. Keep the criteria free of implementation words: a criterion about what the user sees survives a rewrite, while one about which function runs does not. Aim for five to eight criteria on a feature of this size. Fewer usually means a state is missing; more usually means two features have been merged.
Test each criterion by asking whether two people would judge it the same way. The empty month shows a message is checkable; the empty month feels clear is not. When a criterion is vague, rewrite it with a specific value or a specific count. Read the rewritten version aloud and listen for the ambiguity, since hearing it is often faster than reading it. Add the data state the criterion assumes, such as a list with no records or a field with a very long value. A criterion without its starting state is half a criterion, and the missing half is where the disagreement will appear.
Put the criteria in priority order and mark the ones that block the smallest version. The first three should be enough to ship, and the rest should be improvements that can wait. This ordering protects the session when time runs short, because the pair or the individual knows exactly which checks must pass. Note any criterion that depends on another, since a dependency discovered late can make an otherwise simple step impossible. Keep the ordered list next to the smallest-version sentence so the scope and the checks are read together. Priority is what turns a list of wishes into a plan.
Confirm the criteria with the person who will use the feature before you prompt. A five-minute read-back catches the criterion that is technically correct and practically wrong, such as a message that appears but cannot be dismissed. Ask them to name the state they would check first, and add it if it is missing. Record their confirmation with a date and a name, so a later disagreement has a reference. This step feels like process and is actually the cheapest form of review available, because a user who corrects a criterion has saved you an entire build cycle.
Break the spec into steps that each produce a visible state, not into steps that each produce a file. A step is prompt-sized when one spoken request can describe it and one check can confirm it. Typical steps are the empty state, the populated view, the filter, the total, and the failure message. Write the step as a verb aimed at a result, then attach the criterion it satisfies. The mapping is what keeps the build honest, because a step with no criterion is either unnecessary or undeclared. Five to seven steps is a normal size for a feature that fits a session.
Order the steps so the riskiest one comes early. The risk is usually a dependency or an uncertainty, such as a field that may not exist or a layout that may not fit. Building the risky step first means a bad discovery arrives while there is still time to change the plan. Building it last means the discovery arrives after everything else assumes it. Say the order and the reason out loud before the first prompt, then keep the list where you can see it. An order chosen for convenience is fine; an order chosen by accident is how sessions end with a beautiful shell and no working core.
Give each step a stop condition and a rollback note. The stop condition is the criterion, and the rollback note is the one action that returns the project to the state before the step. For most steps the rollback is a revert, which is why small steps matter: a revert is cheap only when the step is small. Write both next to the step so a failure at step four does not require reconstructing steps one through three. This is the part of spec work that people skip when they are excited, and it is the part that makes a mid-session failure recoverable rather than terminal.
Keep the steps in a single list rather than a tree. A tree invites parallel work and hidden dependencies, while a list forces an order and makes progress visible. When a step reveals a new requirement, add it to the list with a note about where it came from rather than editing the spec silently. Review the list at the end of the session and move unfinished steps to the next one with their criteria intact. A list that survives a session is a better handoff than a paragraph of summary, because the next person can start at the top and continue.
Build each step backward from its acceptance check, writing the check first and the implementation second. The check is a sentence you can dictate: given the month has no records, when the page loads, then the empty message appears and the total is hidden. With Voiskey you speak that sentence at the insertion point in the test file, read the polished text, and confirm it names the same state the criterion names. Then prompt for the change. Working in this order means every line of code has a check waiting for it, and a step cannot be declared finished on the strength of a screenshot.
Run the check before the implementation and expect it to fail. A check that passes before the code exists is checking the wrong thing, and the failure message tells you whether the check can see what it claims to see. Read the failure aloud and compare it with the criterion; a mismatch here is a spec problem rather than a code problem. Fix the check first, then the code. This order costs one extra minute per step and prevents the situation where a green run is celebrated for a check that never exercised the feature. A check that cannot fail loudly is a check you will learn to distrust.
Build the smallest implementation that makes the check pass, then read the diff against the criterion. If the diff contains behavior the criterion does not mention, decide whether the criterion is incomplete or the behavior is unnecessary. Write the decision next to the step. This reading is the moment where a spec quietly grows, so naming the growth is what keeps the feature aligned with the smallest version. When the behavior is genuinely needed, add a criterion and a check in the same step rather than accepting it silently. The decision is the artifact; the code is only its current expression.
Before moving on, confirm the step's rollback still works. A revert that fails because the step touched a shared file is a trap discovered at the worst time. Test the rollback once on a small step, ideally the first one, so the habit is established before the session gets complicated. Then continue with the next step. A teammate who picks up the work should be able to download the branch, run the checks, and see the same passing and failing states you see. The download should be the only setup cost, and the checks should be the only explanation needed.
Hand off the spec, the criteria, the step list, and the feature together, because each one explains a different part of the work. The spec explains why, the criteria explain what counts, the steps explain how the build got here, and the code explains the current state. Keep them in one place and name the entry point in a single line. A reviewer who receives only the code will reconstruct a spec from the diff, and the reconstructed spec will match the code by definition, which makes the review circular. The documents are what give the review something independent to compare against.
Mark each criterion as met, partially met, or deferred, with a pointer to the check that proves it. A criterion marked met without a check is a claim, and claims are what a handoff should minimize. For deferred criteria, say why and who will pick them up. This table is the fastest way for a reviewer to see both the achievement and the gaps, and it prevents the pattern where the demo shows the happy path and the gaps surface in use. Keep the table short enough to read in a minute, or it becomes another document nobody opens. The table is short because every row points at evidence rather than at an explanation.
Include the prompts that mattered and the ones that failed. A prompt that produced a clean step is worth keeping as a pattern; a prompt that produced a wrong turn is worth keeping as a warning. Two or three of each is enough for a feature of this size. Do not paste every prompt, since a log of everything hides the few entries that carry a lesson. Name the file where the fuller record lives, so a reader who wants the detail can find it without searching. A handoff with the right two examples teaches more than a handoff with all of them.
Close by asking the receiver to restate the smallest version in one sentence and run one check. If they can do both, the handoff worked. If they cannot, the gap is in the documents rather than in the receiver, and the fix is a sentence or a check rather than a meeting. This test takes a few minutes and gives you a concrete signal about whether the spec survived the transition from speech to working feature. A feature is handed over when someone else can explain it and verify it, not when the branch is merged. That sentence is the handoff, and everything else is supporting material.
Voiskey is an AI voice typing app that works at the system level: press a shortcut, speak, and text appears at the insertion point in any app or text field. You can speak the spec into your notes and speak each prompt where you build, without moving between tools. It removes filler words, stutters, false starts, and self-corrections, and it adapts punctuation and formatting, so a spoken description arrives close to a usable structure.
It removes filler words, stutters, false starts, self-corrections, and grammar slips, and it adapts punctuation, formatting, tone, and phrasing to what you are trying to do. A spec spoken as given, when, then sentences therefore arrives as a short list rather than one long paragraph. It will not decide what the criteria should be, so say the structure aloud: who needs this, what happens now, what should change, and how you will check it.
Yes. Voiskey turns spoken requests into AI-ready prompts, including file names, paths, and commands. That helps when a spec names the file to change or the command that runs the checks. Because paths are easy to mishear, say each segment as a short phrase and pause between segments, then read the polished text before sending. For values that must match exactly, type the fragment and keep the surrounding sentence spoken.
The workflow is Speak-Polish-Type-Edit: speak the request, let the app polish it, the text is typed at the insertion point, and you edit in place. For a spec-to-feature build, that means speaking a criterion, polishing it into a check sentence, typing it in the test file, and editing one detail before running it. The same rhythm then carries the prompt that makes the check pass. Each step stays small enough to verify before the next one begins.

Download Voiskey for Mac and Windows and speak your spec straight into the build.
Use it across macOS, Windows, iOS, and Android