Describe every account screen, state, and error message before a developer builds the flow

Voice Prompts for Authentication begin with the first screen a person sees, not with the form in the middle. Walk the entry point aloud: how someone arrives, what they expect to do, and what the page asks for before anything else. On a sign-in screen the entry point might be an email field and a single button; on a sign-up screen it might be a choice between two paths. Say which path is primary and which is secondary, and describe where each one leads. Naming the entry point first stops the builder from designing a middle screen with no clear way in.
List the paths a person can take from the entry point. The common sign-in, the new account, the forgotten password, and the invitation link each deserve their own short description. Say the order in which the screens appear and what triggers the move from one to the next. If two paths share a screen, say so and name the shared component once. When a path loops back, for example a wrong code returns to the code screen, describe the loop plainly. A path list is the map a builder needs before touching a single form field. Say each path in the order a person would meet it, from the first click to the last screen.
Describe the fields with their labels, order, and expected input. Say the email field comes first, the password field second, and the submit button last. Name the keyboard each field should raise on a small screen, and say whether the password is hidden by default with a way to reveal it. Mention any helper text that appears under a field and the exact wording. Do not invent account rules the designer has not approved; mark them as questions. Exact field descriptions remove the small disagreements that slow a build. Ask the designer to confirm each label and its helper text before the build begins.
Agree on the scope of the flow before you speak the details. Which screens are included, which are out of scope, and which existing screens will be reused. Write the boundary in one sentence and have the designer confirm it. If the flow shares a header or a footer with the rest of the product, say so at the start so the builder does not duplicate work. Keep the scope sentence beside the spoken description. A flow with a clear boundary is easier to review and much easier to hand to a second developer later. Keep the scope sentence visible at the top of the shared document for the whole build.
Speak each state as a scene: what the person sees, what they can do, and what happens next. The default state shows the form; the submitting state shows a disabled button and a short message; the success state moves to the next screen. The error state keeps the form and explains what to change. Say the order of these scenes and the trigger for each one. When a state has no visual in the mockup, describe the behavior you expect and mark it as a question for the designer. States are where flows usually break. Read the scenes in order and ask the designer which one is missing from the mockup.
Describe the wait between actions with care, because silence looks like a failure. Say what appears while the form is sending: a disabled button, a progress label, or a short line of text. Say how long the person should wait before a slow message appears, using the project's existing pattern rather than a new number. If the wait can end in two ways, success or a retry, describe both. A clear waiting state prevents double submissions and the confusion that follows them. Say what the person can do while they wait, such as cancel the action or leave the screen cleanly.
Describe the handoff between screens in concrete terms. Say what the next screen shows at the top, what it carries forward, and what it deliberately hides. For a code screen, say how many characters the field accepts and whether the code can be pasted. For a reset screen, say whether the old password field appears at all. Speak the back behavior too: does the back control return to the form, or does it leave the flow entirely. Handoffs are the part reviewers forget to check. Say what the next screen shows at the top and what it deliberately leaves behind.
End the state pass with a table spoken as short lines. Name each screen, list its states, and say which are designed and which are open. This table becomes the acceptance list for the review and the test plan. Read it aloud to the designer and ask which row worries them most. Their answer often points to the state that needs the clearest copy. Update the table when a question is settled, and repeat the change aloud so it reaches the next prompt. Read the table aloud to the designer and record the answers beside each row before the build.
Error messages decide whether a person can recover, so describe them in plain language. Say the exact sentence for a wrong password, an unknown account, an expired code, and a field left empty. Keep each message specific about the next action without revealing anything the product does not intend to share. Avoid blaming the person; describe what to try instead. When two errors can appear at once, say which one wins. Exact copy spoken aloud is easy to review and easy to test against the built screen. Keep every message short enough to read on a small screen without scrolling sideways.
Describe where an error appears and how long it stays. Say whether it sits under the field, above the form, or in a banner, and whether it clears when the person types again. For a field error, name the field and the exact text. For a form error, say what remains visible so the person does not lose their place. If an error moves focus, say where focus lands. Placement and timing are part of the message, because a correct sentence in the wrong place still confuses. Say the exact trigger that clears the message, such as typing in the same field again.
Handle the unhappy paths without inventing account policy. Say what the screen does when the network is slow, when the code has expired, and when too many attempts have occurred. Describe the visible result and the next action, and mark the actual limits as questions for the owner. Do not promise a behavior the product has not decided. Speaking the visible result while leaving the policy open lets the builder work without locking the team into a rule nobody approved. Mark every policy item as an open question, leave the decision to the named owner, and note the date in the brief.
Check error copy against the success copy in the same pass. A person who sees an error and then succeeds should recognize the same field labels and the same button text. Say the pairs aloud: the error label and the success label, the retry button and the submit button. Inconsistent labels make a recovery feel like a different screen. When a label changes between states, ask whether that change is intentional. Consistency across states is a small detail that makes a flow feel calm under pressure. Say the pairs aloud and listen for a label that changes between states without a reason.
When the flow brief is complete, use Voiskey to dictate the remaining notes at the insertion point in the document you are editing. Speak the state you are clarifying, the exact copy, and the open question, and let the app remove filler so the brief stays readable. Because it learns the labels and screen names you repeat, the copy stays consistent across sections. Ask a developer to read the brief and list the states they cannot picture. Dictate those clarifications in place, then download the approved brief and attach it to the build task. Keep the brief open while you check each section against the notes you just dictated.
Review the copy as a set of pairs rather than single sentences. Read the error and its recovery together, the waiting state and its success together, the entry and its next screen together. If a pair does not make sense when read aloud, rewrite it before the build starts. Use Voiskey to speak the corrected pair into the brief and check the inserted text. When the pairs read cleanly, download a fresh copy and ask the designer to confirm the wording matches their intent. Fix the first broken pair before reading the next one, then read both aloud once more.
Keep a short list of open questions with an owner and a date. Speak each question as a full sentence so it can be pasted into the ticket without editing. When an answer arrives, dictate it beside the question rather than in a separate note. This keeps the decision and its context together. Before the build begins, read the resolved list aloud and confirm every item has an answer or a named owner. Download the brief with the open list attached so the developer knows where change is likely. Read the unanswered list aloud at the end of every single review with the owner present.
Set a definition of done for the flow brief. It is done when every screen has its states, every state has its copy, every error has a recovery, and every open question has an owner. Read that list aloud and check it against the brief. If a screen has a state with no copy, the build will invent one. Fix the gap before approving. Download the signed brief for the task, and keep the earlier version for comparison. A clear definition of done turns the review into a checklist instead of an opinion. Keep the earlier version beside the signed copy so the comparison is always available.
Reuse the approved brief when the product adds a new sign-in method or a new account screen. Open the previous brief, read its structure aloud, and replace the parts that differ. Because Voiskey learns the labels and screen names your team repeats, the new brief starts consistent with the old one. Speak only the differences: same entry screen, new code step, no password field. Download the new brief and attach it to the new task while keeping the original. Reuse keeps one flow from drifting away from the rest. Keep the differences short so the new brief stays easy to compare with the old one.
Review the live flow against the brief after each release. Walk the common path and one error path, and note where the built screen and the brief disagree. Speak each mismatch into a short review note, then decide whether the brief or the build should change. Download the updated brief and share it with the team. A flow that is checked against its description after every release stays predictable, and predictable flows are easier for support to explain. Note who walks the path, the date of the check, and the first screen that disagrees with the brief before you close the task.
Keep a shared list of labels and messages for every account screen. When a new screen needs a message, start from the list rather than writing a fresh sentence. Speak the chosen message aloud to check that it sounds like the others. Update the list when a message changes, and download the revised copy for the team. A shared list prevents the slow drift where every screen describes the same action in a slightly different way. Read the list aloud to the team, keep it where everyone can find it, and name an owner for every new entry before the release.
Retire screens and messages that the flow no longer uses. A leftover message in the list will eventually be copied into a new screen, where it confuses people. Mark removed items clearly and note the date. Review the list on a schedule with the designer and a support representative, because support hears the wording that causes questions. Download the current list after each review. A short, current list is more useful than a complete one that nobody trusts. Note the date and the replacement for each removed item so the team can follow the change without asking around the office.
Speak the entry screen, each path, and every state in order at the insertion point in your brief. Voiskey removes filler and false starts so the description reads as a clean sequence. Add the exact copy for each error and recovery, then read the polished text back. A clear spoken flow reduces the states a developer has to guess.
Name the default, submitting, success, and error states for each screen, then add waiting and retry where they apply. Say what the person sees and what they can do in each one. Mark any state the mockup does not show as an open question with an owner. A complete state list keeps the first build honest.
Yes. The app learns the labels and screen names you repeat, so the same wording appears across sections. Say each message exactly once, check the inserted line, and reuse the project term instead of a synonym. Read the error and its recovery together to confirm the pair makes sense.
Download the finished brief with its open-question list and attach both to the build task. Note the reviewer, the date, and the states that remain unresolved. Ask the developer to read the brief and name any screen they cannot picture. One approved copy keeps the flow consistent through the build.

Download Voiskey for Mac and Windows to describe sign-in and account flows in clear, consistent language.
Use it across macOS, Windows, iOS, and Android