Iterating effectively

Patterns for making 50 small changes a day in vly without losing momentum. The mindset, the rhythm, and the safety nets.

vly’s loop is fast — 30 seconds from prompt to deploy. The temptation is to fire off prompts as fast as you think them. The teams that ship fastest aren’t the ones with the most prompts; they’re the ones whose prompts land cleanly the first time.

The rhythm

1. Look at the live app

   Don’t prompt from memory. Open the preview, see the current state, decide what’s next.

2. One change at a time

   Five small prompts beat one big one. Easier to roll back, easier to reason about, less likely the agent misreads.

3. Use Plan mode for anything that changes the schema or adds a page

   The 5-second review prevents 5-minute redos.

4. Verify in the preview

   Don’t trust “Build complete.” Click around. If you see something off, fix before moving on — every layer you build on top of a bug compounds.

5. Commit the revision when satisfied

   Each prompt creates a revision; if you regret it, roll back. No commitment penalty for trying something.

When you’re stuck on a prompt

Read the agent's first response

If it misses the point, the prompt is the problem. Roll back, refine, re-prompt — don’t fight the wrong implementation.

Add a constraint

“Same change, but don’t break X.” Often a prompt produces correct primary behavior + unexpected side effects. Constraints fix the side effects.

Switch to Plan mode

If you’ve re-prompted twice and the result still misses, drop into Plan mode for the next attempt. The plan reveals the misunderstanding.

Switch agents

Different agents have different strengths. If Claude Code keeps over-editing on a tight change, try Codex.

Avoid these patterns

Bundling unrelated changes

“Add a settings page, fix the broken date picker, and refactor the auth flow.” Three prompts, not one. If any single piece fails, the whole revision is suspect.

Prompting from memory

“Add a button next to the avatar.” Open the live app — is there an avatar? Is it where you remember? Memory fades fast in a 50-revision session.

Skipping the verify step

“Build complete” doesn’t mean correct. Click around the preview. Verify the change is what you wanted, and that it didn’t break anything else.

Big prompts when small ones work

“Add billing, subscriptions, plans, the billing portal, dunning, and tax.” Five prompts in sequence beats one prompt with five things.

Ignoring custom instructions

If you keep correcting the same thing (“use named functions, not arrows”), put it in custom instructions. One-time setup; works on every future prompt.

The “lock and step” pattern

For a complex feature, work in two phases:

1. Lock the foundation — first prompt creates the schema, the routes, the basic UI. Verify, commit.
2. Step through additions — one feature at a time on top. Each step is a small prompt against a known-good base.

This is the pattern most successful vly users converge on. It’s the difference between “I tried for 20 minutes and gave up” and “I shipped a real feature in 45 minutes.”

Tips

Take breaks every 10 prompts. Decision fatigue is real. Step away for 2 minutes; come back, you’ll catch issues that were invisible mid-flow.

Name your revisions. When you commit, give the revision a meaningful name. Future you (or your teammate) will thank you when scrolling version history.

For risky changes, branch first. Branching gives you a clean undo even for changes that span multiple commits.

Related

Plan mode

The cheapest insurance against misunderstanding.

Version history

Roll back when needed.

Debugging prompts

What to do when the agent gets it wrong.