Vibe code handoff / the operational guide

Nobody wrote this code. Now a human has to own it.

You built something real with Lovable, Cursor, Bolt, or Replit, and it worked. Now it needs a person: someone to hold the keys, answer the pager, and keep it safe while it keeps changing. This is the operational guide to that handoff, written for the founder handing over and the developer taking over, because the same handoff fails for both when either side skips the steps.

handoff package · status
repo ownership (your org)HELD
domain + DNS (your registrar)HELD
database export testedDONE
third-party keys listedDONE
known-broken list writtenOPEN
successor assessment bookedOPEN
rule: everything transfers into accounts you own. nothing moves onto theirs.

The short answer

A vibe coded app changes hands safely in three moves: the founder assembles a handoff package covering access, environment notes, and an honest known-broken list; the successor runs a paid assessment before any retainer starts; and ownership of the repo, domain, and infrastructure never leaves the founder's accounts. Handoffs fail when any one of those is skipped.

The demand side of this problem is not hypothetical. An r/vibecoding thread from earlier this year, "The real cost of vibe coding isn't the subscription. It's what happens at month 3," captures the moment this page is about: founders who shipped something real, arriving at the point where the app needs a person, while rescue specialists in the comments report that work nobody wanted a year ago is suddenly sought after. Even SaaStr's guide to vibe coding, which sits near the top of the results for this exact question, tells builders to plan their exit from day one because most commercial apps eventually need a traditional development team. The advice is everywhere. The mechanics are not. This page is the mechanics.

The problem

Why this particular handoff is genuinely hard.

A normal codebase handoff has a shortcut built in: the incoming developer asks the outgoing one why things are the way they are. That shortcut does not exist here. Nobody wrote the code. The founder steered it into existence prompt by prompt, and when the new developer asks "why does auth work this way?" the honest answer is "I don't know, it came out like that and it worked." Every why has to be reconstructed from the code itself, which is the slowest kind of reading there is.

And many developers simply will not do it. Spend ten minutes in the developer subreddits and the sentiment is unmissable: one r/webdev thread declares the handoff between no-code builders and developers completely broken, arguing the gap is the same whether the builder used a no-code tool or an AI agent, and an r/ExperiencedDevs thread from a rescue specialist is titled, verbatim, "Saving challenging projects was my niche, but AI codebases are making me miserable." The refusals are not snobbery, or not only snobbery. Reading intent out of generated code is real work that most developers never priced, never practiced, and did not get into the field to do.

So the market splits. Founders with working apps search for someone to take over. Most developers decline, quote a rebuild to make the problem go away, or accept and burn out on it. The small group who handle these well treat the takeover as a discipline with a sequence, which is exactly what the rest of this page describes.

For the founder

The handoff package: assemble this before you talk to anyone.

Every hour you spend on this package saves the successor several, and you are paying for their hours. It also protects you: assembling it forces you to confirm you actually own your own product.

A1
Repo ownership
The GitHub org or repo belongs to you, not the builder platform and not a freelancer. Add the successor as a member. Never transfer the repo out.
A2
Domain and DNS
Registrar login in your name, on your card. DNS access is what lets someone move or break everything else, so it stays with you.
A3
Hosting and deploy
Vercel, Netlify, Railway, Fly, whatever runs the app. Note which branch deploys where, and any environment variables the platform holds.
A4
Database and backups
Supabase, Neon, Planetscale, or the builder-managed database. Confirm you can export the data yourself, today, before anyone new touches it.
A5
Third-party keys
Every API key the app uses: email, storage, maps, AI providers. List them, note which are live keys, and plan to rotate them after the handoff.
A6
Payment processor
Stripe or equivalent stays in your account, always. A successor gets restricted access at most. Money accounts never move.
A7
Analytics and monitoring
Whatever tells you the app is alive and used. If nothing does, say so; that absence is part of what the successor needs to know.
A8
Support inbox
Where users complain is where the real known-broken list lives. Give the successor read access to it from day one.

Alongside the access list, write three short documents. First, environment and deploy notes: how a change gets from the AI tool to production, which environment variables exist and where they live. Second, the known-broken list: every bug, workaround, and "do not touch that button" you are aware of, in plain language, without embarrassment. An honest known-broken list is the single most trust-building artifact a founder can hand over. Third, data sensitivity notes: what personal, payment, or health data the app holds, so the successor knows what they are now responsible for protecting.

