Skip to content
Guide

How to hand over an AI-built app to developers

You built it by prompting; now engineers are taking over. What to move into your name, what to write down, and how to prove the handover worked before you need it to.

Sources checked October 24, 202612 min readHow we check our content

Updated October 24, 2026: Lovable's docs now say an existing repository can be uploaded as a ZIP into a new project, though Git sync still cannot connect to one.

A white key on a sage-green tray beside an empty silver tray
AI-generated illustration

To hand over an AI-built app to developers, move every account it depends on into your company's name, give them the code and a written account of how it must behave, then test that they can release without you. Getting the code across is the easy part; Lovable, for example, syncs a project to GitHub in both directions.

What gets lost is the knowledge of how the app is meant to behave, and the access nobody wrote down. So move the accounts first. Then give the developers the code with its full history, a list of every service and secret the app uses, and a written account of what the app must do and must never do. Finish by asking them to release a change and roll it back without your help.

What does an engineer need on day one that your AI tool never asked you for? The answer is the same whether the app came from Lovable, Bolt, v0 or Replit. Platform details are from each vendor's documentation as of October 24, 2026, listed under Sources.

What does handing over an AI-built app to developers involve?

Three things move: ownership, knowledge and responsibility. Ownership is the code, the data and the accounts. Knowledge is what the app is for, the rules it enforces and the decisions behind its quirks. Responsibility is who releases changes, who is alerted when it breaks and who can restore the data.

A code handover is complete only when all three have moved.

AI-built apps make the knowledge part harder than usual. Nobody wrote the code line by line, so nobody can explain it from memory, and the prompts that produced it are rarely a reliable record of what it does now. The handover has to rebuild that knowledge from the running app.

What should you do before the developers start?

Put everything in your company's name first, while you still control it: the code in a GitHub organization your company owns, your Supabase project in a Supabase organization you own, and the domain, email sending, payments, analytics, error monitoring and app-store accounts. A developer given access to an account you do not own can be locked out with you.

  • Code: move the repository to a GitHub organization your company owns. GitHub keeps the issues, pull requests and history when a repository is transferred, and redirects the old address to the new one.
  • Lovable sync: according to Lovable's documentation, sync continues after a transfer if your workspace has a GitHub connection for the new owner; otherwise the project disconnects.
  • Database: if the app runs on your own Supabase project, transfer it to a Supabase organization you own. You must be an owner of the source organization and at least a member of the target one, and a transfer cannot move a project between regions.
  • Everything else: domain, email sending, payments, analytics, error monitoring and app-store accounts should all be registered to the company, with you as owner and the developers as named members.

If the app still runs on Lovable Cloud rather than your own Supabase project, decide whether to move it before the handover or as the developers' first job. Our guide to migrating off Lovable Cloud covers what the export includes and what it leaves behind.

What should the handover pack include?

The pack covers what the app is for, the rules it must keep, a system map, a secrets inventory, how it is released today, and what you already know is wrong. Write it once and keep it in the repository, so the next handover is easier. It does not need to be long; it needs to be true.

  1. 01What the app is forWho uses it, the three or four journeys that matter most, and what it costs you when each one breaks.
  2. 02The rules it must keepWho may see and change what, what must never happen twice, and anything required by law or by a customer contract.
  3. 03A map of the systemEnvironments, hosting, database, storage, scheduled jobs, email, payments, AI providers and every other outside service.
  4. 04An inventory of secretsThe name and purpose of every key and where it is stored. Never the values: send those through the platform's own secrets settings, never by email or chat.
  5. 05How it is released todayWhere the live app is built from, how a change reaches users, and whether there is any way back.
  6. 06What you already know is wrongKnown bugs, workarounds, features that were half built, and anything a customer has complained about.

A developer who gets this pack can start by checking the app instead of guessing at it. One who does not will spend the first weeks reconstructing it.

How do you hand over a Lovable app to developers?

Through GitHub: developers work in the connected repository with their usual tools. Lovable's documentation describes a two-way sync: changes made in Lovable are pushed to the connected repository, and changes pushed to the active branch are pulled back into Lovable. A few details decide whether that helps or hurts:

  • Lovable edits and syncs one branch at a time, the repository's default branch unless you choose another in the project's GitHub settings.
  • When GitHub rejects a push, Lovable writes to a branch named lovable-sync instead, for someone to review and merge by hand.
  • Git sync always creates a new repository and cannot connect to an existing one; to start from existing code, Lovable's documentation says to upload the repository as a ZIP into a new project.
  • If you disconnect, the repository stays on GitHub with its history; syncing simply stops.

Agree early who edits the synced branch. If you keep prompting in Lovable while developers push to the same branch, you will overwrite each other. The usual arrangement is that developers work on their own branches and merge through reviewed pull requests, while you keep designing in Lovable. That split is how we work too, and our guide to taking a Lovable app to production explains what changes underneath.

What will developers check first?

Whether the app can be verified at all. Good developers start by measuring: does it build, does it type-check, do the tests pass, what does the linter report, and who can read which table. Only then do they know which changes are safe.

That first pass is often a code audit, and its results tell you whether to refactor or rebuild.

Bell's prototype, an AI email assistant with 143 database tables, is another example: its browser queried the database directly, and the review of its row-level security covered about 12 of those tables. None of that is visible from the screens, which is why developers look underneath before they add anything.

