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. This page is the map. Each step has its own page with the detail.
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 nine steps
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.
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 all nine steps 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 app/, shared UI in components/, integrations in libs/, 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 nine steps for your next idea, on the same rails. That is what makes this a re-runnable kit, not a one-off site.