TL;DR
An AI-built app changes constantly (a re-prompt here, a hand edit there, sometimes an agent pushing updates), and without history you can't answer "what changed?", "who changed it?", or "can we go back?". Your options: filename copies (fragile), the AI tool's chat scrollback (not really history), git (real history, developer-shaped), or a sharing surface with versioning built in (history where the app actually lives). Pick by who needs to use the history.
Why AI apps need history more than most things
Three properties make versioning non-optional here:
- Regeneration has a blast radius. Ask the AI to "fix the button" and it may also reshuffle the layout it decided to improve. Without a restorable previous version, every prompt is a small gamble.
- The editors multiply. You re-prompt, a teammate edits copy directly, an agent pushes a revision. Three kinds of change, one artifact.
- The audience saw something. When a client reviewed Tuesday's version, "what did they see?" is a business question, not a technical one.
Option 1: filename copies
app.html, app-v2.html, app-final-REAL.html. Everyone starts here.
Fine for: a solo project you touch twice.
Where it fails: nobody records what changed or why; the copies drift across machines and inboxes; and the moment two people hold different "finals," you have forks, not versions. This is the exact failure documents had before they moved to URLs.
Option 2: the chat scrollback
The conversation that built the app contains its whole evolution, so it's tempting to treat the thread as history.
Fine for: archaeology on your own prompts.
Where it fails: scrollback is a transcript, not a version store. You can't diff message 220 against message 180, can't restore cleanly to either, and the thread only covers changes made in that chat: your teammate's hand edits and your agent's pushes never appear in it. It's also trapped in your account.
Option 3: git
The developer answer. Check the HTML into a repository; every commit is a version with an author, a message, and a diff.
Fine for: apps that graduated into real codebases with technical owners.
Where it fails for this audience: git's power assumes git's users. The operator, consultant, or marketer producing AI apps (the actual maker, most of the time) won't run git commit after each tweak, and their no-code edits on a shared surface never reach the repo unless someone syncs by hand. History that only the technical half of the team can read or write splits the record in two.
Option 4: history built into the shared link
Put the app on a collaboration surface where versioning is a property of the artifact itself: every change (a republish from the AI, a hand edit, an agent push) lands on one timeline automatically, and any version restores in a click.
- Publish the app; share the one live link.
- Work normally. Edits by anyone, human or agent, are recorded with who and when; save named checkpoints before risky changes.
- When a regeneration goes sideways or a client asks for Tuesday's numbers, roll back or view that version. The link keeps serving the current one.
Fine for: exactly the mixed team AI apps create: technical and non-technical editors, plus agents, on one artifact.
The honest limit: it versions the artifact, not a multi-repo codebase. When your app grows into a product with a build pipeline, you'll add git; the two aren't rivals.
Which one, when
| Situation | Use |
|---|---|
| Solo, low stakes | Filename copies, honestly |
| Understanding your own prompt trail | Chat scrollback |
| Engineering-owned codebase | Git |
| Shared artifact, mixed editors, clients watching | History on the shared link |
How Coedit fits
Coedit builds option 4 in: every project carries automatic version history with rollback, named checkpoints via "Save version", and one timeline that records human edits and agent pushes (CLI or MCP) identically, with author and timestamp. Because history lives where the app is shared, "what did the client see?" has an answer, and no re-prompt is a gamble. Works the same for HTML from Claude, ChatGPT, Gemini, Lovable, or v0.
FAQ
Q: How do I get back the old version after the AI ruined my app? A: If the app lives somewhere with version history, restore the last good version in a click. If it only exists as a file, your options are whatever copies you kept, which is why saving a checkpoint before each big re-prompt matters.
Q: Does ChatGPT or Claude keep version history of what it builds? A: The conversation preserves earlier states informally, and canvas-style editors have some undo, but there's no restorable, diffable version store for the artifact, and changes made outside that chat (by teammates or agents) are invisible to it.
Q: Do non-developers really need version history? A: They benefit most. History with rollback is what makes it safe to let non-coders edit directly: any mistake is one click reversible, so nobody has to gatekeep.
Q: What about changes made by AI agents? A: They belong on the same timeline as human edits, with authorship recorded. Separate logs for agent changes recreate the split-history problem; see human + agent version history, explained.