A commit-by-commit routine for keeping spoken code changes easy to review and undo

Vibe Coding with Version control discipline begins before the first prompt: decide what one commit will contain. A commit should represent one reviewable idea, such as adding a loading state to the invoice list or renaming one helper and updating its callers. Say the boundary out loud, then start a working branch for it. When a second idea appears mid-session, write it down for the next branch instead of folding it into the current change. This one habit prevents the most common problem in spoken coding, which is a session that produces a large diff nobody can review and nobody wants to revert.
Start from a clean state. Check that the working copy has no uncommitted edits before you begin, or commit them separately with a message that says what they are. A dirty start makes every later diff ambiguous, because you cannot tell which changes came from this session. Speak the check as part of the routine: show the status, list the modified files, and confirm the branch name. When the start is clean, the end is comparable. A clean start is also the cheapest way to notice that a generated file or a scratch note is being tracked when it should not be.
Create the branch before the first change, not after. A branch named for the change gives the work a label that survives in history and in review. Speak the name in a consistent pattern, such as the feature and the short description. If the team uses ticket identifiers, say the identifier exactly, because a wrong identifier is harder to find later than a wrong file. Then confirm you are on the new branch before speaking any code request. Working on the wrong branch is a small mistake with an expensive correction, and the confirmation costs one sentence. Say the branch name aloud before the first request.
Decide what will not be committed. Build output, cache folders, editor settings, and scratch files should be excluded before the session, not cleaned up after it. Speak the exclusion list once and confirm the status output shows none of those files as untracked. If a generated file must be committed for the project to work, say so and name it, so the reviewer does not treat it as noise. A clear exclusion list keeps each diff focused on the change you described, and it prevents a stray file from becoming part of a release by accident. Review the exclusion list whenever a new tool starts writing files into the project.
Speak one change per prompt and wait for the result before speaking the next. A prompt that asks for a rename, a new test, and a style fix at once produces a diff with three unrelated parts, and a failure in one part obscures the other two. Say the first change, review the diff, accept or correct it, then say the second. This rhythm is slower for the first few minutes and much faster overall, because each step stays small enough to understand. When the editor proposes a larger change than you asked for, ask it to reduce the scope before you review.
Describe the visible outcome rather than the implementation steps. A sentence such as show a spinner in the save button while the request runs gives a reviewer something to check, while a sentence such as add a boolean and conditionally render a component gives instructions that may not match the goal. Speak the outcome, then let the editor choose the mechanism, and review the mechanism afterward. When the outcome is clear, a wrong implementation is obvious; when only the mechanism is stated, a wrong outcome can pass review because the code looks like what was asked for. State the outcome, then check the outcome.
Keep the prompt and the commit boundary aligned. If you cannot describe the prompt as one reviewable idea, split it before you speak. A useful test is to say the sentence a reviewer would read in the commit message. If that sentence needs the word and three times, the prompt probably contains three changes. Rewrite the prompt until the sentence is simple, then speak it. The alignment between prompt and commit is what makes a spoken session produce a history that reads like a plan rather than a transcript of accidents. Write that sentence first and keep it beside the prompt.
Check the diff after every prompt, even a small one. Read the changed lines, confirm the files are the ones you expected, and look for anything unrelated. When a prompt produces a change in a file you did not mention, stop and ask why before continuing. That single check catches most of the drift that would otherwise accumulate into a messy commit. It also keeps the next prompt honest, because an editor that has just added an unrelated import is more likely to add another. Small reviews keep the session predictable, and they make the next review shorter because there is less accumulated change to read.
Write the commit message for the reader who will open the history in six months. Start with a short subject that names the change in the imperative, such as add loading state to the invoice list. Then add a body that explains why the change was needed and what it does not include. The subject is what people scan; the body is what they read when they are deciding whether to revert. A message such as fix stuff or update files forces that reader to open the diff, which defeats the purpose of a message. Write the subject before you open the diff, then check it against the diff.
Explain the reason rather than restating the code. The diff already shows what changed, so the message should say what problem it solves, what alternative you rejected, and any condition a future reader must know. Speak two or three sentences, then read them back. If a sentence describes a line of code, delete it. If a sentence describes a decision, keep it. When the reason is captured, a later revert is an informed decision rather than a guess, and the next person can tell whether the original condition still applies. That is the whole value of a history: it records reasons, not only edits.
Keep the message consistent with the scope of the commit. If the message needs to describe two unrelated changes, the commit should be split. If the commit contains a change the message does not mention, the message is incomplete. Speak the message before you commit, not after, because writing it first exposes scope creep. This ordering is a small discipline with a large effect: a message written to fit the diff tends to describe whatever happened, while a message written first forces the diff to match the plan. When the two disagree, stop and split the work rather than rewriting the message to fit.
Reference the identifiers your team uses, and keep the spelling exact. A ticket identifier, an issue link, or a related commit reference should appear where the team expects it. Say the identifier once and check it in the message. If the team uses a template with sections, follow it rather than inventing a structure. The value of a commit message is not literary; it is that another person can search the history, find the decision, and understand it without asking you. Consistency is what makes that search work. A missing identifier is a small omission that costs a future reader a long afternoon.
Read the full diff before you commit, including the parts you think you know. Spoken requests can produce changes in files the prompt did not mention, such as a shared helper or a type definition. Scan the file list first, then read each hunk. For every hunk, ask whether it belongs to the change described in the message. If the answer is no, either the message is wrong or the hunk should be removed. This review is not a formality; it is the point at which spoken work becomes code you can defend. Review the file list first, then read every hunk in order, including the small ones.
Check the untracked and ignored files as part of the review. A new file that should be committed will be missing from the diff, and a scratch file that should not be committed will appear as untracked. Say the status check out loud and confirm both lists. Then check that generated files are excluded rather than committed by accident. A commit that silently omits a new file is worse than a messy one, because the build fails for the next person and the cause is not in the history. Say both lists out loud before you write the message, so it covers what is actually there.
Look for accidental deletions and renames. A spoken request can remove a line that looked redundant and was actually a guard, or rename a symbol that other code still calls. Read removed lines carefully, especially in files you did not intend to touch. Run the tests before the commit rather than after, so the diff and the test result are reviewed together. When a test fails, fix it in the same commit only if the fix belongs to the same idea; otherwise revert the hunk and split the change. A test that passes only because the diff is incomplete is a test you cannot trust later.
Use the spoken loop for the notes that review produces. Put the insertion point in the commit message field or a review note, hold the Voiskey shortcut, and say the finding as one sentence with one expected correction. Voiskey removes filler words and false starts and adapts punctuation to the field, so a note about an unexpected hunk arrives in a form you can paste into the review. Then make the correction in a separate prompt and review the new diff. The loop keeps the message, the change, and the review aligned. Repeat it until the diff matches the sentence you first spoke.
Practice the revert before you need it. Pick a commit from the working branch, revert it, run the tests, and confirm the result. Then reapply the change. This exercise takes a few minutes and removes the fear that makes people keep a bad change rather than undo it. Speak the command and the expected result, and note whether the revert applied cleanly. A team that has reverted once knows what it costs; a team that has never done it treats a revert as a crisis and delays it until the diff has grown. The exercise also shows which commits are hard to revert, and those are the ones to split next time.
Keep the conditions for a revert written down. A failing test that cannot be explained in a few minutes, a behavior change that no one asked for, or a diff that cannot be reviewed in one pass are all reasons to stop and undo. Say who can call the revert and how the decision is recorded. Then say what happens next: which commit is restored, what is kept, and when the change is attempted again. A written trigger turns a stressful judgment into a routine procedure that anyone on the team can follow. Keep the trigger short enough to remember under pressure.
Avoid stacking unrelated commits on a broken base. If a commit is wrong, revert it before starting the next idea, rather than adding a fix on top. A fix on top preserves the original mistake in history and makes the eventual cleanup harder. Speak the sequence: revert the bad commit, confirm the tests pass, then start the next change on a clean base. This order keeps the history readable and keeps each commit independently reversible, which is the whole reason for committing in small steps. If the base is broken, every later review is contaminated, and the cause becomes harder to find with each new commit.
When you want the same workflow on your own machine, download Voiskey for Mac and Windows and keep the shortcut ready while your editor, diff, and commit message field are open. Voiskey turns a spoken note into text at the insertion point, including file names and paths when you name them, which suits a routine full of exact identifiers. It removes filler and self-corrections and adapts formatting to the field, so a commit subject and a revert reason arrive in a form you can keep. Then close the session by checking the status one last time and leaving the branch clean.
Voiskey is a voice typing app for desktop use. You press a shortcut, speak one change request, and the text appears at the insertion point in your editor. It removes filler words and false starts, so each prompt describes one reviewable idea instead of a bundle of unrelated edits.
Voiskey learns names, jargon, acronyms, and spelling preferences. Repeating a branch name or ticket identifier in context helps it stay stable. A short list of your team's terms beside your notes gives every spoken message the same spelling. Read the list back before a long session.
Say the subject in the imperative, then two sentences about why the change was needed and what it leaves out. Voiskey clears self-corrections and adapts punctuation to the field, so the message reads as a summary. Place the insertion point in the message field first.
Yes. Voiskey types wherever the insertion point sits, including a commit message field, a review note, or a prompt field, after you press the shortcut and speak. It also adapts phrasing and formatting, which keeps a short subject and body readable in the history.

Download Voiskey for Mac and Windows and dictate the next clean commit.
Use it across macOS, Windows, iOS, and Android