How do you know the handover is complete?

When the new team can do the everyday and the emergency jobs without asking you or the previous builder: release and roll back a change, run the app on staging, restore a backup, rotate a secret and act on an alert. Test it with a short list:

  1. Release a small change to production and roll it back.
  2. Run the app locally and on a staging environment that is not production.
  3. Restore the database to a copy from a backup and check the data.
  4. Rotate one secret without downtime.
  5. Receive an alert when something fails, and know who acts on it.

Anything they have to ask for was missing from the handover. Add it to the pack, then run the list again.

What should a handover checklist cover?

A handover checklist should cover the accounts and secrets before the developers start, the handover pack, the checks once they have the code, and proof the handover is complete. Here is the whole handover as one checklist to copy and adapt to your app. Keep it in the repository with the pack, so the next handover starts from it.

Before the developers start:

  • The repository is in a GitHub organization your company owns, with its issues, pull requests and history.
  • If the project syncs with Lovable, your workspace has a GitHub connection for the new owner, so sync continues after the transfer.
  • If the app runs on your own Supabase project, it sits in a Supabase organization you own.
  • Domain, email sending, payments, analytics, error monitoring and app-store accounts are registered to the company.
  • You are the owner of every account, and each developer is a named member.
  • Each developer has their own account with the access their work needs, and nobody uses your personal logins.
  • Secret values go through the platform's secrets settings, never by email or chat.
  • Any key that was ever sent in plain text has been rotated.
  • If the app runs on Lovable Cloud, you have decided whether to move it before the handover or as the developers' first job.

In the handover pack:

  • The pack is written down and kept in the repository.
  • It names who uses the app, the three or four journeys that matter most, and what each costs you when it breaks.
  • It says who may see and change what, and what must never happen twice.
  • It lists anything required by law or by a customer contract.
  • It maps the environments, hosting, database, storage, scheduled jobs, email, payments, AI providers and every other outside service.
  • It lists every secret by name, purpose and where it is stored, never the values.
  • It says where the live app is built from, how a change reaches users, and whether there is a way back.
  • It lists known bugs, workarounds, half-built features and customer complaints.

Once the developers have the code:

  • The developers have checked whether the app builds, type-checks and passes its tests, what the linter reports, and who can read which table.
  • If the project syncs with Lovable, everyone knows which branch it syncs: the default branch, unless you chose another in the project's GitHub settings.
  • You have agreed who edits the synced branch.
  • Developers work on their own branches and merge through reviewed pull requests.
  • Someone reviews and merges by hand anything Lovable writes to the lovable-sync branch.

Proof the handover is complete:

  • The new team has released a small change to production and rolled it back.
  • The app runs locally and on a staging environment that is not production.
  • The database has been restored to a copy from a backup, and the data checked.
  • One secret has been rotated without downtime.
  • An alert arrives when something fails, and everyone knows who acts on it.
  • The new team did all of this without asking you or the previous builder.

What goes wrong when AI-built apps change hands?

Accounts, secrets and knowledge get lost: accounts sit in a freelancer's or builder's personal name, secrets pasted into chat or email are never rotated, nobody knows which environment the live app is built from, Lovable prompts and developer commits undo each other on one branch, and a rebuild quietly drops rules the prototype enforced.

  • Accounts in a freelancer's or builder's personal name, discovered when that person stops replying.
  • Secrets pasted into chat or email, then never rotated.
  • Nobody knowing which environment the live app is actually built from.
  • Prompting in Lovable and developer commits landing on the same branch and undoing each other.
  • A full rebuild started without a written account of what the app must do, so the rebuild quietly drops rules the prototype enforced.

If the app is already broken or exposed when you hand it over, our vibe-coding rescue service starts with an architecture review of what exists, then fixes what is risky, such as access rules and secrets. Plans start at $2,999 a month paid annually, $3,999 a month billed quarterly, or $4,999 month to month; see pricing. To see how far your app is from production first, take the free production-readiness check.

Sources

Each platform fact above comes from one of these pages, checked on October 24, 2026. We review this page every 30 days.

Common questions

Can developers work on a Lovable project?

Yes. Connect the project to GitHub and developers work in the repository with their usual tools. Changes pushed to the branch Lovable syncs flow back into Lovable, so agree who edits that branch and have developers merge their own work through reviewed pull requests.

Do I lose my Lovable project if I move the code to GitHub?

No. The GitHub sync keeps the Lovable project and the repository in step. If you later disconnect, the repository stays on GitHub with its full history; only the syncing stops.

Should I keep using Lovable after developers take over?

You can, and it is often the fastest way to design new screens. Keep your prompting and the developers' work on separate branches, and let the developers decide how each change reaches production.

What should I never send to a developer?

Secret values over email or chat, and your own personal logins. Give each developer their own account with the access their work needs, and share secrets through the hosting platform's secrets settings. Rotate any key that was ever sent in plain text.

How long does handing over an app take?

Moving accounts and code can take a day. Rebuilding the knowledge takes longer and depends on the app's size and how much was written down. The handover is done when the new team can release a change and roll it back without help.

More on this: Production architecture & security · How to migrate off Lovable Cloud to your own Supabase

Built something in Lovable you want people to rely on?

We are the engineers who take it the rest of the way — secured, tested, released and supported.