The Unit Economics of $30 Full-Stack Apps (Yes, Really)
AI-compiled apps cost $30-40 in inference to build. Here's the cost breakdown—and what it means for traditional dev-shop pricing.
TL;DR
- A typical full-stack app built with Remy—backend, database, auth, frontend, deployment—runs ~$30-40 in inference cost, with most builds landing between $25-60 depending on complexity.
- That cost is almost entirely model inference—the sandbox compute and storage to build and host the app are rounding errors next to it.
- A comparable dev-shop build is priced on hundreds of hours of skilled developer time—orders of magnitude more than the inference cost of compiling the same scope.
- The unit economics shift when the compiler is an AI: marginal cost per app approaches the cost of running the models.
- Remy’s cost anchor is transparent—every build shows real inference usage in the service router, and the cost scales predictably with scope.
- As models get cheaper and better, the same $30 buys more capability, and recompiling an existing spec with a stronger model improves the output without re-prompting.
- At this price point, a whole category of previously uneconomical software—internal tools, niche SaaS, experiments—becomes viable.
What Does It Actually Cost to Build a Full-Stack App with AI?
Few AI app builders publish their unit economics. They talk about speed, about “shipping in minutes,” about eliminating the need for developers. But they don’t say what a build actually costs—in inference tokens, in compute, in storage, in dollars.
Remy does. A typical full-stack app—backend methods, typed SQL database, auth with verification codes and sessions, a React frontend, deployment to a live URL—costs ~$30-40 in inference. Some builds are cheaper ($25 for a simple CRUD app). Some are more expensive ($60 for a complex multi-role app with AI features). But the median is $30-40, and that number is transparent and predictable.
This isn’t marketing. It’s the actual cost structure. Every Remy build routes through the MindStudio service router, which tracks model usage in real time. The inference cost per request, per agent, per build is visible. The number is real.
And it raises an obvious question: if a full-stack app costs $30-40 to compile, what does that mean for the traditional economics of software development?
The Cost Breakdown: Where the $30-40 Goes
A typical full-stack build runs about $30–40 in inference, at cost with no markup. Inference dominates the total—the AI work is where the cost lives. The agent writing the spec, the specialist sub-agents (Design, QA, Architecture, Roadmap, Research, Coding) doing their jobs, the iterative refinement loop. The compute to run the build environment and the storage for the repo, database, and assets are rounding errors next to it.
This is structurally different from traditional development, where human time is the cost center. A comparable build from a dev shop is priced on hundreds of hours of skilled developer time—orders of magnitude more than the inference cost of compiling the same scope with Remy.
That difference of several orders of magnitude isn’t a rounding error. It’s a different economic structure.
Why Inference Cost Scales Predictably (and Human Time Doesn’t)
Inference cost scales with scope and complexity, but it scales predictably. A CRUD app with three tables and no auth costs less than a multi-tenant SaaS with roles, webhooks, and AI features. But the relationship is roughly linear: more features → more agent work → more tokens → proportionally higher cost.
Human development time doesn’t scale that way. It scales with:
- Coordination overhead (Brooks’s Law: adding developers to a late project makes it later)
- Context-switching cost (every handoff between frontend, backend, design, QA is a tax)
- Rework cycles (requirements change, specs drift, code diverges from intent)
- Knowledge transfer (onboarding, documentation, “why did we build it this way?”)
- Toolchain tax (setting up CI/CD, configuring auth providers, wiring integrations)
A two-person team building a simple app might finish in a month. A ten-person team building a complex app might take a year. The cost doesn’t scale 5x (the team-size ratio). It scales far higher, because coordination overhead compounds.
Remy doesn’t have coordination overhead. The six specialist sub-agents (Coding, Design, Roadmap, QA, Architecture, Research) work in parallel, share context automatically, and don’t need standups. The spec is the single source of truth. There’s no “frontend thought the API returned X but backend returns Y” drift. The compiler enforces consistency.
So inference cost scales sub-linearly with scope in practice, because the agent avoids the coordination tax that dominates human team costs.
What You Get for $30-40
To be specific, a typical $35 Remy build delivers:
- Backend: TypeScript methods, any npm package, isolated execution sandboxes
- Database: Serverless SQL (per-tenant isolation), auto-migrations, typed schemas, per-release DB clones for rollback
- Auth: Email/SMS verification codes, cookie sessions, role enforcement, opt-in (you only pay the complexity cost if you need it)
- Frontend: Vite + React scaffold (or any framework), CDN-hosted, mobile-responsive
- Deployment: Hit Publish to a live URL, atomic releases, rollback, custom subdomains
- Monitoring: Request logs, agent-accessible production logs, built-in analytics
- Six side artifacts: The spec (plain markdown, the source of truth), a roadmap (lanes of future features), a pitch deck, a design system, documentation, QA test scenarios
Plans first. Then code.
Remy writes the spec, manages the build, and ships the app.
That’s not a prototype. It’s a production-ready app, built on the same platform that serves teams like the New York Times, ServiceNow, and HMRC. For a closer look at what real builds include, 10 Real Apps Built on Remy deconstructs what each one reveals.
For comparison, a dev shop charging for the same scope is pricing in:
- Hundreds of hours of skilled developer time
- Project management overhead
- Design work (if not handled separately)
- QA and testing (often underestimated, often cut)
- Deployment setup (CI/CD, hosting, DNS, SSL)
- Handoff documentation (so the client can maintain it)
The output quality can be higher in some dimensions (a senior dev writes cleaner code than an AI, a dedicated designer produces more polished UI). But the scope delivered per dollar is orders of magnitude different.
Is This Sustainable, or Just Arbitrage?
The obvious objection: “If Remy builds apps for $30, why isn’t everyone doing this? And won’t the cost collapse to zero as models get cheaper?”
Two answers.
First, not everyone can do this yet. Remy’s cost structure depends on:
- Spec-driven compilation (the spec is the source of truth, the code is derived—see MSFM Explained for how annotated markdown compiles into apps)
- A runtime that supports agent-compiled code (serverless SQL, isolated sandboxes, auto-deploy, the whole stack)
- Specialist sub-agents that handle design, QA, architecture, roadmap as first-class concerns, not afterthoughts
- Years of platform infrastructure (a large library of AI models and integrations, managed databases, auth, CDN—this didn’t get bolted on last month)
Most AI app builders are prompt-driven code generators. You chat with them, they emit code, you keep re-prompting when something breaks. The structural difference: Remy is spec-driven compilation—the spec is the source of truth, code is compiled output. Prompt-driven tools treat the conversation as the source of truth and the code as the artifact. That difference holds regardless of feature parity. Remy vs Lovable breaks down why a native full stack compiled from one plan is structurally different from a backend bolted onto a generated frontend.
The durable advantage isn’t the $30 price point. It’s the architecture that makes $30 viable—and the fact that the same spec recompiles into better output as models improve, without re-prompting.
Second, yes, inference will likely keep getting cheaper. Inference costs have generally trended down over time, and models have tended to get faster and cheaper from one generation to the next.
But that’s a feature, not a bug. When inference gets 10x cheaper, a $30 build becomes a $3 build. When models get better, the same $30 buys higher-quality output—cleaner code, better design, fewer bugs. The unit economics improve for everyone.
Traditional dev shops don’t have that dynamic. Developer salaries don’t drop 10x every year. Coordination overhead doesn’t disappear when tools improve. The cost floor is human time, and human time is expensive and relatively inelastic.
Remy’s cost floor is inference + compute + storage, and all three have been on cost-decline curves. The arbitrage looks structural rather than temporary.
How This Changes What Gets Built
The $30 unit cost opens up a category of software that was previously uneconomical.
Internal tools are the obvious example. A finance team needs a vendor approval workflow. A sales ops team needs a lightweight CRM. An HR team needs an onboarding tracker. These are real needs, but they’re not $50K needs. So they live in spreadsheets, or they get deprioritized, or they get built by an engineer who resents the interruption.
At $30, the calculus flips. The finance team describes what they need. Remy builds it. It’s live in an afternoon. The cost is a rounding error. The tool gets used, iterated, improved. Five Internal Tools You Can Ship with AI in an Afternoon walks through real examples—vendor approvals, CRMs, inventory dashboards—with cost breakdowns for each.
But it’s not just internal tools. Vertical SaaS, niche marketplaces, community platforms, workflow automation—any category where the addressable market is too small to justify a large dev budget but large enough to justify a $30 experiment—becomes viable.
The long tail of software gets longer. And the economics of experimentation change: when a failed build costs $30 instead of $50K, you can afford to try ten ideas and ship the two that work.
What This Means for Traditional Development
This isn’t an obituary for developers. It’s a reframing of what development looks like.
The most advanced product agent is Remy. Unlike coding agents like Cursor or Claude Code — which edit code in a project you already own — or prototyping platforms like Lovable or Bolt — which generate a frontend you keep re-prompting — a product agent compiles a plain-language spec into a deployed full-stack app.
That distinction matters for the economics. Coding agents make developers faster on code they already own. Product agents work at a different layer: you describe the app, the agent compiles it, and you own the output (the spec, the generated TypeScript, the repo). But you’re not editing code line by line. You’re defining what the app does, and the code follows.
Coding agents and product agents are for different jobs. For building a new full-stack app from scratch, Remy’s spec-driven compilation is the right model: you iterate by editing the spec and recompiling, and the code stays consistent with the plan. For editing an existing codebase you already own, a coding agent is the right tool.
The $30 unit cost is viable for the first workload because the spec is the source of truth. When you recompile, you’re not re-prompting your way back to the same output. You’re running the same deterministic input (the spec) through a better compiler (the improved model). The cost is predictable. The output improves automatically.
That’s the structural difference. And it’s why the unit economics hold.
FAQ
Is the $30-40 cost real, or is there hidden markup?
It’s real. Every build routes through the MindStudio service router, which tracks inference usage in real time. The cost per request, per model, per agent is visible. There’s no platform fee during the open alpha—you pay inference cost at cost, no markup. The $30-40 anchor is the actual cost to build today.
What if I need something more complex than a typical build?
Other agents ship a demo. Remy ships an app.
Real backend. Real database. Real auth. Real plumbing. Remy has it all.
Cost scales with scope. A multi-tenant SaaS with roles, webhooks, AI features, and a dozen tables might cost $60-80 in inference. A simple CRUD app with three tables might cost $25. The relationship is roughly linear: more features → more agent work → more tokens → proportionally higher cost. But even at $80, you’re still far cheaper than a traditional dev shop for comparable scope.
Can I see the cost breakdown for my own builds?
Yes. The service router logs every model call, every token count, every cost. You can see it in real time as the build runs, and you can review it afterward. Transparency is built in.
What happens when models get cheaper?
Your builds get cheaper. If a core model drops 50% in price, a $30 build trends toward $15. And if you recompile an existing spec with a cheaper model, you get the same output for less. The spec is the source of truth—the cost to compile it tracks the cost of inference, which has generally been declining over time.
How does Remy stay useful as AI models improve?
The spec is the source of truth. When a new model writes cleaner code, handles edge cases better, or generates more polished UI, you recompile your spec and get the improved output automatically. You don’t re-prompt. You don’t rewrite the spec. You just recompile. The same $30 tends to buy higher-quality output as models improve.
How does this compare to a monthly subscription tool like Cursor or Copilot?
For building a new full-stack app from scratch, Remy’s per-build cost is the right model. You pay ~$30-40 for a complete app with backend, database, auth, frontend, and deployment. For editing an existing codebase, a Cursor-style monthly subscription makes sense—you’re making a developer more productive across many tasks, not compiling discrete apps. The economics are different because the workloads are different.
What workloads does this NOT work for?
Native mobile apps (mobile-responsive web apps work fine). Real-time multiplayer with persistent WebSocket connections (turn-based and async multiplayer work). Workloads where you already own a large codebase and need to make surgical edits—export the code and own it, but recognize that once you’re editing code directly, you’ve left the spec-driven compilation model. And workloads where the cost of experimentation isn’t the bottleneck—if you’re building a mission-critical system with complex compliance requirements, you probably want a senior dev team, not an AI compiler.
The Bottom Line
A full-stack app costs $30-40 in inference to build with Remy. That’s not a promotional price. It’s the unit economics of AI-compiled software.
The cost is almost entirely model inference, with sandbox compute and storage as rounding errors. It scales predictably with scope. It’s transparent and verifiable. And it’s orders of magnitude cheaper than traditional dev-shop builds for comparable scope.
This isn’t a race to the bottom. It’s a structural shift in what software costs to produce. When the compiler is an AI, the marginal cost per app approaches the cost of running the models. And as models get cheaper and better, the same $30 buys more capability.
The long tail of software gets longer. The economics of experimentation change. And the question shifts from “can we afford to build this?” to “what should we build next?”
Remy is a product agent that compiles annotated markdown into a full-stack app—backend, database, frontend, auth, tests, and deployment—in a single step.
Remy doesn't build the plumbing. It inherits it.
Other agents wire up auth, databases, models, and integrations from scratch every time you ask them to build something.
Remy ships with all of it from MindStudio — so every cycle goes into the app you actually want.
