GitHub handoff after an AI builder (2026)

Citation-ready definition: GitHub handoff after an AI builder in 2026 is the evidence sequence that proves a company organization owns the remote, a second human can merge, and CI rebuilds the app without a Lovable, Bolt, Rork, FlutterFlow, Cursor, v0, or Replit login. You take the export or two-way sync and make it org Git. Connecting the builder to GitHub is not the handoff.

The expensive 2026 failure is rarely “we never connected Git.” It is “we bought traffic on a personal repo, with keys in the first commit, and a build that only the founder can run from the builder tab.” A converting preview hides that gap. A second hire, a locked laptop, or a revoked GitHub app will not.

This article is the organization Git + second-engineer ship playbook after any AI builder. It expands the short punch list on GitHub handoff into essay depth. It is not the database evidence on Supabase hardening after an AI builder, not the founder calendar on AI-builder exit plan for founders, and not the stay/harden/rewrite verdict on rewrite vs harden. Those pieces stay the Postgres proof, the weeks, and the layer marks. This page is who can clone, review, and rebuild. Soft CTA: when the org seat or CI is ambiguous, book.

Use the short landers for punchy lists: GitHub handoff is the org-remote clipboard; CI/CD checklist is the train after the remote is owned; ship checklist is the release ritual; production-ready is the operating contract; MVP hardening is the pre-ads list; AI builder exit is the six ownership boxes. The vibe coding hub maps tool exits. This long-form essay stays the Git proof.

Why a connected repo is still a hostage

AI builders are paid to make the preview work tonight. Git is paid to survive a person leaving. Those incentives collide. The generated tree looks finished because the canvas can push. The company is unfinished because nobody can rebuild without the founder’s login.

GitHub is explicit about the seat that matters. An organization is a shared account. People still sign in as themselves. The company owns the work. A personal repo with two outside collaborators is not that. Transferring a repository moves issues, pull requests, webhooks, and secrets with the tree. After the move, the org’s default permissions apply. Transfer a private repo onto GitHub Free and you lose protected branches. That is a plan fact, not a footnote.

Five hostage patterns show up after a builder export:

1. The remote sits on a personal account. Billing, admin 2FA, and who can add a collaborator leave with one human. The company cannot recover the source on a Friday.
2. Main accepts force-push and laptop deploys. Protected branches exist so a pull request and a required check stand in front of `main`. Without them, the next merge is folklore.
3. The first export committed `.env`. Keys in history outlive the chat. Rotation is the fix. Archaeology is second.
4. CI only runs inside the builder. A green preview tab is not a workflow file. If GitHub Actions cannot install and build on a runner you do not sit at, you do not have CI.
5. Nobody else has shipped a trivial pull request. If the only path is “ask for the ZIP and the password,” handoff failed—even if a repo URL exists.

None of that is a reason to rewrite the screens. It is a reason to stop buying ads until a second person can clone, open a pull request, and watch CI go green without opening Lovable, Bolt, Rork, FlutterFlow, Cursor Cloud Agents, v0, or Replit. If you cannot name that person, mark the host/CI layer on rewrite vs harden.

Ownership map: seats Git actually needs

The founder exit calendar seats Git as one door among six. This page seats the remote. Handoff is complete when a second person, using a company org seat, can merge a pull request whose required check builds the app without a builder login. Until then you are renting a tree.

Write the proof next to the name. “We have GitHub” is false until the repo lives in a company organization and a second owner can open it. “We have branch protection” is false until a direct push to `main` is denied. “We have secrets” is false until deploy keys sit in Actions secrets—not in a README. Organization secrets do not reach private repos on GitHub Free. Do not discover that on launch day.

Builder docs do not contradict this. Lovable Git sync keeps code and migration files, never the rows. Bolt auto-commits; it does not merge in-app. Rork exports paid code through GitHub. FlutterFlow overwrites `flutterflow`. Cursor’s GitHub app is for Cloud Agents and Bugbot—not an exit. v0 makes the repo the source of truth. Replit zips or syncs the tree. Secrets and the database stay behind.

Evidence gates: mark once, then refuse slides

A working session should produce marks, not vibes. Open the GitHub org, the builder Git settings, and a second laptop that has never opened the builder. Walk each gate once. Until a second human’s pull request is green on a runner you do not sit at, you do not know whether the tree stands alone.

Close a gate with an artifact. “We transferred” is not evidence until `git remote -v` on a clean machine prints the org URL. “We protected main” is not evidence until a direct push fails—GitHub’s example is `GH006: Protected branch update failed`. “We have CI” is not evidence until the required check has a unique job name; reused names make status checks ambiguous. “We rotated secrets” is not evidence until the old token fails and the new one lives only in Actions or a vault.

