Troubleshooting Unsaved Changes in Lovable

Why changes sometimes appear unsaved in Lovable

Lovable does not have a traditional Save button. Instead, it saves a version snapshot after every AI interaction in Agent Mode. This means your work is preserved automatically — but it also means there are specific scenarios where changes can appear lost. The most common cause is GitHub sync conflicts. When you have two-way sync enabled, changes made directly in GitHub (or by another collaborator) can overwrite what you see in the Lovable editor. The GitHub version becomes the source of truth, and your Lovable edits that were not yet synced may be replaced. Another frequent scenario is closing the browser tab while the AI is mid-task. If the AI has not finished processing, the partial changes may not be saved to version history. The editor does not warn you before closing because there is no 'unsaved changes' state — either the AI task completed (and was saved) or it was interrupted (and may be lost). Dev Mode edits are a special case. When you edit code directly in the Dev Mode code editor, changes take effect immediately in the preview but may not create a version history entry the same way AI interactions do. If the browser crashes after a Dev Mode edit but before the next AI interaction, those edits could be lost.

• GitHub sync overwrote local Lovable changes — the remote branch became the source of truth
• Browser tab closed or crashed during an AI task — partial changes were not saved to version history
• Dev Mode edits not captured in version history — direct code edits do not always create version snapshots
• Network interruption during save — the editor lost connection before the version could be stored
• Platform incident — Lovable experienced elevated error rates (check status.lovable.dev)

Error messages you might see

Before you start

• A Lovable project open in the editor
• An internet connection (Lovable saves to the cloud, not locally)
• Knowledge of whether your project is connected to GitHub (check Settings, then Connectors)

How to fix it

// Scenario: You edited a file in Lovable, but a collaborator
// pushed a change to the same file on GitHub at the same time.
// GitHub's version wins because it is the source of truth.
// Your Lovable edits appear to vanish.

// Solution: Check the Git commit history on GitHub
// 1. Open your GitHub repository
// 2. Click on Commits
// 3. Find the commit that overwrote your changes
// 4. Use Lovable version history to find your lost version
// 5. Restore it, then manually merge any needed changes
// Prevention: Add to AGENTS.md:
// "This project is actively edited via GitHub.
//  Before making changes, check if there are new
//  commits on GitHub that have not synced yet."

Complete code example

1# Change Management Rules
2
3## Save Points
4
51. After completing any significant feature, add a chat message:
6   "Checkpoint: [feature name] is complete and working."
7   This creates a named version in the history for easy recovery.
8
92. Before starting major refactors, prompt:
10   "List all files that will be affected by this change"
11   in Plan Mode first.
12
13## GitHub Sync Safety
14
15- This project uses two-way GitHub sync
16- Do not edit files directly in GitHub while the Lovable editor is open
17- Wait for Lovable changes to sync to GitHub before making external edits
18- If a sync conflict occurs, Lovable version history takes precedence
19
20## Protected Files
21
22Do not modify these files without explicit permission:
23- src/App.tsx
24- src/integrations/supabase/client.ts
25- vite.config.ts
26- index.html
27
28## Recovery Protocol
29
30If changes appear lost:
311. Check version history (scroll up in chat)
322. Check GitHub commits for synced versions
333. Do not make new changes until the lost changes are recovered
344. If recovery is needed, restore the latest good version first

Best practices to prevent this

• Connect your project to GitHub early — it provides a persistent backup that survives browser crashes and session timeouts
• After completing a feature, add a chat message like 'Checkpoint: login feature complete' to create a named version in history
• Do not close the browser tab while an AI task is running — wait for the task to complete so the changes are saved
• Avoid editing the same project simultaneously in Lovable and GitHub — two-way sync can cause overwrite conflicts
• Check status.lovable.dev if saves fail repeatedly — platform incidents can temporarily prevent saves
• Use Plan Mode to review what will change before Agent Mode executes — this prevents unwanted modifications
• Refresh the browser tab if the editor feels stuck — this re-establishes the connection to Lovable's servers
• Duplicate your project before making large changes — the duplicate serves as a manual backup

Still stuck?

Copy one of these prompts to get a personalized, step-by-step explanation.

Related error patterns