TLDR: The first page an AI builds is a draft, not a deliverable. Iterate in small, targeted steps: change one thing per turn, point at the exact section you mean, and tell the AI to leave everything else untouched. Broad prompts like “make it better” invite the model to rewrite working parts and reintroduce old bugs. Save the versions you like, and re-publish each good one to the same live link so reviewers always see the latest.
An AI can hand you a strikingly good first draft of a page in under a minute. It will almost never be the version you actually ship. The gap between “good first try” and “this is done” is closed by iteration, and iteration is a skill with real technique. Done well, it feels like steering. Done badly, it feels like wrestling. This guide is how to iterate on AI-generated pages so each change moves you forward instead of sideways.
Why iteration goes wrong
The most common way to refine an AI page is also the worst: typing something broad like “make it better,” “clean this up,” or “fix the layout.” To a model, those are permission to redo the whole thing. It rewrites sections you were happy with, changes your copy, and often brings back a bug you already squashed two turns ago.
Vague requests get vague, sweeping rewrites. Specific requests get surgical edits. The precision of the change is set by the precision of the ask.
The second failure is changing several things at once. When you ask for five edits in one message and two of them look wrong, you cannot tell which instruction caused what. You have lost the thread. Small scopes keep cause and effect visible.
The iteration loop that works
Good iteration is a short, repeatable loop. Change one thing, look at the result, keep it or revert, repeat. Each of these steps has a technique worth spelling out:
1 Change one thing at a time
2 Point to the exact spot
3 Protect what already works
4 Describe the outcome, not the code
5 Re-publish the good versions
Copy-paste prompts for common fixes
These work in both Claude artifacts and ChatGPT Canvas. Notice how each one is scoped and protective:
- Spacing: “Add more vertical space between the sections. Change nothing else.”
- A single element: “Make the primary button larger with more padding and rounded corners. Leave every other element untouched.”
- Copy: “Rewrite only the subheadline to be shorter and clearer. Keep all layout and styles the same.”
- Responsiveness: “On screens narrower than 600 pixels, stack the two columns into one. Do not change the desktop layout.”
- Undo a regression: “That change also altered the header, which I liked before. Restore the previous header exactly and keep only the footer change.”
The revert prompt is the one people forget. When an edit goes sideways, do not try to patch the patch. Tell the model to restore the previous version of that specific part and keep only the change you actually wanted.
When to start over instead of iterating
Iteration has a limit. If a conversation has gone twenty turns deep and the model keeps losing track of decisions, the context has become noise. That is the time to start fresh: open a new chat, paste the current HTML back in as the starting point, and continue from there with a clean slate. You keep the work and drop the confusion.
| Situation | Keep iterating | Start over |
|---|---|---|
| A few clean turns in | Yes | No |
| Model forgetting earlier decisions | No | Yes, paste current HTML |
| One specific element to fix | Yes | No |
| Output getting worse each turn | No | Yes |
| You like the page, want small tweaks | Yes | No |
How re-publishing makes iteration painless
The reason to publish early is that it makes every later change free. With VisiblePage, you paste the current HTML and get a live link immediately. As you iterate, you re-publish each good version to that same URL. Everyone you shared the link with, whether a client, a teammate, or a reviewer, always sees the latest without you resending anything. No “final_v4.html,” no “use the newer one I sent.” One link, always current.
That single canonical link is what turns iteration from a private struggle into a smooth review loop. Build a rough version, publish it, gather feedback, refine, re-publish, repeat. See update a shared page without changing the link for how that works, and the broader guide to sharing your AI work for the full picture. The whole prompt-to-page workflow lives in our pillar on building with Claude and ChatGPT. For a deeper reference on the CSS concepts you will end up nudging, MDN is the standard.
Try it now: Publish your work-in-progress as a live link and re-publish every improvement to the same URL.
Frequently asked questions
How do I refine a page an AI built without breaking it?
Iterate in small, targeted steps: change one thing per turn, name the exact section you mean, and tell the AI to leave everything else alone. Broad requests like “make it better” tend to rewrite working parts. When a version is good, publish it as a live link with VisiblePage so reviewers always see the current one.
Why does the AI keep changing things I did not ask it to?
Vague or sweeping prompts invite the model to redo the whole page. The fix is precision: reference a specific element, describe the exact change, and add an instruction to keep the rest of the page identical. Small scopes produce small, predictable edits.
Should I start a new chat to fix a page or keep the same one?
Keep the same conversation while the context is still useful, because the AI remembers the page and your earlier decisions. Start fresh only when the thread gets long and confused, and in that case paste the current HTML back in as the new starting point.
How do I keep versions of an AI page as I iterate?
Save the HTML at milestones you like, and use a host that lets you re-publish to the same URL so the live link always shows your latest good version. That way you can experiment freely and only promote the versions that work.
How do I share each new version with reviewers?
Publish the page as a live link and re-publish updates to the same URL. Everyone you already sent the link to sees the newest version automatically, so you never resend files or manage v2 and v3 copies.
Ready? Turn your iterating draft into a live link — your first page is free.