From Spoken User Story to Test Cases

Turn one spoken story into cases your team can actually run

Voiskey Voiskey Team
Voice Vibe CodingAI Code PromptsSpoken User Story

Speak the Story in One Breath

From Spoken User Story to test cases is a short trip if the story is spoken in one clean breath. Ask the story owner to say who wants the change, what they want to do, and why it matters, without slides or a ticket template. Record the answer as three sentences, then read it back and ask what is missing. A story that cannot be said in one breath is usually two stories, and splitting it early saves a week of unclear tests. Keep the spoken version next to the polished version so the original intent stays visible. Date the recording note.

Name the actor precisely. A role such as administrator, reviewer, or first-time visitor changes which cases matter. Ask the owner to describe the last real person who did this and what that person knew before starting. Write down the starting state: signed in, empty list, saved draft, or imported file. The starting state is where most test ambiguity hides, because two people can read the same action and imagine different beginnings. Speak the starting state as its own sentence and have the owner confirm it. A confirmed starting state turns a vague story into a testable one. Write it in one sentence.

Capture the value in the owner's words. Why does this change matter, and what happens today without it? The answer often reveals a workaround the team forgot to mention, and the workaround is a case in disguise. Write the value as one sentence and keep it with the story. When a later case is hard to justify, return to this sentence; if the case does not support the value, it can wait. A story with a stated value also gives the reviewer a way to judge scope, which is useful when a case starts to grow. Keep the value sentence short so it can be quoted in review.

Finish with a story card that fits on one screen. It has the actor, the action, the value, the starting state, and the definition of done in the owner's words. Read the card aloud and ask the owner to correct anything that sounds like a different request. If they add a condition, add it to the card instead of keeping it in conversation. The card is the source for every case you will dictate, and a clean card is the cheapest quality step in the whole process. A card that survives a read-aloud will survive a test review. Keep the card with the case set.

Pull Rules Out of the Spoken Story

Extract rules as statements with a condition and an outcome. Read the story sentence by sentence and ask what must be true for the action to succeed, and what should happen when it is not. Write each answer as a when-then sentence. Aim for five to nine rules for a normal story, and mark the ones the owner is unsure about. Rules that nobody can state are candidates for a conversation with the designer, not for a guessed test. Speak each rule into the list and review it at the insertion point before moving on. A rule list is easier to challenge than a paragraph of prose.

Separate business rules from interface rules. The business rule says a request over a limit needs approval; the interface rule says the approve button is disabled until a note is added. Both belong in the test set, but they are tested differently. Business rules belong in the case description, while interface rules belong in the steps and the expected screen state. Mixing them creates cases that fail for the wrong reason. Label each rule with its kind, and ask the owner to confirm the business rules while a designer confirms the interface ones. Two reviewers, two kinds of rules, one clearer case set.

Test the rules against the story for contradictions. If one rule says a field is required and another says the save works without it, the story has a gap. Bring the conflicting pair to the owner with both sentences quoted, and ask which one is right. Record the decision and the date. When a rule changes, find the cases that mention it and update them in the same change. Rules that live only in conversation will drift, and drifting rules are the main reason a test suite stops matching the product. A dated decision is easier to revisit than a remembered one. Review the rule list when the story is accepted.

Dictate Cases in Given-When-Then

Write each case with three spoken parts: given the starting state, when the action happens, then the expected result. Keep the given short and concrete, such as a signed-in reviewer with one pending request. Keep the when to one action. Keep the then to what a person can observe on screen or in the result. Dictate the three parts as separate sentences, then read them back as one case. This shape is easy to review and easy to automate later, because the parts map to setup, action, and check. Use the same shape for every case so the set reads like a list.

Cover the rules in a deliberate order. Start with the happy path that matches the story, then the boundary cases around each limit, then the failure cases for missing or conflicting input, then the permission cases. For each rule from your list, write at least one case and note which rule it covers. Stop when every rule has a case and the story's value is demonstrated. More cases are not automatically better; uncovered rules and duplicated cases are the real problems, and a coverage note shows which you have. A coverage note makes the gaps visible before a reviewer finds them.

Make the expected result observable. Saying that it works is not a result; saying that the request moves to the approved column and the button becomes unavailable is. Name the screen, the field, and the value. If the result includes a message, quote the message. If the result is a change in another view, say which view and what changes. Vague results produce tests that pass on a broken build, because the checker has nothing to compare. Speak the observable result slowly and check that a new teammate could confirm it without asking. The result sentence is the part reviewers read most closely. Write it before the steps so it cannot drift.

Keep the case set in the repository beside the code. Give each case an identifier, a title, the rule it covers, and the three parts. When a case is retired, mark it with the date and the reason instead of deleting it; a retired case often explains why a later change looks the way it does. Read the set aloud at the end of the session and fix any case that sounds like two cases in one. The deliverable is a set another person can run without the story owner in the room. That independence is the sign the spoken story became real tests.

