From idea to deployed
The code is the easy part now. What you are buying for €99 is the workflow: an ordered chain of prompts and generators that turns a one-paragraph idea into a deployed Next.js site, where each step writes a file the next step reads. Before the chain there is one command that makes a fresh clone yours. This page is the map. Each step has its own page with the detail.
First run
Start here, before any prompt. Clone, install, and run the init command. No .env file is needed at any point.
$gitclone <your-repo-url> my-site$cdmy-site$pnpminstall$pnpmrun initpnpm run init asks seven questions: project name, naked domain, one-line description, who it is for, the primary goal or call to action, voice and tone notes, and an accent hex. It writes the answers to ai_rules/app_approach/app-context.md and sets the matching fields in src/config.ts: appName, appDescription, domainName, the Resend addresses and colors.main. Stripe, AWS and auth are left alone.
Before it asks anything it resolves every symlink in .claude/skills/ and stops if one points at nothing, because a broken link costs you a skill without showing up in ls. Run it twice and the second run changes nothing. --dry-run prints the plan without writing, and --non-interactive with the field flags skips the questions for a scripted setup.
app-context.md is the file an agent reads before it writes product code or a blog post, and it ships as a placeholder. The root CLAUDE.md tells the agent what to do while it still is: say so, then either run init for you or ask you those same seven questions. It will not infer your product from the boilerplate's own marketing copy.The thesis
AI made writing code cheap. It did not make deciding what to build cheap, and it did not make a model that invents your file paths trustworthy. So the value moved up a layer: from typing the code to running the workflow that keeps the code correct, consistent, and on spec.
Every step removes one failure mode. The brief forces the decisions. The PRD makes "done" machine-checkable. The generators keep copy and design on voice and on brand. The memory bank stops the agent re-learning the repo every session. The build loop ships against the spec one atomic task at a time. Run the chain and you get a site. Keep the chain and you re-run it for the next idea.
ai_rules/.You decide, the agent executes
The split that makes the workflow work: you make the handful of decisions that need judgment, and the agent does the typing against them. Two lanes, running in order.
You decide
Answer five questions; the agent writes concept-brief.md
Confirm routes, data, and success criteria in PRD.md
Two knobs decide the design system; nothing else to choose
AI executes
From the brief, with machine-checkable acceptance criteria
On-voice strings into copy.md, accent into globals.css
Reads the repo once, fills .memory so it stops guessing
The SDD loop ships atomic tasks, then pushes to Vercel
The three phases
The full guide ships as ai_rules/project_init_workflow.md. Three phases, in order, with explicit handoffs.
| Phase | Who runs it | Steps |
|---|---|---|
| 1. Product definition | You + an LLM | Idea, PRD, copy, design |
| 2. System init | The agent | Memory bank, architecture, MCP |
| 3. Implementation | The agent | Build (the SDD loop), deploy |
The chain, step by step
Each step is collapsed so the whole workflow stays scannable: the title and the file it writes are visible at a glance, and the detail (what it does, what it runs, where to read more) opens on click. The list below is the chain; the first run above is the setup that comes before it.
Paste a one-paragraph idea. The prompt asks the five questions that force the decisions everything else depends on: who it is for, the one job, the single CTA.
Runs: prompts/1_idea_clarification
Interviews you on routes, data, SEO, and forms, then writes a spec with machine-checkable success criteria so done stops being an opinion.
Runs: prompts/2_prd_generator
Turns the spec into every homepage string in a builder voice with AI-slop words stripped. One file is the source of truth; components read from it.
Runs: generators/copy_generator
The design system is locked. You turn two knobs, the default mode and one accent hue, and the whole site re-skins from one variable pair.
Runs: generators/design_system_generator
The agent reads the brief, the PRD, and the boilerplate inventory, runs a reuse / extend / new gap analysis, and fills nine memory files so it never re-learns the repo.
Runs: prompts/3_memory_bank_init
Reuse the flat core for what exists; isolate net-new feature logic into src/features. Server-first by default, client islands only where interactive.
Runs: PRD plan phase
Add only the MCP servers the current step needs (Supabase, Context7, Playwright, Magic) plus the recommended skills. No over-install.
Runs: ai_rules/mcp.md
specify, plan, tasks, implement. The agent ships one atomic task per pass, each verified against a checkable criterion, so drift gets caught early.
Runs: .claude/commands/sdd-*
Push to Git, import into Vercel, deploy. The same ai_rules/ chain ships in the box, so you re-run the whole chain for your next idea on the same rails.
Runs: Vercel + the inherited ai_rules/
Inheritance, not invention
You inherit a production-ready core
Routes in src/app/, shared UI in src/components/, integrations in src/services/, plus the SEO, theming, and analytics systems and env-gated Supabase / Resend / Stripe. The build is green with zero env vars. The workflow's job is to map your idea onto what already exists.
Reuse beats reinvention
If a capability ships in the boilerplate, you customize it. The memory bank runs a REUSE / EXTEND / NET-NEW gap analysis over your PRD so the agent extends the waitlist API instead of rebuilding it.
The chain travels
ai_rules/ ships in the box. Re-run the same chain for your next idea, on the same rails. That is what makes this a re-runnable kit, not a one-off site.