# AI Builds Apps From Prompts. So Why Buy This?

> Agents output code, not outcomes: no decisions, no liability, no 2am accountability. Why a $199 kit of pre-made decisions beats free generation. Inside.

Source: https://boringpush.com/blog/why-boringpush-when-ai-builds-apps

## The demo ends where the business begins
Watch an agent build a SaaS app from one prompt: auth screens, pricing page, dashboard with charts — ten minutes, genuinely impressive. Then ask the follow-ups businesses require: whose Stripe account collects, where webhooks dedupe, what happens when the database fills, who gets paged at 3am.

Silence. Not failure — absence. The demo answered "can it render" and nothing else. Rendering was never the business; the business is everything after render that agents can't sign for.

Ai agents vs boilerplate debates confuse output with outcome the way demos confuse trailers with films. Trailers are exciting. Films need endings.

## Generated vs decided, side by side
| Business requirement | Prompt-generated app | Decided kit |
|---|---|---|
| Who owns the 3am page | Nobody (model sleeps) | You, with alerts wired |
| Webhook retries | Untested (happy path only) | Deduped, drilled |
| Database year two | Whatever it guessed | Switchable by variable |
| Bill at scale | Surprise (meters everywhere) | Flat ($5, modeled) |
| Liability for bugs | None (licensed as-is) | Yours (readable, owned) |
| Decisions documented | None (vibes in chat) | Files (law with history) |

Three details the DHH shelf would underline:

1. **Software is liability, not text.** "Getting Real" preached clarity over mass; "REWORK" preached owning outcomes. Generated code transfers zero liability — when it breaks prod, the model is already onto the next prompt.
2. **Constraints beat options at 2am.** "Shape Up" bets on fixed appetites and bounded scope — creativity inside fences. Unconstrained generation produces infinite options (four auth patterns, three billing shapes) and zero answers. Decisions are what ship; options are what demo. A kit is 500 decisions pre-made by people who paid for them with incidents.
3. **Boring is a feature, exciting is a tax.** Basecamp's whole canon argues ordinary tools, owned infrastructure, calm operations. Agent output trends novel (new dependencies, clever patterns, framework-of-the-week idioms) — excitement billed hourly at debug time. BoringPush is boring on purpose: the excitement budget goes to product, never plumbing.

The opencode post blamed missing conventions. This one prices missing accountability.

## Buy decisions, generate inside them
Use agents plenty — inside fences, against specs, behind gates. The kit is the fences.

**Step 1 — Buy the 500 pre-made decisions.**

```md what $199 actually purchases (not code — verdicts)
database: SQLite default, flip by variable (no week-two gamble)
billing: 3 rails, one interface, dedupe built in (no retry roulette)
auth: Google + magic, portable sessions (no lock-in lottery)
deploys: Vercel or $5 VPS, one push (no SaturdayYaml)
agents: lock file + shapes + gate (no unsupervised sprawl)
```

Each verdict cost someone an incident before it became a default — bought experience, amortized across every buyer. Generating equivalents takes quarters (decide, break, learn, encode); buying takes an afternoon (read, verify, ship). Verdicts are the product; code is the packaging.

**Step 2 — Generate volume inside the verdicts.**

```bash
# the division of labor that actually works:
# kit decides: schema shapes, provider verbs, route limits, migration law
# agent executes: features per spec, branches per task, proof per handoff
# founder disposes: reviews diffs, runs gates, pushes to prod, owns 3am
```

Agents at maximum throttle inside minimum fences: fast generation, bounded blast radius, proof-gated merges.

**Step 3 — Own the outcome end to end.**

```bash
# ownership checklist (the part no prompt covers):
# alerts reach YOUR pocket (Telegram, 2 seconds) → YOU diagnose (logs, monit)
# YOU approve (branch + proof) → YOU push (production remote) → YOU sleep (quiet channel)
```

Ownership is the whole game the demo skips: pager, judgment, accountability, sleep quality. Kits wire the machinery (alerts, logs, rollbacks, drills); founders supply the signer. No model stands behind its output at 3am — which is fine, as long as someone does. Be that someone, armed with boring tools.

So that's the playbook — generated fast, decided once, owned always.

## Generated-only vs decided-plus-generated
| Quarter, solo founder | Prompt-only stack | Kit + agents |
|---|---|---|
| Time to first demo | 1 day (dazzling) | 1 weekend (gated) |
| Time to first revenue | Months (plumbing!) | Days (checkout day one) |
| Midnight incidents | Several (unowned edges) | ~Zero (fenced + alerted) |
| Codebase comprehension | Falling (whose code?) | Full (reviewed diffs) |
| Database switch cost | Rewrite quote | Afternoon errand |
| Total quarters to profit | Unknown | Measured in weeks |

Cost, admitted: $199 plus opinionated defaults (someone else's verdicts, occasionally disagreeable) against free generation plus full freedom (every decision yours, every incident too). Priced against incident evenings and plumbing quarters: decisions bought cheap, freedom itemized honestly. Pay for judgment once; generate volume forever after.

## FAQ

### Is ai agents vs boilerplate even a real debate, or a strawman?
Real enough to cost real quarters: founders do attempt prompt-only stacks, hit the plumbing wall (auth edge cases, webhook retries, database reality), and either quit or buy the kit late — after paying the tuition of trying. The debate resolves empirically wherever it's run: generation dazzles week one, decisions pay from month two. Run the experiment cheaply (one feature, timed) if unconvinced.

### Should agents write the kit's code instead of buying it?
They'd reproduce it badly: the kit's value is verdicts (which database default, which paywall shape, which migration law), and verdicts require incident history agents don't have. Agents execute excellently inside decided systems and decide poorly outside them. Buy verdicts from the scarred; assign execution to the tireless. Division by comparative advantage, not enthusiasm.

### What about "vibe coding" the whole SaaS in a weekend?
Weekends produce demos; businesses need Tuesdays through Thursdays (refunds, edge cases, support tickets, tax paperwork). Vibe-coded launches that survive share one trait: their builders retrofitted decisions afterward (paywalls, dedupe, backups — the unsexy list). Skip the retrofit by starting decided: weekend speed plus Tuesday durability, same 48 hours.

### Do better models eliminate the need for kits?
Stronger models generate subtler bugs (correct-looking, wrong-meaning) and bigger diffs (more to review, more to own) — capability gains flow into output volume, not outcome ownership. The 67% debugging figure persists across generations precisely so. Models improve drafting; decisions, liability, and 3am still need an owner. Bet on workflow plus models, never models alone.

### When SHOULD a founder skip the kit and prompt everything?
Learning expeditions (education is the deliverable), throwaway prototypes (lifespan under a month), and framework research (evaluating patterns deliberately). Plus the genuinely cash-zero (time rich, $199 poor — prompt away, buy from first revenue). Exceptions named and bounded; the default stays decided. Know your exception or you're living in it.

## Keep reading

- [OpenCode SaaS Starter: Stop the Every-Session Redesign](/blog/opencode-saas-starter) — the conventions agents obey
- [Build Features With AI That Don't Need Rewrites](/blog/build-feature-with-ai-data-first) — the pipeline verdicts enforce
- [Solo Founder? Don't Let AI Ship Your Features](/blog/solo-founder-ai-ship-features) — the ownership split, in full

If you can think it, BoringPush can make it — decisions included, outcomes owned, excuses retired.