The second-engineer ship is the gate this page exists for. A clean clone. A documented env bootstrap. One trivial pull request. CI green. A preview or deploy they trigger. If they still need the founder’s builder tab, stop. The CI/CD checklist is the train shape. This page is whether you are allowed to be laying track yet.

What Git does not move

Operators lose weeks assuming a green clone is a product exit. It is a tree. Name what stayed behind before you cancel the builder.

Lovable’s FAQ is the cleanest vendor sentence in this class: the repository holds code and migration files, never the data. Pushing does not publish. Reconnecting creates a new repository. Bolt’s disconnect is permanent; after you cut the wire you fall back to Version History. v0 says the connected repo is the source of truth—and that deleting it may make the code unrecoverable. Sync moves code. It does not grant permission to deploy through GitHub or the Vercel CLI. Replit cannot transfer a project. A zip leaves secrets, the database, and deployment config behind. Editor secrets are not deployment secrets.

Treat those facts as an inventory, not as a rewrite brief. Seat the remote. Then walk the other doors on the founder exit plan. If the gap is Row Level Security, leave this page and open Supabase hardening.

Week sequence: transfer before traffic

The founder calendar sequences seats. This sequence sits inside those weeks and owns the remote. The ranges below are studio-observed operator weeks for a small product with a readable tree—not a bid and not a vendor SLA. Reserve the calendar. Feature work only the founder can push waits until the matching gate has a name.

Read the chart as a reservation, not a promise. Week 0 is cheap: if you cannot list the clone URL, the org owners, and every pasted token, later weeks thrash. Week 1 is the transfer. Weeks 1–2 land a workflow and a rotated key. Week 3 is the first week that feels like a team. The last bar is the silent kill: a prompt sprint that never left a personal account.

Overlap the bars when you have two humans. Do not overlap them with a paid feature only the founder can ship. A prompt that adds payments or a new host waits until the second-engineer pull request is green. The production-ready gate still applies: no cutover without a tested rollback. The ship checklist is the go/no-go; this page is whether a second person may join that ritual yet.

Builder-specific notes — not a noun-swap FAQ

The gates are shared. The first proof is not. Do not paste a Lovable reconnect onto a FlutterFlow `flutterflow` branch, or a Bolt disconnect onto a v0 Vercel role, and call the handoff done.

Lovable is export-only. You cannot import an existing repository. One project links to one repo on one provider. Lovable edits one branch at a time. If the histories diverge, Lovable pushes its side to `lovable-sync` and the next GitHub pull replaces Lovable’s copy. Do not move or delete the connected repo. Do not rename the account or org. A paid download is a snapshot. Sync is the paper trail. Tool-exit lists stay on get off Lovable and get off Lovable without a full rewrite.

Bolt Git is owner-gated. Collaborators do not see the GitHub icon. Their edits sync the next time the owner opens the project. Bolt does not merge in the app. If both sides write at once, Bolt keeps its change and overwrites GitHub. Work on a feature branch. The lifecycle is honest: GitHub is how you set up your CI/CD tools. Bolt hosting is a different door. Product harden stays on Bolt MVP hardening without rewrite and get off Bolt.

Rork is paid-export. Paid users own the generated code and download it via GitHub. Share the repo. Open it in an IDE or Xcode. Keep building in Rork in parallel if you want. That is a tree door, not a store binary. The ship spine stays on transition from Rork to a shippable mobile app and get off Rork.

FlutterFlow is one-way overwrite. Custom code never lives on `flutterflow`. Create `develop` from that branch. Merge generated updates through a pull request. Canvas branches are not GitHub branches. Get off FlutterFlow is the tool exit; this page is whether `main` can survive the next push.

Cursor is an IDE. The GitHub app exists so Cloud Agents and Bugbot can clone and read checks. It reads branch protection. It does not replace it. Opening a prototype in Cursor is not a handoff. The store path lives on Cursor prototype to App Store / Play and get off Cursor.

v0 will create a private repository under the Git Scope you pick. Pick the company org. It pushes to a working branch and respects required checks. If protection blocks Publish, the pull request stays open. That is Git working. It is not proof a Vercel Viewer can deploy from GitHub. Get off v0 is the canvas exit.

Replit will zip the tree or connect Git with auto-sync. After you copy to another account, you re-enter secrets and rebuild the database. Get off Replit is the runtime exit. This page is whether the checkout you kept can build on Actions.

Kill criteria: pause features, not the product

A handoff without kill criteria is a wish. Write the date you will stop prompting to a personal remote, the date you will hire, and the evidence that sends you back to a bound rewrite of the host.

Pause feature work when any of these are true:

• Paid traffic, a partner demo, or store Submit is inside two weeks and the production remote is still a personal account, or only the founder can push.
• A live token still exists in a committed `.env`, a README quick start, or a chat transcript.
• CI cannot install and build with every builder tab closed.
• A new prompt would add payments, a native module, or a second host while `main` is unprotected.
• Two people disagree about who is org owner on GitHub.

Hire (or book a partner for a named gate) when the founder cannot be the second org owner and cannot land a workflow file; when history is dirty and nobody will rotate; or when week-0 inventory slipped past the kill date. Hire for org Git + CI + a second ship—not for a greenfield UI. Austin app development company is the studio brief if you want that conversation; Austin mobile app development if the next door is a store artifact that still sits on this remote.

Stop this handoff and reopen [rewrite vs harden](https://www.codecross.com/articles/rewrite-vs-harden-after-ai-builder-2026) only when the host/CI gate is irreparable: the tree cannot build outside the builder; secrets cannot be reproduced; or the only way to “make it work” is to keep the builder as the compiler. That is a verdict on the extract. Write it down. Do not “handoff” a tree you have proven no runner can compile by adding a prettier README.

If none of those have fired, keep the screens. Sequence the gates. The cheapest honest path in 2026 is org Git on DNA users already accepted—not a second codebase, and not another month of founder-only pushes.

FAQ

Does connecting Lovable, Bolt, or Rork to GitHub finish the handoff?

No. Sync is a pipe. Handoff is org ownership, a second maintainer, and a runner that builds with the builder closed. Lovable can be in sync and still publish only from Lovable. Bolt can auto-commit and still refuse to merge in-app. Rork can two-way sync and still hold Cloud data. Connecting Git is the start of this page, not the end.

Is a personal GitHub repo with two collaborators org-owned?

No. GitHub’s organization account is the shared container. Collaborators on a personal repo do not give the company billing, default permissions, or a second owner who can transfer. Transfer or recreate under the org. Then apply the org’s member privileges. Personal forks may exist for work. Production source of truth does not.

Does CI that only runs inside the builder count?

No. A preview tab is not a required status check. Land a workflow in the org repo. Give the job a unique name. Require that check on `main`. Prove a second person can open a pull request and watch it go green while every builder is closed. Use the CI/CD checklist for pipeline shape after that proof exists.

What if FlutterFlow overwrites the branch we edited?

That is the documented behavior. FlutterFlow always pushes to `flutterflow`. Edits on that branch are destroyed on the next push. Keep custom code on `develop`. Merge generated updates through a pull request. Protect `main`. If you cannot describe that three-branch path on a whiteboard, you do not have a FlutterFlow handoff.

Does transferring a repo move hosting, rows, and store seats?

No. A GitHub transfer moves the repository and the things attached to it—issues, pull requests, webhooks, Actions secrets, deploy keys. It does not move Lovable Cloud rows, Bolt or Replit databases, Vercel deploy roles, Apple, or Play. v0’s GitHub sync does not grant deploy permission. Replit copies leave secrets and the database behind. Seat those doors on the founder exit plan.

When do I pause new prompts versus bound-rewrite the host?

Pause prompts when the remote is still personal, a live key is still in history, or CI cannot build with the builder closed and traffic is close. Bound-rewrite the host when the tree cannot be reproduced outside the builder, or when secrets have no supported vault. Closable gaps—missing branch rules, a personal remote you can transfer, a workflow you can land—are handoff work on this calendar.

Is there a CodeCross github-handoff lander I should use instead?

Yes. Use GitHub handoff for the short punch list. This essay stays the evidence playbook for the gates. Use the CI/CD checklist and ship checklist when the gap is the train or the release ritual. Use the founder exit plan for the calendar around Git. Use what production-ready means after vibe coding for the operating contract.

Next steps

Walk the gates in order. Inventory the remote. Create the company org and a second owner. Transfer or recreate the production repo. Protect `main`. Scan and rotate. Land a workflow that builds with every builder closed. Have a second engineer ship a trivial pull request. Then—and only then—rehearse traffic. Pause any prompt that only the founder can push while a gate is red.

CodeCross LLC is an Austin-registered product studio (1606 Headway Cir STE 9212, Austin, TX). We help operators turn a generated export into a remote they can staff: org first, second maintainer second, a rewrite of the host only when the tree cannot build outside the builder. The Austin app development company page is the studio brief; Austin mobile app development is the store-binary engagement. Company-level evidence lives on proof. When you want a second pair of hands on the remote, book a conversation.

The goal is not to punish vibe coding. It is to stop treating a connected GitHub icon as proof that a stranger on your team can rebuild. Ownership of Git is evidence. Handoff is an org plus a second ship plus a runner. Get those three right and most teams never need a second codebase.