If you are still choosing a platform or wondering what your platform already exposes, the platform guides cover that side: is Lovable safe, is Bolt safe, and the rest of that series. And if the app is changing hands because the person who understood it is gone, the developer-left guide covers the messier version of this same package, assembled without their help.

The sequence

What a professional takeover actually looks like.

Four stages, in order, each one earning the next. Any successor worth hiring follows something like this sequence, whatever they call the stages.

01
A paid assessment, never a blind retainer
Someone reads the codebase and the live app before promising anything. Small, fixed price, evidence out the other end. Our version is Ship Check at $299. Anyone competent has an equivalent. What no professional does is quote a monthly rate for a codebase nobody has read.
02
A written read of the codebase
The assessment produces a document you own: what the app is made of, what is exposed, what is fragile, ranked by how much each item can hurt you. This document is the real handoff artifact. Even if you never hire the assessor, the next candidate starts from it instead of from zero.
03
A scoped stabilization pass
The dangerous findings get fixed at a fixed scope and price, not on open-ended hours. Ours is Ship Fix at $4K to $15K by scope. The point of this stage is to make the app boring: known, guarded, and safe enough that ongoing work is maintenance rather than firefighting.
04
The ongoing relationship
Only now does a retainer make sense, because now both sides know what they are signing. Depth varies: monitoring plus fixes as they surface, or a senior engineer in every critical loop. Ours is Continuum, at $500 to $1,500 per month for Care and $3,000 to $15,000 per month for Partner.

Mapped to our ladder, plainly: Ship Check is the assessment mechanism, $299 fixed, and it produces the written read whether or not you continue with us. Ship Fix is the stabilization pass, $4K to $15K by scope. Continuum is the relationship: Care at $500 to $1,500 per month keeps the exposure handled as the app changes, and Partner at $3,000 to $15,000 per month puts a senior engineer in every critical loop, which is the takeover in its fullest form. The fractional CTO pricing guide shows how that band compares to the wider market, and the SaaS maintenance cost guide covers what ongoing ownership of an app like yours should cost in general.

If you want a zero-commitment first step before any of that, the free Leak Check reads your live URL in about a minute and tells you whether anything is exposed right now, which is worth knowing before you give anyone access to anything.

For the developer

Taking one over: how to do it without hating it.

The same sequence protects you from the other side. Never quote maintenance on a codebase you have not read; charge for the assessment, timebox it, and put the findings in writing, because the written read is what turns an unbounded liability into a scoped job. Assume the founder's account of the app is sincere and incomplete: they know what it does, not how, and the support inbox knows things they do not.

Refuse the hostage position too, in reverse. Holding a client's repo or domain on your accounts feels like leverage and is actually risk: it makes every departure a fight and every fight your fault. Work inside their accounts, document what you change, and let retention come from being worth keeping. The founders reading this page are being told to demand exactly that, so the developers who already work this way are the ones who will get hired.

The standard

What to demand from any successor. Us included.

These four are not preferences. They are the difference between hiring an operator and acquiring a dependency.

D1
No hostage dynamics
You keep ownership of the repo, the domain, the database, and the infrastructure. The successor works inside accounts you control. Any arrangement where leaving them means losing access to your own product is a cage, however friendly the pricing.
D2
Documented exit terms
Written before the work starts: what happens to access, credentials, and in-flight work if either side ends it. A professional will have this ready. Reluctance to discuss the exit is information about the relationship.
D3
Proof of work, defined
A retainer needs a definition of what you receive each month: a report, closed findings, something you can verify. "We are keeping an eye on it" is not a deliverable. If proof of work is undefined, so is the work.
D4
Proof of retention
Firm age and career years are weak proxies; anyone can survive. The real signal is how long clients keep choosing the same operator when they are free to leave. Ask every candidate for their longest continuous client relationship, and ask what kept it alive.

On retention, hold us to the same standard. Our longest client relationship is 15+ years embedded as the technical partner for the same business, documented with the rest of the track record on the proof page. That number is the axis we think successors should be judged on: not how long a firm has existed, but how long clients keep choosing the same operator when leaving is easy. Ask every candidate the same question and listen for a specific answer.

