Turn spoken failure cases and error paths into prompts your editor can act on

Prompting for Tests and error handling by voice begins with the failure you are actually afraid of, not with a general request for coverage. Say the scenario out loud in one sentence: when the month filter has no matching records, the page should show an empty state and no totals row. That sentence is already a test case, and it is easier to dictate than to type because it describes behavior rather than syntax. Ask for the test first and the implementation second, so the prompt produces a failing check before it produces a change. This order matters more than any phrasing trick, because a test written after the code tends to describe what the code does instead of what the user needs.
Name the failure in the voice of the person who would experience it. A user sees a blank screen, a wrong total, or a button that does nothing; a developer sees an exception, a null value, or an unhandled branch. Translate between the two in the prompt: the user sees a blank screen when the list is empty, so the component should render an explicit message. This translation is the part most often lost when people type quickly, and it is the part speech handles well because you can narrate the scenario as a short story. Keep the story to three beats: the setup, the action, the expected visible result.
Pick the smallest failure worth testing today and resist the urge to enumerate everything. One prompt, one scenario, one expected result is the rhythm that keeps a spoken request clean. If you try to describe six edge cases in one breath, the polish step will merge two of them and the test will check neither properly. Instead, speak the first case, send it, watch the test fail for the right reason, then speak the next. This sequencing produces a suite you can trust because each test was born from a deliberate sentence and verified in isolation. It also keeps the session moving at the speed speech is supposed to offer.
Write the feared failure into the project notes before you prompt, so the scenario survives the session. A line that says empty month filter must show a message and hide totals is enough; it does not need a paragraph of context. When you return the next day, the line is a ready-made spoken prompt. When a teammate picks up the work, it is a shared definition of done rather than a private concern. The notes also stop the quiet drift where a prompt asks for behavior that contradicts a test written last week. Five seconds of writing protects an hour of work.
Speak each case in a given, when, then pattern and let the app shape it into a prompt. Say given a list with no records for the selected month, when the page loads, then the table shows the empty message and the total is hidden. The pattern works by voice because each clause is short and the order is fixed, so you never have to hold the structure in your head while also choosing words. It also produces a test that reads like a requirement, which is exactly what a reviewer needs. Repeat the pattern for the next case rather than compressing two scenarios into one sentence.
Use concrete values instead of placeholders whenever the value is easy to say. A test with a real month, a real count, and a real label is more useful than a test with an abstract input, and it is easier to speak because you are describing something specific. Say three invoices dated March rather than some records with dates in the selected range. When a value is long or exact, such as an identifier or a formatted string, type that fragment and speak around it. This is the same split that works for ordinary code prompts: speech carries the scenario, keys carry the characters that must match.
Name the test after the behavior, and say the name first. A name such as shows empty message when month has no records tells the next reader what the case protects and gives the prompt a clear anchor. Speaking the name before the case also forces you to commit to one behavior, which prevents the common failure where a spoken test drifts between two concerns. If the name needs the word and twice, the case is probably two tests. Split it, speak the first, and keep the second for the next prompt. Naming is the cheapest form of review available while you dictate.
Ask for the assertion explicitly, because a test without one is a demonstration rather than a check. Say the assertion as a sentence about the visible result: the empty message is present and the totals row is absent. Avoid describing internal calls unless the behavior cannot be observed from outside, since internal assertions tend to break on refactors that do not change what a user sees. When you must assert on an internal value, say why in the same breath so the reason is captured. Two assertions are better than five, and one is better than two when it names the visible outcome. A spoken prompt that includes its own justification is easier to review later than a bare line of expectation.
Dictate error handling as a set of named paths rather than as a vague request to handle failures. Say the path, the trigger, and the visible result in one sentence: when the record request fails, the panel shows a retry message and keeps the previous list visible. Then repeat for the next path. Naming each path turns an open-ended task into a checklist, and a checklist is what speech is good at carrying. It also prevents the pattern where an assistant adds a single generic catch block and calls the work finished. The prompt should make it obvious when a path has been skipped.
Separate the message from the mechanism. The mechanism is how the failure is detected, such as a rejected request or a missing value; the message is what the user reads. Speak the message in the user's language and keep it short enough to fit the space where it appears. Then say what the user can do next: retry, go back, or continue with partial results. If the message must include a value, such as a count or a date, name that value in the prompt rather than leaving it to be invented. A message without a next action is usually a dead end, and a dead end is a failure the test should catch.
Decide where errors should be visible before you prompt, because visibility is a design choice rather than an implementation detail. A form error belongs next to the field; a page-level failure belongs at the top of the content area; a background failure may belong in a small status line. Say the location explicitly in the prompt and add it to the acceptance check. Write the chosen location into the test sentence so the assertion checks placement, not only wording. If you skip this, the result often places every message in the same banner, which is technically handled and practically unhelpful. Location is the detail that makes an error path feel designed rather than patched on at the end.
Give every error path a test, and speak the test in the same session as the prompt. The pair is small: one prompt for the behavior, one prompt for the check, both phrased in the same words. Keeping them together means the test uses the message you just specified rather than a paraphrase invented later. It also gives you an immediate signal, since a test that fails for the wrong reason points at a mismatch between the two prompts. A path without a test is a promise, and promises are what accumulate when a session runs long. When the pair passes, you can move on with confidence instead of carrying an untested branch into the next feature.
Run the suite after every few prompts and read each failure aloud before changing anything. Reading forces you to say what the test expected and what happened, which catches the common mistake of fixing the assertion instead of the code. Use Voiskey to dictate your reading notes next to the failing test, so the note lands in the file where the failure lives rather than in a scratch pad. Keep the notes to one line each: expected, actual, suspected cause. When the failure is a genuine mismatch in the requirement, say so and update the test deliberately rather than quietly loosening it.
Check that new tests fail before the implementation exists. A test that passes immediately is either checking something already built or checking nothing at all, and both cases deserve a sentence of investigation. Speak the check as a prompt: confirm this test fails now and explain why. Record the reason for the failure next to the test, so the passing state later has a reference point. If the assistant reports that the test cannot run, fix the setup before adding more cases, because a suite that cannot run is worse than no suite. This one habit prevents the most expensive kind of false confidence, where a green run hides a check that never executed.
Read the error output as a story rather than as a wall of text. Say the first line that names the failure, then the line that shows the value, then the line that shows where it happened. Most failures become obvious within those three lines, and speaking them prevents your eyes from skipping to a familiar-looking message. If three lines are not enough, read the next block aloud too, slowly, before deciding. When a failure is genuinely unclear, dictate a prompt that asks for the smallest reproduction rather than a broad rewrite. The goal of this reading is a specific next action, not a general feeling that something is wrong.
Before you stop, leave the suite in a state a teammate can reproduce. Note the command that runs the tests, the dependency version, and any fixture the tests assume. A teammate should be able to download the project, run the same command, and see the same result without asking you which folder to use. Write that command in the run instructions and remove any assumption that only you know. Confirm this once by running the command from a clean checkout rather than from your working directory. A suite that only runs on your setup is a private artifact, and private artifacts do not survive a handoff or a long weekend.
Keep a short voice test plan for each feature you build more than once. The plan is a list of spoken sentences, one per case, in the order you would say them. Start with the happy path, then the empty state, then the failure paths, then the boundary values. Because the sentences are already written, a later session begins with dictation rather than composition. Review the list when the feature changes and strike the cases that no longer apply. The plan is not a formal document; it is a set of prompts you have already proven, kept where you will find them next time.
Group the plan by the words you actually say, not by the structure of the code. Cases that share a phrase belong together, such as every sentence that begins when the month has no records. This grouping makes the plan fast to speak and easy to extend, because a new case usually reuses an existing opening. It also exposes duplicates, which are easy to accumulate when tests are written one prompt at a time. A plan of twenty sentences with four duplicates is really sixteen cases and four wasted checks, and the cleanup takes a minute. Sort the duplicates into one sentence and note any variation after it.
Use the same plan in review. When someone reads a change, ask them to speak the sentence for the behavior they are checking and compare it with the test name. A mismatch is a finding even if the suite is green, because it means the test protects something other than the stated behavior. This technique is quick, needs no tooling, and works when the reviewer is tired, which is when most reviews happen. Keep the plan open during the review so the sentences are in front of everyone rather than recalled from memory. Write each mismatch down as a question for the author instead of a judgment.
Add the plan to your team vocabulary when more than one person works on the feature. A shared list of sentences is the cheapest way to make tests consistent across a team, because everyone checks the same behavior with the same words. Store it with the project, link it from the run instructions, and review it when a feature ships. If the team uses shared vocabulary and workflows, the plan becomes part of that shared material rather than an individual habit. Consistency here pays off in fewer disputes about whether a change is finished, and it shortens the next review before it starts.
Speak one case per prompt in a given, when, then pattern: given the setup, when the action happens, then the visible result. Voiskey clears filler and shapes the sentence into a usable prompt, so each case stays a single requirement. Send the case, watch it fail for the right reason, then dictate the next one. Enumerating many cases in one breath usually merges two of them, and the merged test checks neither behavior properly.
Voiskey learns names, jargon, acronyms, and spelling preferences, which helps with identifiers you repeat across a suite. For values that must match exactly, such as an error code or a formatted string, type that fragment instead of speaking it. The hybrid keeps the scenario spoken and the characters exact. Reading the polished prompt before sending catches the remaining mismatches, and that check is faster than debugging a test that failed for a naming reason.
Voiskey works at the system level in any app or text field: press a shortcut, speak, and text appears at the insertion point. For test prompts it removes filler words, stutters, false starts, and self-corrections, then adapts punctuation and formatting so a given, when, then sentence arrives as a usable request. The vibe coding use is to speak the prompt where you are working, which keeps test writing in the same window as the code it checks.
Voiskey supports more than one hundred languages and translation, so a spoken error message can be produced in the language your readers use. That is useful when a test asserts on a user-facing message that must match the interface language. Say the intended message in the prompt, or describe its meaning and ask for the matching text. Then read the polished result and keep the exact string in a typed fragment if the test compares characters.

Download Voiskey for Mac and Windows and speak your next test case at the insertion point.
Use it across macOS, Windows, iOS, and Android