| name | source-command-setup-aidevtool-from0 |
| description | Bootstrap a brand-new (empty) project from zero — product idea, interactive questionnaire, stack suggestion, roadmap, best practices. |
source-command-setup-aidevtool-from0
Use this skill when the user asks to run the migrated source command aidevtool-from0.
Command Template
🌱 AI Dev Tool — Start from Zero
Use this when the project is empty (no code yet). If there's already a
codebase, use /setupcontextdevkit instead. Goal: go from a blank folder to a
project with a clear product vision, a stack, a roadmap, the best-practices
constitution, and an initialized DevPipeline — by actively interviewing the
user and suggesting, not just scaffolding.
First confirm it's greenfield: run node contextkit/tools/scripts/detect-stack.mjs
and check greenfield: true / no sourceDirs. If it's not empty, stop and point
to /setupcontextdevkit.
Phase 1 — Intelligent product questionnaire (interactive)
Ask a focused, smart set of questions — adapt follow-ups to the answers, do
not dump a static form. Cover:
- What is the app? Problem it solves, who it's for, the core value.
- The core user journey (the one flow that must be great).
- Platform: web / mobile / desktop / CLI / API / library?
- Scale & constraints: expected users, budget, deadlines, team size, any
hard constraints (offline, on-prem, regulation like LGPD/GDPR)?
- Tech preferences: do they already have stack ideas, or want a suggestion?
- Audience language for UI text.
Summarize your understanding back and get a thumbs-up before proceeding.
Phase 2 — Product vision
Write contextkit/memory/product.md: one-paragraph vision, target user, core value,
the primary journey, non-goals. Short and sharp.
Phase 3 — Stack: suggest or refine
If they gave a stack, sanity-check it against the requirements and note risks. If
they want a suggestion, propose one recommended stack with a short rationale
and 1–2 alternatives + trade-offs (act like architect). Record the choice as
/new-adr "Stack: <summary>" (ADR-0001). Don't over-engineer for imagined scale.
Curated stacks with playbooks. When a curated option fits the requirements,
prefer it over an ad-hoc proposal — the playbook anchors conventions the kit
will enforce later (/setupcontextdevkit, scoped AGENTS.md, /contract-check):
- TanStack (type-safe React/Solid/Vue with Query + Router; optionally
Start as the full-stack frame) →
contextkit/workflows/playbooks/tanstack.md.
Pick it for type-safe apps where headless control matters; don't stack
TanStack Router on top of Next/Nuxt/Remix.
If you pick a curated stack, cite its playbook in the ADR and inherit its
conventions verbatim into the project's AGENTS.md "Stack" block.
Phase 4 — Roadmap (product/business)
Build contextkit/memory/roadmap.md with the user via /roadmap new: phases/
milestones with P-IDs (P1.x, P2.x…), each a user-facing capability + a
one-line acceptance note, ordered by value. Co-create it — ask which outcomes
matter first; don't dump a template. This is the what/why of the product — NOT
bugs or CI tasks (those live in the DevPipeline).
Phase 5 — Best practices (the constitution)
Offer to adopt the context-coding best practices in contextkit/best-practices.md
— Tier 1 architecture (dependencies point inward; boundaries; one source of truth
per piece of state) plus, when the project carries real domain weight, the domain
lane (one word one meaning inside a boundary; invariants enforced by the owner of
the state; foreign shapes translated at the seam); Tier 2 hygiene (no line limit +
intelligent refactoring — split by responsibility, never random; SoC; naming;
errors; docs) and lean discipline (abstract on the second real case, not the
first). On yes, fill the constitution section of AGENTS.md accordingly and set
practices.active = true via /context-config.
Keep it proportional: a fresh project is usually simple/modular, so record the
direction rules now and let the domain ceremony arrive when the classifier says
the work needs it (/domain "<objective>"). Don't seed a hexagonal architecture
into a project that has no domain yet — that is the speculative half rule 9
forbids.
Phase 6 — Initialize execution
When the user wants durable execution state, create one explicit workflow for
the first milestone, then add its tasks to that workflow's canonical scope:
node contextkit/tools/scripts/workflow.mjs new <milestone-slug> --title "<milestone>"
node contextkit/tools/scripts/pipeline.mjs add --tasks <workflow-dir> \
--priority P1 --title "<first task>" --acceptance "<measurable criterion>"
Never seed a writable global backlog or infer a task scope from the roadmap.
As soon as the project's structure exists (apps/backend/frontend/modules), give
each its own scoped AGENTS.md with /claude-md — the root one is the
constitution; each module documents its local rules. Do this as modules are born,
not after the codebase is already sprawling.
Curated-stack starter (opt-in). If Phase 3 picked a curated stack with a
starter under templates/contextkit/starters/<stack>/, offer to copy it into the
project root as a wiring scaffold. Default is no; the user explicitly
opts in. Currently available: tanstack/ (Start + Router + Query, empty —
no invented domain, no CSS framework, no backend choice — see ADR-0017).
After copy, the starter becomes the user's code; no upgrade path.
Phase 6b — Version control (verify, then decide with the user)
Run node contextkit/tools/scripts/git.mjs status. git init if it's not a repo.
Then check the remote:
- already connected (
remoteUrl present) → confirm it's the right one, done.
- none → ask: "Do you already have a repository to connect, or should we
create a new one?" Then run
/git setup-remote (B1 connect existing / B2 create
new — private by default; install gh/glab if needed). A new project should be
under version control from day one. Confirm before pushing/creating.
Phase 7 — Set level & finish
Recommend a starting level (usually L2; L4+ if it'll be a team). Run
node contextkit/tools/scripts/setup-complete.mjs to clear the first-run trigger,
then /log-session. Report: product, stack (+ADR), roadmap, pipeline seeded,
level. The platform stays active — as the roadmap grows, suggest the next
practice/level. Empty project today, opinionated project tomorrow.