Red flags and alternatives

What to walk away from, and where else to look.

Three patterns predict a bad takeover reliably enough to treat them as disqualifying. A rebuild-first pitch delivered before any assessment: nobody can know your app needs a rewrite without reading it, so a pre-read rebuild quote is a sales position, not an engineering judgment. A retainer with no defined proof of work: if you cannot say what you received last month, you did not buy maintenance, you bought reassurance. And access held on the vendor's accounts: the moment your repo, domain, or database lives under their login, the price of leaving is your product.

And because no single successor fits everyone: if your app needs deep product rework rather than stabilization and stewardship, a full rescue-and-rebuild engagement may fit better than our ladder. Justin McKelvey runs a Vibe Code Rescue at $25K to $50K over 4 to 8 weeks, starting with a free repo audit, with ongoing fractional CTO work reserved for clients after a first engagement, per his published pricing as of July 2026. General dev shops make sense when the verdict really is a ground-up rebuild and you need a team, not an operator. If your app was recently breached rather than merely fragile, start with the hacked-app guide first, because incident response comes before any handoff.

The honest summary: the handoff market is thin, the refusals are real, and the fix is process, not luck. Assemble the package, buy the assessment, keep your keys, and judge every candidate, including us, on retention and exit terms.

FAQ

Handing off a vibe coded app, straight answers.

Assemble a handoff package first: repo ownership, domain, hosting, database access, third-party keys, payment processor, analytics, support inbox, plus environment notes and an honest known-broken list. Then insist the developer run a paid assessment of the codebase before any retainer or rebuild quote. A professional successor reads before they promise. Everything transfers into accounts you own, never onto theirs.
Because the usual shortcut is missing. On a normal takeover, the developer can ask the previous author why things are the way they are. On a vibe coded app nobody wrote the code, so the founder cannot answer why questions, and the developer has to reconstruct intent from the code alone. That work is slow, hard to estimate, and drains people who are used to greenfield speed. Some developers decline outright; the ones who do this well have made reading unfamiliar AI-generated code a deliberate specialty with a process around it.
A credible path starts small: an assessment in the low hundreds, a stabilization pass in the low four to low five figures, then an ongoing arrangement that ranges from hundreds per month for monitoring-plus-fixes to five figures per month at fractional CTO depth. Our published ladder is Ship Check at $299 for the assessment, Ship Fix at $4K to $15K for the stabilization, and Continuum at $500 to $1,500 per month for Care or $3,000 to $15,000 per month for Partner, which is fractional CTO depth. Full takeover-and-rebuild engagements elsewhere run considerably higher; Justin McKelvey publishes a $25K to $50K band for his Vibe Code Rescue as of July 2026.
Read access to the repo and the hosting dashboard is enough for an assessment. Full takeover needs more: deploy rights, database access, and visibility into the third-party services the app depends on. The rule that matters is direction of ownership. You add them as a member of accounts you control. If a successor asks you to move the repo, domain, or database into accounts they control, that is a hostage dynamic in the making, and you should refuse.
Almost never as a first move. A working app with real users carries months of validated behavior that a rewrite throws away, and a rebuild quote made before anyone has read the code is a guess dressed as a plan. The honest sequence is assessment first, then a verdict with evidence. Sometimes the verdict genuinely is rebuild, and a good assessment will say so and point you at rebuild specialists rather than selling you maintenance. But rebuild-first without a written read of the codebase is a red flag, not a plan.
Set the exit terms before the engagement starts, while everyone is still friendly. You keep ownership of the repo, domain, infrastructure, and every third-party account. The successor documents what they change, so the next person can pick it up. And ask for proof of retention: not how long the firm has existed, but how long clients have kept choosing the same operator. An operator who expects to be judged on staying has no incentive to build a cage.

Hand it to someone
who expects to be judged on staying.

30 minutes, no pitch. Bring your half-finished handoff package.Fixed-price assessment, written read of your codebase, yours to keep.

If we are the wrong successor for your app, the assessment will say so, and you keep the document either way.

Matt

Last updated: July 2026