Start with a working foundation

Kickstart

The 0→1 vertical: the one project-autopilot refuses to do (it requires a scaffold already standing). kickstart builds that scaffold from a general idea, then passes the baton. Bookend of ship-it: kickstart it … ship it.

Core Insight: A greenfield ideation pass pointed at "more" is how projects drown before they run. So kickstart inverts the ambition: its ideation optimizes for the leanest elegant path to the intent: the least code, the fewest moving parts, the boring proven choices, and treats not building as a first-class output. It gets to a walking, intent-aligned scaffold fast, then hands off. The whole skill is a brake on overbuilding, because that's the failure mode it exists inside.

Anti-overbuild gates (the spine; these override enthusiasm)

1. Lean-path ideation, not maximal. kickstart's idea-forge pass optimizes for the simplest elegant build that delivers the intent (what to NOT build), not feature maximalism. (This is the OPPOSITE calibration from ux-maximizer's wow prompt; the wow pass comes later, if ever. See references/PROMPTS.md.)
2. Walking skeleton first. The thinnest end-to-end runnable thing + one green test before any deep build. Proves the shape, gives the ratchet a baseline, and means stopping early still leaves something that works.
3. Intent is the ceiling. "Full" = delivers the Intent Statement. Beyond-intent ideas go to a someday backlog, never auto-built. Scope ratchet: close the gap to intent, never widen it.
4. Selective recursion + ideation budget. Run idea-forge on a sub-fork ONLY when it's non-obvious AND high-leverage / costly-to-reverse. Obvious, cheap, reversible decisions → pick the boring default (YAGNI). Cap ideated forks per round; most features just get built.
5. Subtraction pass. Every architecture/feature decision pairs a "build" top-N with a "deliberately skip/defer" bottom-N. Non-building is an explicit deliverable.
6. Rule of three. No abstraction, framework, or config layer until 2–3 real call sites actually need it. No speculative generality, no "we might want it later."
7. Hard handoff. Stop at a walking scaffold + green baseline + bead backlog and hand to project-autopilot. kickstart is NOT the 1→done loop; it builds the runway.
8. Creep check. Between build-out rounds: "are we still on the smallest path that delivers the intent?" Catch sprawl early; cut, don't power through.

The Pipeline (staged: one step at a time)

Phase 0  IDEA → INTENT    Turn the general idea into a crisp Intent Statement (who it
                          serves, what job, what "winning" is, commercial-vs-fun, and
                          the keep-it-small scope). This is the CEILING for "full".
Phase 1  HOW (lean-path)  idea-forge the simplest elegant way to BUILD it → top 5
                          approaches PAIRED with a bottom-5 to deliberately skip. A
                          genuinely big/expensive architecture or stack fork →
                          dueling-idea-forge. Choose the leanest that delivers the intent.
                          (research-software, if installed, to learn a new stack.)
Phase 2  WALKING SKELETON Scaffold the thinnest thing that runs end-to-end + one green
                          test. Checkpoint. NOW the green ratchet engages.
Phase 3  BUILD-OUT        Feature by feature toward the intent: idea-forge ONLY the
                          non-obvious high-leverage forks (gate #4), YAGNI default for
                          the rest, planning-workflow → beadsmith → build under the
                          ratchet. Creep check between rounds. Fill ONLY to the intent.
Phase 4  HANDOFF          When a working, intent-aligned scaffold + green baseline +
                          bead backlog exist → hand to /project-autopilot (1→done),
                          which later routes to the quality verticals and /ship-it.

Skills it orchestrates

idea-forge (the recursive engine, pointed at leanness) · dueling-idea-forge (big architecture/stack forks only: adversarial takes before committing) · planning-workflow (chosen approach → plan; if not installed, write the plan doc directly) · beadsmith (plan → beads) · research-software (learn a new stack; if not installed, read the stack's docs) · reality-check (intent extraction in Phase 0) → then project-autopilot at the handoff. Staged prompts in references/PROMPTS.md.

Shared mechanisms (inherited from project-autopilot)

Green ratchet (engages at the walking skeleton), decision inbox, successive-prompter timing, as in project-autopilot. Lifecycle position: kickstart (0→1) → project-autopilot (1→done) → bug-zero/perf-max/ux-maximizer (quality) → ship-it (out).

THE EXACT PROMPT

/kickstart
Idea: <the general thing you want to build>
Intent: <who it's for / what winning looks like, if you know it; else Phase 0 draws it out>
Mode: solo (default) | swarm (optional; needs ntm installed)

Anti-Patterns

• Ideating for "more" instead of for the leanest path that delivers the intent.
• Deep-building before a walking skeleton runs end-to-end (no baseline, no proof).
• Running idea-forge on every facet: selective recursion is the whole point (gate #4).
• Building past the intent because an idea was cool: that's a someday backlog item.
• Abstracting/frameworking before the rule of three is met.
• Trying to take it all the way to done. Hand off to project-autopilot at the scaffold.
• Skipping the subtraction pass: what you DON'T build is half the design.

References

• PROMPTS.md: the lean-path idea-forge prompt, subtraction pass, recursion gate, creep check