Keep building in Lovable or Replit after you hire a developer
You can keep building your app in Lovable or Replit after you hire a developer or agency. The safe setup is a review branch: your AI builder commits to a branch of its own, the technical team reviews that work and tests it on a staging site, and only then is it merged into main, the one branch that deploys to production. What decides whether it works is where production deploys from: Lovable’s and Replit’s Publish buttons ship what’s in the builder, not what’s been reviewed on GitHub.
We run both versions of this for clients. On an AI design platform for businesses, the founder prototyped the app with Replit Agent. Once we took it to production, he kept building in Replit on his own branch, and his work reached production through a staging site. On a media delivery app built in Lovable, the founder edits main directly and our engineers work through pull requests. The first puts review in front of production; the second keeps the founder fast. Which one fits depends on what a bad release would cost.
Why AI edits straight to production get risky once a developer joins
- Two authors share one codebase. The AI builder doesn’t know why a developer wrote a line, so a prompt about one screen can quietly undo a fix somewhere else.
- AI edits reach the backend, not just the screens. Lovable’s docs say its agent writes and deploys server functions as part of building a feature, and on Lovable Cloud every draft uses the same database as your published app. Replit Agent works on a development database, and its changes to tables and columns are applied to production when you publish.
- Nobody reads the change. “Make checkout simpler” can touch pricing, sign-in or permissions. Without review, the first person to test it is a customer.
- The team loses track of what’s live. When a bug report comes in, developers need to know which version customers are running.
The review-branch system, step by step
The flow is one direction: founder’s branch → pull request → staging → test → main → production.
- Give the AI builder its own long-lived branch. The founder keeps prompting exactly as before. Every commit lands on that branch, never on
main. - Deploy production from
mainand staging fromstaging, through a host connected to GitHub. On the AI design platform, that’s two services on Render, each auto-deploying its own branch. Staging has its own database, so testing never touches customer data. - Bring the founder’s work in by pull request. A pull request is a proposed change that shows every edited line, so a developer actually reads it before it joins
staging. - Test on staging, then merge
stagingintomain. The founder tests here too: it’s their feature. - Merge
stagingback into the founder’s branch after each release. That way the founder’s next prompt builds on current code, including the developers’ fixes.
The founder owns product and copy, and says when a batch is ready. The developers own review, merge conflicts, database changes and releases.
What the reviewer checks
- Files outside the feature: sign-in, billing, payment webhooks, permissions.
- Database changes: new or dropped tables and columns, changed access rules.
- Packages and config:
package.jsonand build settings. On the AI design platform, review caught a merge from the founder’s branch that would have brought back Replit-specific plugins the production build had already removed. - Secrets pasted into code, and tests deleted or weakened to make something pass.
- Uncommitted work. In Replit, workspace edits aren’t on GitHub until they’re committed and pushed from the Git pane, so check the workspace is clean before opening the pull request.
Merge small and often
When the founder and a developer change the same lines, Git can’t merge them on its own, and someone resolves the conflict by hand. Merge the founder’s branch whenever a feature is done, so each pull request is small enough to read in one sitting and conflicts stay rare.
How to set it up in Lovable
Lovable edits and syncs one branch at a time. Its own Git sync guide says that if your team requires a pull request for every change to main, you should switch Lovable to a branch of its own and merge its work through the same review.
- Create the founder’s branch. In Project settings → Git → GitHub, use the branch picker’s Create branch. A new branch starts from the currently active branch, so create it while Lovable is on
main. Lovable starts editing and syncing it immediately. You can’t switch branches while Lovable is mid-edit. - Host the website from GitHub. Lovable’s hosting guide names Netlify, Cloudflare Pages, Vercel and others, and says the branch you deploy production from “can be the branch Lovable syncs, or a release branch you merge into after review.” Deploy production from
mainand a staging site fromstaging. - Keep your domain off Lovable’s Publish. Lovable’s docs say Publish deploys the current version and, once you host elsewhere, “continues to publish to Lovable hosting only.” They don’t say what it deploys from a non-default branch, so point your real domain at the host deploying
main. - Plan for the backend. On Lovable Cloud, a branch holds back code, not data. Lovable won’t drop, rename or retype tables and columns unless its “Execute backward incompatible database migrations” permission allows it. Set it to “Ask each time”, so every destructive change shows you the SQL first. For full separation, point the founder’s project at a test backend and run production on its own Supabase project, which means leaving Lovable Cloud.
Protect main too, but only once Lovable syncs its own branch. If Lovable is still syncing main when GitHub rejects its push, it parks the work on a fallback branch called lovable-sync.
How to set it up in Replit
- Create the founder’s branch in the Git pane. Replit’s Git pane creates, switches and merges branches and connects to GitHub. On the AI design platform, the Agent’s checkpoints showed up as commits on the founder’s branch. Push to GitHub at the end of each session.
- Deploy production from GitHub
main. Replit’s Publish saves a snapshot of your Replit App, and you update it by publishing again. It doesn’t deploy from GitHub, so a founder publishing from their branch would skip review. The AI design platform moved from Replit hosting to Render when it went to production; taking a Replit app to production covers that move. - If you stay on Replit hosting, only the team publishes, from
main, after staging. Publishing is also when Agent’s database changes reach production, which is one more reason it belongs to whoever reviewed them.
v0 works this way by default: each chat pushes to a working branch, and Publish opens a pull request and merges it, which GitHub branch protection can hold for a review.
The lighter alternative: founder on main, developers on branches
On the media delivery app, Lovable syncs main and the founder’s edits land there directly: about 99 of every 100 commits come from Lovable. Our engineers work on branches and merge through pull requests. The point of this setup is speed: the founder sees each change live the moment they click Publish, with no pull request or merge to wait on. The trade-off is deliberate: the founder’s edits, including Lovable’s changes to server functions and the database, reach production without pull-request review, so the safety net sits after release instead of before it.
What makes it workable:
- Our team watches production. We monitor the app’s errors and logs, so when a change breaks something, whether it came from the founder’s prompt or from our engineers, we catch it and fix it quickly.
- House rules live in
AGENTS.md, which Lovable reads on every message, so the agent works within the constraints our engineers set. - Tests cover behavior that must not change.
Our guide to a developer working on a Lovable app covers how our engineers work alongside the founder day to day.
That speed is worth it only when a bad release is cheap to recover from: the app does a focused job, its logic is straightforward, and a bug shows up quickly and gets fixed without lost money or data. An app for sharing photos and videos with clients can run this way. A trading platform for a quant fund can’t, because one wrong calculation can cost real money before anyone notices. Move to a review branch once mistakes get expensive: complex logic around money, permissions or customer data, paying customers who depend on every release, or several people changing the backend.
Review branch vs founder on main
| Review branch | Founder on main |
|
|---|---|---|
| Founder’s edits land on | Their own branch | main |
| Reviewed before production | Yes, pull request plus staging | No, monitored and fixed after release |
| Founder’s speed | Waits for the next merge | Publishes when ready |
| Production deploys from | main, through a host |
The builder’s Publish |
| Staging | Separate site and database | None on Lovable Cloud |
| Merge conflicts | Possible, kept rare by small batches | Rare, the founder is always on current code |
| Developer effort | Reviewing, merging, syncing back | Monitoring, AGENTS.md, tests |
| Best for | Paying customers, billing, several developers | Fast founder iteration on focused apps with simple logic |
What to ask an agency before hiring
- Where will my AI builder commit, and who merges that into production?
- What deploys production? Can my Publish button skip your review?
- Is there a staging site with its own database?
- How often will you merge my branch, and how do your fixes get back to me?
- What do you check in my changes?
- If I stay on
main, which guardrails will you add? - Do you want me to stop using the builder? The right answer is usually no.
FAQ
Does Lovable support branching?
Yes. Lovable syncs one branch at a time, and you can switch or create the synced branch in the project’s GitHub settings. Commits on other branches stay out of the editor until they’re merged into the synced branch.
Does Lovable have a staging environment?
Not built in. Lovable Cloud drafts use the same database as the published app. For staging, host a second copy of the site from a staging branch, and point it at a separate test backend if you need separate data.
Can Replit deploy from GitHub?
Replit’s Publish deploys a snapshot of the workspace, not a GitHub branch. Replit syncs with GitHub through the Git pane, and a host such as Render can deploy production from your GitHub main branch.
If you want engineers who set this up around the way you already build, start with our Replit rescue or Lovable rescue.
