Every change gets a number like v3.4.5, with when it happened and the prompt that made it. Open the timeline from your preview, and go back to any version when a change goes wrong.
A free kit for Lovable. Lite works without GitHub; Pro uses GitHub and lets you go back by asking in chat.
Version history 5
v7.1.1 Small tweakNow
13 min agoBigger buttons on the menu
Built on v3.4.5
“Menu buttons bade karo”
v7.1.0 Went back
15 min agoWent back to v3.4.5
v7.0.0 Big change
1 h agoFull redesign with a dark theme
“Poori site dark theme mein”
v3.4.5 Small tweak
yesterdayFixed the footer links
“Footer links theek karo”
v3.4.0 New feature
2 days agoAdded a pricing section with 3 plans
“Pricing section add karo”
To go back, ask in chat: “go back to v3.4.5”.
A readable number for every change
Small tweak v3.4.5 → v3.4.6, new feature → v3.5.0, big redesign → v4.0.0. You can tell how big a change was from its number.
A timeline inside your preview
A small button in the corner of your Lovable preview lists every version with what changed and when. Visitors to your live site never see it.
The prompt that made it
Turn prompts on and each version also shows the message you typed, so you can repeat a good result or see where it went wrong.
Go back by asking
In Pro, type “go back to v3.4.5” in Lovable's chat and that version comes back a minute or two later. In Lite, the button tells you which change to restore in Lovable's History.
Going back is saved too
Going back never deletes a version. It becomes a new version marked “Went back”, and later versions show “Built on v3.4.5”, so you always know where you are.
When you go back, the numbers keep going up. On v7.0.0, going back to v3.4.5 gives you v7.1.0 with v3.4.5's code, and v4 to v7 are all still there to come back to.
| Feature | Lite | Pro |
|---|---|---|
| Needs GitHub | No | Yes |
| Setup time | About 10 minutes | About 15 minutes |
| Where versions are kept | A table in your app's database | Git tags on GitHub |
| How you go back | Lovable's History; the button tells you which change | Ask in Lovable's chat: “go back to v3.4.5” |
| Every change gets a version | Only when Lovable describes the change | Yes |
| Private | No: anyone with your app's public key can read the list | Yes, in a private repo |
| Best for | Trying it out, personal and prototype projects | Real projects and anything private |
Download the kit
One zip file. Double-click it to unzip.
Open START-HERE.html
Every step on one page in your browser, with a Copy button for each message and file.
Paste into Lovable
Follow the Lite or Pro steps. After that, versions are made for you as you work.
Before you start
Lovable
Lite and Pro kit
Bolt and v0
GitHub layer
Claude Code, Cursor and other coding tools
Agent skill
ChatGPT, Claude and Gemini chats
Free prompt on this page
Using ChatGPT, Claude or Gemini? Paste one of these at the start of a chat. The AI then numbers each change, so you can ask for any earlier version by its number.
At the end of every reply that changes my work, add a short version note in this exact format: Version: v[major].[minor].[patch] (patch = small fix, minor = new section or feature, major = big redesign) Date: [today's date] What changed: [one line] My request: [my message, in one line] Start at v1.0.0. Keep counting from the last note in this chat. If I say "go back to vX.Y.Z", show me that version's full content again, then continue from it as a new version and say which version it was built on.
Before you make any change, list the files or sections you will touch and wait for me to say "go". After the change, summarise exactly what changed in 3 bullet points, so I can compare it with the previous version.
These notes live inside the chat. They help you find and repeat a version, but they don't replace saving important work outside the tool.
Every AI tool has its own undo, and each has a catch. Checked against each tool's official docs on 29 October 2026.
| Tool | How to go back | Brings back data? |
|---|---|---|
| Lovable | History in the top bar, pick a version, Revert | No |
| Bolt | Clock icon, pick a version, Restore this version | No |
| v0 | Version controls on a message, Restore | Not applicable |
| Replit Agent | Pick a checkpoint, Rollback (tick Database for data) | Optional |
| Figma Make | Version history, Restore | Not applicable |
| Claude Code | /rewind, or Esc twice | Not applicable |
| Cursor | Click a checkpoint, Restore Checkpoint | Not applicable |
| GitHub Copilot (VS Code) | Hover a request, Restore Checkpoint | Not applicable |
| Devin Desktop (formerly Windsurf) | Revert arrow on your prompt | Not applicable |
| Claude (claude.ai) | Edit an earlier message; switch with its arrows | Not applicable |
| ChatGPT | ⋯ on a message, Branch in new chat | Not applicable |
| Gemini (Canvas) | Previous Version and Next Version | Not applicable |
These tools save a version on every change, so going back is a click. The catch is data: restoring brings back code, not the rows in your database.
Every change creates a version automatically. Open History from the top bar (or Project → History), preview any version, bookmark the good ones and click Revert to go back.
Watch out: Revert restores your project's code only. It does not roll back database data, and very old versions can't be reverted.
Lovable docs: History (opens in a new tab)Click the clock icon in the top menu, pick a version and choose Restore this version. Hover a version to rename or bookmark it.
Watch out: Restoring doesn't change your Bolt or Supabase databases. On mobile you can't preview a version before restoring it.
Bolt support: Rollback and backup (opens in a new tab)Each message that changes code creates a new version. Use the version controls on a message to inspect, compare or restore it. Restoring creates a new latest version, so nothing after it is lost.
Watch out: Code you edit by hand doesn't create a version, and a deploy always uses the latest version.
v0 docs: Versions (opens in a new tab)The Agent makes checkpoints at milestones. Roll back with one click, and tick Database under Additional rollback options if you want the development database back too.
Watch out: Rollbacks don't change the database unless you tick it, the production database is never rolled back automatically, and Replit recommends Git for long-term history.
Replit docs: Checkpoints (opens in a new tab)A new version is saved whenever you or Figma AI edit the file. Open Version history at the top of the chat panel to preview, favourite, name or restore a version.
Watch out: Restoring needs edit access. It doesn't delete anything: later versions stay available.
Figma help: Edit a Make file (opens in a new tab)Coding agents take a checkpoint before they change your files. Every one of them says the same thing in its docs: checkpoints are short-term undo, and Git is the real history.
Every prompt creates a checkpoint. Run /rewind (or press Esc twice on an empty prompt) and choose to restore the code, the conversation, or both.
Watch out: It keeps the 100 most recent checkpoints in a session and deletes them about 30 days later. Files changed by Bash commands or by hand aren't tracked, and Anthropic says to keep using Git.
Claude Code docs: Checkpointing (opens in a new tab)The Agent creates a checkpoint before significant changes. Click a checkpoint in the chat timeline, or Restore Checkpoint on an earlier request.
Watch out: Checkpoints are stored locally, separate from Git, and restoring reverts files only. Cursor says to use Git for permanent version control.
Cursor docs: Checkpoints (opens in a new tab)A snapshot is taken before each chat request. Hover an earlier request and choose Restore Checkpoint; the later requests are removed.
Watch out: Checkpoints are temporary and don't replace Git. Terminal commands, network requests and deployments are not undone.
VS Code docs: Chat checkpoints (opens in a new tab)Hover your original prompt in Cascade and click the revert arrow, or create a named checkpoint from inside the conversation.
Watch out: Reverts are currently irreversible, so check before you click.
Devin docs: Cascade (opens in a new tab)Chat apps have the weakest history. You can branch a conversation, but there's no single place that shows every version, so save good results outside the chat.
Edit an earlier message to start a different version of the chat, with its own artifacts. The earlier version is kept, so you can try another direction without losing it.
Watch out: Branches sit behind the arrows on each edited message; there is no overview of every branch.
Claude help: Artifacts (opens in a new tab)Hover a message, click More actions (⋯) and choose Branch in new chat. You get a new chat with everything up to that point, and the original stays as it was.
Watch out: Each branch is a separate chat with no tree view. Canvas is no longer available in current models; writing and code now happen in blocks inside the chat.
OpenAI: ChatGPT release notes (opens in a new tab)Changes save automatically. Use Previous Version and Next Version at the top of the canvas to move between saved versions.
Watch out: Google's help page doesn't describe a history list, naming, or restoring a specific version.
Gemini help: Canvas (opens in a new tab)Save a copy before you ask
In a code project, commit before every AI session: git add -A && git commit -m "before AI". In Lovable, Bolt or v0, connect GitHub on day one, so your history lives outside the tool too.
Name a good version the moment you see it
Bookmark it in Lovable or Bolt, name it in Figma Make, or make a named checkpoint in Devin Desktop. In a chat app, copy the result into a file named like v3-pricing-final.md.
Save the prompt, not just the result
The same prompt rarely gives the same answer twice, so the prompt is the recipe. Keep one PROMPTS.md (or a note) with the date, the tool, the prompt and what came out.
Try a new direction in a new branch
Branch the chat in ChatGPT, edit an earlier message in Claude, or restore a version in v0 instead of asking the AI to undo its own work. The good version stays untouched.
After a wrong turn, go back with a clean context
Restoring files doesn't make the AI forget the bad instructions. Use Restore code and conversation in Claude Code, or paste the last good version into a fresh chat and continue there.
Yes. Lovable saves a version on every change, and you can preview, bookmark and revert them from History. It doesn't give versions readable numbers or show your prompt, and revert restores code only. This kit adds the numbers, dates and prompts, and a timeline you open from your preview.
Lite needs no GitHub and takes about 10 minutes, but its version list sits in your app's database where anyone with the public key can read it, so it suits personal and prototype projects. Pro uses GitHub, gives every change a version, keeps it private and lets you go back by asking in chat.
No. Like Lovable's own History, going back restores code only. Database rows and uploaded files stay as they are. If a change added or altered tables, going back can break the app until you ask Lovable to fix the tables.
No. The button shows in your Lovable preview. To see it on the live site yourself, add ?versions=on to the address, and ?versions=off to hide it again.
Bolt and v0 are in testing. A skill for Claude Code, Cursor and other coding tools is coming soon. For ChatGPT, Claude and Gemini chats, the free prompt on this page adds numbered version notes to any conversation today.
Open History from the top bar (or Project → History), pick the version you want and click Revert. Lovable creates a version on every change, so you can go back step by step. Revert restores code only: database data stays as it is.
We'll email you once, when the kit is ready to download. You can also use this form to tell us about anything on this page that's out of date.