One idea, one prompt, one commit, repeated all day

Vibe Coding with Continuous small commits works when each spoken change has a size limit you can state before you speak. Pick a limit you can review in a few minutes: one function, one component, one rule, or one file. Write the limit at the top of your task and say it aloud when you open the editor. If a request needs more than the limit, split it into steps and number them. A limit converts a vague hope for discipline into a check you can apply in seconds. It also gives you a natural place to stop when a session runs long.
Choose the limit by review cost, not by line count. A ten-line change in a shared module can be harder to review than a forty-line change in a new file, so measure the number of decisions a reviewer must make. If a change adds a new dependency, changes a public interface, or alters behavior in two places, it is large no matter how few lines it touches. Write those triggers next to the limit. A practical limit names both the scene of the change and the decisions it introduces, so the reviewer knows what to expect before opening the diff.
Tell the editor the limit as part of the prompt. A sentence such as changing only the validation branch and leaving the rest of the function untouched gives the editor a boundary to respect. When the result crosses the boundary, stop and ask for the smaller version instead of accepting the larger one because it looks convenient. A boundary stated up front is easier to enforce than one negotiated after the change. Keep the sentence in your task notes so you can reuse it. The habit of naming the boundary is most of the discipline. Say the boundary before every prompt you dictate.
Review the limit at the end of the day. List the commits you made and ask whether each one matched a single decision. If three commits touched the same decision, the limit was too small for that work. If one commit touched three decisions, it was too large. Adjust the limit for the next day and write the adjustment in your notes. A limit is a working tool, not a rule carved in stone, and it should track the kind of work you are doing. Small adjustments keep the habit alive. Write the adjustment down so it survives the week.
One prompt should carry one intent. An intent is a change in behavior, not a list of edits: make the empty state show a shortcut, reject a duplicate name, or move the count into the header. Say the intent as a single sentence, then say the boundary. When you notice a second intent forming in your sentence, stop and save it for the next prompt. Two intents in one prompt produce a diff where a reviewer cannot tell which change caused which result, and that ambiguity is exactly what small commits are meant to remove. One intent per prompt keeps the diff readable.
Dictate the intent in the order a reviewer reads. Start with the current behavior, then the desired behavior, then the boundary. Say what happens today, what should happen after the change, and what must stay untouched. This order forces you to be concrete about the starting point, which is where most misunderstood requests begin. Read the sentence back before sending it. If the current behavior is hard to state, you may not understand it well enough to change it safely. A short pause here saves a long review later. Say the current state first, then the target, then the boundary.
Keep the prompt free of solution detail unless the solution is the point. If you know the exact function to change, say it; if you do not, describe the behavior and let the editor propose the location. Mixing a behavior request with a half-remembered implementation detail produces a confused change. Speak the behavior first and add the location as a second sentence. When the result surprises you, the intent sentence is the reference for deciding whether the surprise is acceptable. Without that reference, every result looks plausible. Keep the intent sentence beside the diff while you edit the code.
Record the intent beside the commit. A commit message that restates the intent is easier to scan than one that lists files. Write the message in the imperative, keep it under a line, and add one sentence about the boundary in the body if it matters. When you dictate the message, say the intent first and edit the result at the insertion point. A history of intents is a history of decisions, and a history of decisions is what makes a project possible to reason about months later. Keep the message as small as the change. Read the message once aloud before you commit it.
Commit as soon as the change works, before you start improving it. The working state is the most valuable moment in the session, because it is the point you can return to if the next idea fails. Speak the commit message while the intent is fresh, run the checks you agreed on, and commit. Do not wait to bundle a second idea for a tidier history. A tidy history is built from many small commits, not from one large commit that hides its own steps. The habit is to treat the working state as a stopping point rather than a checkpoint you pass through.
Set a simple test before you commit. The test can be a manual reproduction, a single automated check, or a quick look at the changed screen. Say the test aloud before you speak the change, so you know what done means. If you cannot state a test in one sentence, the change is probably too vague to commit. A small test that runs in seconds is better than a thorough test you skip under pressure. Write the test result in the commit body when it is not obvious, so the next person sees the evidence you had. Name the check in the commit body for clarity.
Use the commit as a boundary for conversation, not just for code. When the commit lands, start a fresh thread of thought for the next idea. If the next idea turns out to depend on the first, the commit gives you a clean base to compare against. If it turns out to be a mistake, you can undo it without touching the good change. This separation is the practical reason small commits are worth the extra effort. The repository becomes a sequence of decisions you can inspect, not a single pile you must untangle. Start the next idea from the committed state, not before.
Do not let an unfinished idea block a finished one. If the first change works and the second is half done, commit the first and leave the second in your notes. A half-finished change sitting in the working tree makes every later comparison noisy, and it tempts you to commit it just to clear the state. Name the unfinished idea in a note with the next step, then return to it after the commit. This small act of parking keeps the working tree meaningful and the history honest. A clean tree is a form of attention. Park the unfinished idea in a note and return later.
Review each commit before you move on, even when you are the only reviewer. Read the diff against the intent sentence and ask whether every line belongs to that intent. If a line belongs to a different idea, remove it or move it to its own commit. This pass takes a minute and catches the accidental edits that small commits are supposed to prevent. Voiskey helps here because you can speak the intent and the boundary into the commit body at the insertion point while the diff is open, keeping the record and the review together. Download Voiskey and try one review this way. Keep the intent sentence in the commit body.
Use a short review checklist for every commit. Confirm that the change matches the intent, that the boundary held, that the test ran, and that the message describes the decision rather than the files. Check that no unrelated formatting or renaming slipped in. If the commit touches a shared component, check the other call sites that might be affected. Record the checklist result in one line, such as reviewed with the boundary held and the test passing. A checklist that fits on one line is a checklist you will actually use on a busy day. Write the line every single time, even when busy.
Ask for a second pair of eyes on the commits that change shared behavior. A small commit is easy to review, so a teammate can check it in a couple of minutes between tasks. Send the intent sentence with the diff, not just a link. The sentence gives the reviewer the standard to judge against, and it makes a disagreement specific. When a review finds a problem, fix it in a new commit rather than rewriting history; a corrective commit keeps the record of what happened. Small commits make this pattern cheap and keep the review short enough for a chat message.
Close the review with a one-line note in your own log. State the commit, the intent, and whether the boundary held. Over a week, the log shows how often commits drift and which kinds of work tend to grow. If most drift happens in one area, adjust the size limit for that area. The log is also a useful record when someone asks why a change was made. A few lines per day is enough to turn a habit into evidence, and evidence is what keeps a habit going when the week gets busy. Read the log on Friday and adjust one thing.
Protect the habit by lowering the bar on busy days. On a heavy day, commit after each small working step even if the message is plain. The goal is to keep the sequence intact, not to write perfect messages. A plain message with a clear intent is still useful. When you have more time, improve the message and add the boundary note. This flexibility keeps the habit from collapsing the first time a deadline lands. Consistency matters more than polish, and a small commit made under pressure is better than a large one made later. Keep the sequence alive and the message plain.
Prepare the environment so the habit is easy. Keep the test command, the commit template, and the intent note in one place. Learn the shortcut for the status view and the diff view so checking the working tree takes seconds. With Voiskey, keep the shortcut ready for dictating messages and notes at the insertion point, and download it for any machine you use for a full week. Friction is the main enemy of a small-commit habit, so remove one step at a time. The setup is part of the practice, not a distraction from it. Do it once and reuse it every week.
Use a short daily reset to catch drift. At the end of the day, look at the commits and the working tree. If the tree has several unrelated changes, park them in notes or split them into separate commits the next morning. If the commits are tiny fragments of one decision, combine the plan for tomorrow rather than rewriting today. Write one sentence about what went well and one about what to change. The reset takes five minutes and prevents a week of accumulated mess that feels too large to fix. Do the reset before you log off for the day.
Measure the habit in weeks, not days. Count how many days had at least one small commit, and how often a commit needed correction. Review the count at the end of the week and adjust one thing: the size limit, the test, or the message format. A habit that survives a busy week is one that has been adjusted to fit real work. Share the adjustment with the team if others are trying the same practice. The point is not a perfect history but a history you can read, trust, and continue. Adjust one variable each week and measure the result.
Voiskey is an AI voice typing app for desktop use. You press a shortcut, speak one intent and its boundary, and text appears at the insertion point in your editor or commit message. It removes filler words and false starts, and adapts formatting, so a short request stays short.
Yes. Say the intent in the imperative, then add the boundary if it matters, and edit the result at the insertion point. Voiskey removes filler and false starts, so the message describes one decision instead of a list of files. It also learns names and jargon, which keeps identifiers stable in the message.
Say the current behavior, then the desired behavior, then the boundary, in three short sentences. Voiskey adapts punctuation and formatting to the task, so the sequence arrives as a clear request. Review it at the insertion point before sending, and keep the boundary explicit so the change stays small.
Voiskey supports 100+ languages and translation. You can dictate the note in one language and ask for another version, then review the result at the insertion point. Keep file names and identifiers unchanged, and check that the translated note still states one intent and one boundary.

Download Voiskey for Mac and Windows and speak one small intent at your cursor.
Use it across macOS, Windows, iOS, and Android