Build both sides of a feature switch without breaking the screen people already use

Vibe Coding a Feature behind a toggle means building two versions of the same screen and choosing between them at run time. Before you speak a prompt, name the toggle, its default value, and the one place in the code that reads it. Say the feature name, the off value, and the on value in a single sentence. If the default is off, say so twice, because a builder who assumes on will ship the new path to everyone. A toggle with a clear name and a clear default is the foundation for everything that follows, and it prevents the most expensive kind of mix-up.
Describe what the feature does when the toggle is off. The off path is the current experience, and it must keep working exactly as it does today. Say the screens, the labels, and the behavior that must not change. List the places where the off path and the on path share code, because that is where a change can leak from one side to the other. When you cannot name the shared code, ask for a short map before the build. The off path is the promise you make to current users. Write the shared list on the same page as the toggle name so nobody has to search for it.
Say who can turn the toggle on and in which environment. If only developers can enable it, say that; if a small group of users can, name the group by role rather than by person. Do not describe admin screens the product does not have. When the toggle is controlled by a setting, say where the setting lives and what it is called. The audience for the on path decides how much polish the first version needs and how loudly a bug will be felt by the people who see it. If the answer is unclear, ask the owner before the first prompt rather than after the build.
Write the rollback sentence before the build starts. It should say how to return to the off path and what happens to any state created while the toggle was on. If the on path writes something the off path cannot read, that is a design question, not a code detail. Speak the rollback sentence aloud and have the owner confirm it. A feature behind a toggle is only safe to launch when the way back is as clear as the way forward, and the owner has agreed to both. If the owner cannot confirm the rollback in one sentence, the design is not ready to build.
Speak the off path as a complete set of instructions, even though it appears unchanged. Say which components render, which labels appear, and which actions remain. Ask the builder to confirm that the off path still matches the current screen before touching the on path. This sounds redundant, but a shared component changed for the new feature often alters the old screen in a way nobody notices. A short check of the off path at the start prevents a regression from hiding behind a toggle for a whole release. Run that check on the current release and save the result as the baseline for the review.
Describe the off path with the same states you would describe for any screen. Say the empty state, the loading state, the error state, and the success state as they exist today. If the new feature adds a state only on the on path, say that clearly so the builder does not add it to the old one. When the off path has a known bug, decide whether to fix it separately rather than folding it into this change. Mixing a fix with a feature makes the review harder and the rollback riskier. If a fix is needed, send it as a separate change so the feature review stays clean.
Name the exact point where the toggle is read. Say the setting is checked once at the top of the screen, or once when the page loads, and that the result is passed down. A toggle checked in five places drifts, because one place will eventually disagree with another. Ask for a single read and a clear value. When the value changes while the screen is open, say whether the screen should update immediately or on the next visit. That decision shapes the build and the tests. Ask the builder to name the read point in the plan before writing any code.
Ask for a test that proves the off path is unchanged. A simple check that loads the screen with the toggle off and compares the visible text with the current version is enough to start. Run it before the on path is built, so you know the baseline is clean. Record the result in the task. When the on path is later added, run the same check again. A baseline test turns the off path from an assumption into evidence that the team can point to during review. Keep the baseline result beside the diff so the reviewer can compare both at once.
Build the on path in small pieces, starting with the smallest change that shows the feature. If the feature adds a button, build the button and its state before the action behind it. If it adds a field, build the field and its label before the validation. Speak each piece as its own prompt, and state the toggle condition for each one. Small pieces are easier to review and easier to switch off when one of them is wrong, and they keep the diff readable for the reviewer. Say which piece can be removed without touching the others if the design changes.
Keep the on path behind the toggle at every step, including in tests. A test that runs the new code without checking the toggle can pass while the real screen still shows the old version. Say the toggle value in the prompt for each test. When a piece of the feature is shared with the off path, mark it as shared before the builder changes it. Shared code is the most likely place for a leak between the two versions, so it deserves its own review. A test that does not name the toggle value is not proving the new behavior.
Describe the new behavior in terms of what the person sees and does, not in terms of the code. Say the button appears beside the title, the menu opens on click, and the confirmation replaces the form. When a transition matters, say what disappears and what replaces it. If the new path reuses an existing component, say which one and what changes. A behavior description that names visible results gives the builder a target and gives the reviewer a test. Say exactly what stays on screen during the transition so the person never faces a blank frame by themselves at any point.
Stop adding scope when the on path covers the agreed cases. New ideas that arrive mid-build go into a list for the next version, not into the current change. Speak the list aloud at the end of each session and decide what waits. A feature behind a toggle can absorb unlimited polish, and the toggle makes it easy to keep adding. A written boundary protects the launch date and keeps the review focused on the cases the team agreed to ship this time. Write the boundary into the task so the next session starts from the same agreed line.
When both paths are built, use Voiskey to dictate the test notes at the insertion point in the task document. Speak the toggle value, the screen, the action, and the result for each case, and let the app remove filler so the notes read as a clean checklist. Because it learns the feature name and the toggle value, the notes stay consistent across cases. Run the off-path check and the on-path check in the same session. Download the diff and the notes together so the reviewer sees exactly what changed. Keep the notes short enough to read in one pass before you start testing.
Test the four combinations that matter: toggle off on the old screen, toggle on with the feature, toggle on with the feature failing, and toggle off after the feature was used. The last one is the case teams forget. If using the on path left something behind, the off path may show it. Record each result beside its case name. When a case fails, fix it before testing the next one. Download the updated diff after each fix so the reviewed version is the current one. If the fourth case fails, fix the cleanup step before touching any other case.
Ask a reviewer who did not build the feature to switch the toggle themselves. Watch where they look for the switch and what they expect to happen. Their confusion reveals whether the toggle's scope is clear. Use Voiskey to add their questions to the notes, then answer each one in the document. When the reviewer can explain what the toggle does and what happens when it is off, the build is ready for the next stage. Note their first question, answer it in the brief rather than in a message, and add it to the notes for the next reviewer.
Keep the diff small and readable. A feature behind a toggle that touches twenty files is hard to review and hard to roll back. If the diff is large, ask which changes are shared and which belong only to the on path. Move shared changes into a separate step with their own review. Download the final diff and attach it to the task with the test notes. A reviewer should be able to see the off path unchanged and the on path added without hunting. If the shared changes are large, give them their own task and their own reviewer.
Decide early when the toggle retires, and say the plan aloud. A toggle can stay off for a season and then surprise everyone when it is switched on. Write the condition for removal: after a set period, after a group of users confirms the feature, or before the next release. Give the decision an owner and a date. Use Voiskey to record the plan in the task, then download the note so it survives the sprint. A toggle without a retirement plan becomes permanent code that nobody understands. Put the date where the team will see it when the sprint ends.
When the feature is ready for a wider group, describe the change in the release notes in plain language. Say what the toggle controls, what a person will see, and how to report a problem. Speak the note at the insertion point and keep it short. Download the note with the release package. A clear note helps support answer questions without reading the code and helps the team remember why the toggle exists in the first place. Keep the note beside the release notes so support can find it quickly, answer questions, and point to the page that changed most.
When the toggle is removed, delete the off path and the toggle check in one change, then run the full test set. Say the removal in the task and note the date. If the off path is still needed for some users, the toggle is not ready to retire. Keep the removal diff small and reviewed like any other change. Download the final diff and archive the toggle notes with the feature. A clean removal leaves no half-dead branches behind. If any shared file still mentions the old path or the old label, the removal is not finished yet.
Review the outcome after the toggle is gone. Compare the behavior with what the team promised at the start. Note what the toggle made easy and what it made hard, such as testing two paths or explaining the scope to support. Speak the lessons into a short note for the next feature. Download the note and keep it with the project records. The next toggle will be simpler if the team remembers what this one taught them. Keep the note short enough that the next team reads it and records one lesson before building a toggle of its own next quarter.
Speak the toggle name, its default value, and the one place that reads it as a single sentence at the insertion point. Voiskey removes filler so the scope is easy to follow. Then describe the off path and the on path in separate passes. A clear spoken scope keeps the two versions from leaking into each other.
Describe the off path first, because it is the current experience and must stay unchanged. Name its screens, labels, and states, then ask for a check that compares it with today. Only after that baseline is clean should you describe the on path. The order protects current users while the new feature is built.
Yes. The app learns the names you repeat, so later prompts use the same toggle name and value. Say the name once clearly, check the inserted line, and keep using it instead of a shorthand. Consistent naming makes it easier to see which changes belong to the feature and which belong to the old path.
Download the diff with the test notes and attach both to the task. Include the four cases: off, on, on with failure, and off after use. Ask a reviewer to switch the toggle themselves and explain what each value does. A small diff with clear notes is easier to review and roll back.

Download Voiskey for Mac and Windows to describe both sides of a feature toggle in clear, reviewable language.
Use it across macOS, Windows, iOS, and Android