// pillar 02 β /build
π Build
The PRD goes in. A hosted product comes out. Then it's a conversation, not a codebase.
Pillar 02 β Build
π PRD in, live product out
β click a feature β the window follows
// the breakdown
Every module, all the way down.
build.01
App Builder
One run. Landing page to logout button.
From a scored, researched, briefed idea, the builder writes the PRD β product name, core loop, features with acceptance criteria, data model, and the landing page as part of the product, not an afterthought. Then it one-shots the whole app: hosted at its own URL with signup, auth, hash-routed views, full CRUD against a real data API, tracking beacons wired into every step of the funnel, and payments-ready product gates.
After it's live, you never 'develop' again β you talk. "Move the paywall to right after first end-use." "Tighten the mobile hero." Chat edits apply surgically to the running app. Improvement sprints run bigger passes; agent-mode adds a merciless review pass that finds dead buttons and broken flows and fixes them before you ever see them.
Time to live
one run
Interface
conversation
Tracking
funnel-wired at birth
Payments
gates ready day one
build.02
Template builds
Clone the winner. Rewrite only the words.
When an app has been refined for weeks β conversion-tuned hero, mobile QA'd flows, monetization choreography that actually converts β that work shouldn't die with one product. Template builds seed a new app from a proven app's actual code: every file cloned, every slug reference swapped, products carried over.
Then the transform stage rewrites only the domain content β the words, the offers, the examples β while the machinery, design system, and funnel choreography stay byte-for-byte intact. Weeks of tuning, inherited in minutes.
Inherits
code, not vibes
Rewrites
domain content only
Keeps
funnel + mobile tuning
Zero-residue
swept for old-domain leaks
build.03
Staging & versions
Prod is sacred. History is one click deep.
Flip staging on for an app and every edit β chat, sprint, auto-repair, even external mirror pushes β lands in a staged copy while production keeps serving untouched. Read per-file diffs, preview privately (there's a shareable phone-preview link that needs no login), then promote exactly the changed files, or discard the lot.
Separately, every push to production β promotes, finished builds, sprints, mirror imports, manual saves β freezes a numbered version: the complete file set, browsable as a live page with a version ribbon, restorable in one click. A restore auto-saves current prod first, so even the undo has an undo.
Diffs
per-file, line-level
Versions
auto on every prod push
Preview
browsable, ribboned
Restore
one click, undoable
build.04
Quality machinery
An AI user breaks it before a human can.
Every build ends with smoke suites β hard checks committed alongside the app so they run on every future change too. Above that sits the walkthrough tester: an AI that drives the real app in a real frame like a real user, reading each screen and deciding its own next move toward a goal β it signs up when it hits a login gate, dismisses overlays, and adapts instead of replaying a script.
SEO audits score the live pages and push their fixes straight into the builder. And the A/B layer runs landing-page experiments (sticky 50/50 assignment, signups attributed to the variant actually seen) and in-app experiments on signed-in users β with archived variants kept re-runnable.
Tester
goal-driven, not scripted
Smoke
committed, durable
A/B
LP + in-app
Attribution
variant actually seen