Review Coverage With the Story Owner

Walk the owner through the cases in story order, not file order. Start with the happy path, then the boundaries, then the failures. Ask after each case whether it matches what they meant, and record their answer beside the case. Owners often spot a missing case in the first two minutes, before a detailed review begins. Keep the session to the story card and the case list, and leave the code out of the room. A review that stays in the owner's language produces corrections you can act on immediately. Read each case title aloud and let the owner interrupt.

Ask for the case they would add, not the case they would remove. The add question surfaces intent that the written story missed, while the remove question tends to start a scope debate. Write the suggested case, mark it as proposed, and decide later with the team. If the owner suggests three or more new cases, the story may need another round of rule extraction. Bring that observation to the session honestly; it is better to refine the story than to pad the case list with guesses. A proposed case is a useful note even when it is not built now. Name the rule it would cover so the gap is clear.

Capture review notes where the cases live. With Voiskey, speak the correction into the case file while the owner is still explaining it, and the text appears at the insertion point. It removes filler and false starts, so the note reads like the other entries. Download Voiskey before the session and test the shortcut once, because a tool that fails mid-review wastes the owner's time. The workflow is Speak-Polish-Type-Edit, and it fits a review where edits are small and frequent. Keep the note attached to the case identifier so nothing gets lost. Then read the changed case back to the owner for confirmation.

Close the review with a coverage statement. Say how many rules are covered, which cases are proposed, and which decisions remain open. Ask the owner to confirm the statement in one sentence. Attach it to the story card and the case set. A coverage statement is short, but it prevents the classic ending where everyone leaves with a different idea of what was agreed. When the next story starts, read the last statement first, because it often reveals a rule the new story inherits. Inherited rules are the easiest cases to miss and the cheapest to add. Keep the statements in one place for the whole project.

Keep Cases Current After Release

After release, run the case set against what shipped and note every mismatch. A mismatch is either a bug or an outdated case, and both need a decision. Record the case identifier, the observed result, and the decision in the same note. Speak the entry while the evidence is fresh, then clean it at the insertion point. Do not let a mismatch stay as a comment in a chat; move it to the case set or the issue tracker where the next person will find it. The first week after release is when the case set either earns trust or loses it. A trusted set is one people run without being asked.

Update cases when the story changes, not only when a test fails. A renamed field, a moved button, or a new required input all change the given and the then. Walk the case set with the change, edit each affected case, and mark the rule it covers. If a change removes a rule, retire the case with a date. Keeping cases aligned with the story card prevents the slow drift where tests pass but the product no longer matches what was intended. Alignment is a small weekly task, not a quarterly rescue. A short weekly pass costs far less than a large cleanup. Put the pass on the same calendar as the release review.

Use spoken updates to keep the set readable. Voiskey lets you press a shortcut in the case file, say the corrected result, and see the text at the insertion point. Say the screens and fields exactly as the product labels them, so the case matches what a tester will see. Download Voiskey for the person who owns the set, and make it part of the post-release routine. Readability matters because a case that is hard to read gets skipped, and a skipped case is worse than no case at all. A clean sentence is a form of maintenance. Keep each entry to the three parts and one coverage note.

Close each release with a short case health note. State how many cases ran, how many passed, which rules changed, and which cases were retired. Add one sentence about the next story that will inherit these rules. Download Voiskey and dictate the note from your notes, then edit it at the insertion point. Share it with the story owner and the tester, not only with the team lead. A health note that is read and corrected becomes the memory of the product, and memory is what keeps a case set alive. Date every health note and keep it under ten lines.

FAQ s

Voiskey is an AI voice typing app for desktop use. You press a shortcut, speak the story or a case in given-when-then form, and text appears at the insertion point in your notes or editor. It removes filler words and false starts, and adapts formatting, so the spoken story becomes a clean, reviewable case.

Yes. Voiskey learns names, jargon, acronyms, and spelling preferences, so a field label or screen name stays stable once you use it in a real sentence. Say each new label clearly the first time and check it at the insertion point. A team plan adds shared vocabulary and workflows for a group writing cases together.

Say the starting state, then the single action, then the observable result, as three separate sentences. Voiskey adapts punctuation and formatting to the task, so the three parts arrive as a readable case. Review each sentence at the insertion point before adding the next, and keep the result concrete enough to confirm without asking.

Voiskey supports 100+ languages and translation. You can dictate the case in one language and ask for another version, then read the result at the insertion point. Keep field labels and screen names unchanged, and check that the translated case still states one action and one observable result.

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 speak each test case at your cursor.

Use it across macOS, Windows, iOS, and Android

Use it across