# Emergent ships fast previews; a kit owns the production repo you keep

> Emergent is a sandboxed AI app builder. When you need a repo Claude Code and Cursor can keep shipping, own a full-stack kit instead of another credit loop.
> By Dave · 2026-09-10
> Source: https://otf-kit.dev/blog/otf-vs-emergent

## Sandboxed agents ship demos. Production needs a repo you own.

Emergent is an AI app builder in the same sandboxed-agent class as Lovable, Bolt, and Rork. You describe a product in natural language; the platform generates web or mobile software, hosts projects, and can integrate with GitHub so you can download or keep iterating on the generated code. That is a real product for getting from idea to a working preview quickly.

The ICP question for OTF readers is narrower. You are already using Claude Code, Cursor, Codex, Lovable, or Bolt. You hit the scaling wall when the demo needs auth that matches your tenants, payments that match your Stripe account, native builds that survive App Store review, and conventions a coding agent can keep following six months later. At that point the useful artifact is not another chat session. It is a repository with deploy scripts, schema, and agent instructions.

This post maps Emergent to that decision, using Emergent’s own positioning as the primary source, and contrasts it with owning a full-stack kit that is already wired for filesystem agents.

## What Emergent optimizes for

Emergent markets prompt-to-app building for websites, mobile apps, dashboards, and SaaS tools. Pricing is credit-based, with published plans for individuals and power users plus enterprise options. The FAQ states that generated code is yours, GitHub integration exists for version control, and you can download, modify, or host applications elsewhere.

That package is strong when:

- Speed from blank idea to interactive preview matters more than owning infra day one
- You are comfortable iterating inside Emergent’s agent loop and credit model
- “No coding required” is a feature, not a compromise
- Export or GitHub sync is enough of a handoff for your next step

It is a weaker fit when:

- Your coding agent needs a durable monorepo with CLAUDE.md / `.cursorrules` / tested prompts as first-class deliverables
- Production means your Railway/EAS/Supabase stack, not a vendor-hosted project that you later reverse-engineer
- Cross-platform shipping (Expo + web export + API) must share one product domain model from day one
- You are comparing tools as if Emergent were a UI library — it is not; it is a sandboxed generation product

The catalog row for Emergent is explicit: sandboxed generation with the same production-handoff gap as the rest of that tier. OTF’s stated advantage on that row is real working code you own from message one, shaped for Claude Code and Cursor rather than for staying inside a builder sandbox.

## The production handoff is the product

A sandboxed agent can generate a booking screen, a dashboard chart, or a mobile shell. The handoff fails in predictable places:

1. **Conventions** — Your team’s folder layout, auth middleware, and design tokens are not the agent’s default. Without a kit that already encodes them, every new prompt re-discovers the house style.
2. **Privileged work** — Stripe webhooks, service-role database access, and reminder crons need a server boundary. Prompt-built apps often blur that line until a security review forces a rewrite.
3. **Native release** — Expo projects need EAS profiles, store metadata, and CI. A mobile preview is not an App Store pipeline. See the Rork gap for the same class of failure on mobile sandboxes: [Rork can scaffold React Native; it cannot follow you to the App Store](/blog/rork-cant-ship-to-app-store).
4. **Agent continuity** — Filesystem agents win when they can read the whole repo. That is the thesis in [sandboxed vs filesystem agents](/blog/sandboxed-vs-filesystem-agents). Emergent can export code; OTF starts as the code shape those agents already expect.

None of that means Emergent is useless. It means you should treat it like a prototype accelerator, then decide whether your production system of record is Emergent’s project or your own kit repo.

## What owning a kit changes

A shipping OTF kit is a product starter with a buyer mirror, preview URL, and agent docs. Booking kit is one example already documented in the recent Cal.com comparison: Expo SDK 54, Supabase RLS + `available_slots()`, Hono for Stripe/Resend, live preview at `booking-preview.otf-kit.dev`, and delivery through `sync-kits.yml` to `otf-kit/booking-kit`. Fitness kit and saas-dashboard follow the same delivery class.

The difference is not “AI vs no AI.” Kits ship `CLAUDE.md`, `.cursorrules`, and tested prompts so Claude Code and Cursor extend a known architecture. Emergent’s loop is prompt → generated app inside its platform. OTF’s loop is prompt → change files in a repo that already deploys.

If you are leaving Lovable or Bolt because the export is messy, Emergent will feel familiar: fast preview, credits, hosted projects, optional GitHub. The scaling wall returns when you need the same invariants the kits already encode — exclusion constraints on bookings, RLS on profiles, EAS update channels, Railway Docker for Expo web + API.

## Decision table

| Question | Prefer Emergent | Prefer an OTF kit + Claude Code / Cursor |
|---|---|---|
| Primary job | Idea → working app preview fast | Idea → owned production repo |
| Where code lives long-term | Emergent project (+ optional GitHub) | Buyer repo from day one |
| Who owns deploy | Emergent hosting / your later migrate | Your Railway / EAS / Supabase |
| Agent model | Sandboxed builder agents | Filesystem agents on a known kit |
| Best next step after demo | Export or keep iterating in-product | Extend screens, schema, prompts in-repo |

## How to choose without rewriting twice

1. **Write the job.** If the job is “prove the idea this week,” Emergent fits. If the job is “ship tenants next month with our infra,” start from a kit.
2. **Name the handoff.** GitHub sync is necessary but not sufficient. Ask whether the export includes auth, payments, and release scripts you will keep.
3. **Budget for agent work.** If Claude Code is your daily driver, prefer a repo that already speaks its language.
4. **Do not confuse tiers.** Do not fold Emergent into a shadcn/UI-library compare page. Emergent is a sandboxed-agent competitor row, same class as Lovable and Bolt.
5. **Keep both when useful.** Some teams prototype in Emergent and rebuild the production surface on a kit once the domain model stabilizes. That is a sequence, not a contradiction.

## Bottom line

Emergent is a capable sandboxed AI app builder: prompts, credits, web and mobile generation, GitHub integration, and code ownership claims on its own site. OTF’s wedge is not “faster prompts.” It is a production-shaped repo for builders who already use filesystem coding agents and need to leave the sandbox without losing the product.

If you are choosing between another sandboxed session and a kit you can keep shipping, choose the artifact you will still open in Cursor after the credits reset.

## Sources

Emergent product site (positioning, pricing FAQ, code ownership / GitHub claims): https://emergent.sh/