project-scaffolding
Turns the pipeline's design documents into a running system. Reads the architecture document and implementation plan, executes each ecosystem's current official project generator to create the real repo structure (one deployable unit per architecture container, monorepo by default), wires the walking skeleton end-to-end — UI shell with the design system's tokens.json, API, domain stub, local database — stands up the engineering foundations (CI, environments, test harness, deployment config written but not executed), and verifies empirically by building and running the skeleton test. Deploy-ready, not deployed. Use after implementation-planning and before per-slice work, when the plan's walking skeleton needs to become a real repo. Trigger on "scaffold the project", "set up the repo", "create the project structure", "build the walking skeleton", "initialize the codebase", or "stand up the skeleton". Checkpoints progress and resumes safely — never regenerates over a partial scaffold.
zeeshanhanif · 已有静态检查记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add zeeshanhanif/agentic-sdlc-kit --skill project-scaffolding技能说明
name: project-scaffolding description: >- Turns the pipeline's design documents into a running system. Reads the architecture document and implementation plan, executes each ecosystem's current official project generator to create the real repo structure (one deployable unit per architecture container, monorepo by default), wires the walking skeleton end-to-end — UI shell with the design system's tokens.json, API, domain stub, local database — stands up the engineering foundations (CI, environments, test harness, deployment config written but not executed), and verifies empirically by building and running the skeleton test. Deploy-ready, not deployed. Use after implementation-planning and before per-slice work, when the plan's walking skeleton needs to become a real repo. Trigger on "scaffold the project", "set up the repo", "create the project structure", "build the walking skeleton", "initialize the codebase", or "stand up the skeleton". Checkpoints progress and resumes safely — never regenerates over a partial scaffold.
Project Scaffolding
The first skill in the pipeline whose output is a running system, not a document. It takes the architecture and the plan and produces the walking skeleton as a real repo: generated structure, wired end-to-end, foundations in place, verified by execution. It ends where deployment begins — everything is deploy-ready; the first actual deploy is the user's step.
Three principles govern it:
- The stack is an input, never a decision. The architecture's ADRs already chose the technology. This skill reads the stack and refuses to relitigate it. Gaps the generators need answered (package manager, monorepo tool) are elicited — and flagged as candidate architecture amendments.
- Official generators first, manual structure second. Every serious ecosystem ships an official project initializer that encodes current best-practice structure. Discover it, verify it against live docs (never trust memory for CLI names/flags — live reality always wins), run it for real, then customize. Hand-build only where no generator exists, following that ecosystem's documented conventions. This keeps the skill self-updating: framework conventions change, generators change with them, the skill inherits it.
- What this skill owns is the stack-independent layer: the walking-skeleton wiring between units, module-boundary enforcement, the design system wired into the UI shell, pipeline conventions carried into the repo, and empirical verification. Generators create isolated apps; this skill makes them a system.
Inputs
Defaults below; user-provided paths win. Each degrades independently.
- Architecture —
docs/architecture.md(primary). The stack per container (from ADRs), the containers themselves (each becomes a deployable unit), module boundaries, deployment target, cross-cutting concepts. Without it the skill can still run by eliciting the stack directly, but say plainly that fidelity suffers — this skill is designed to realize an architecture. - Implementation plan —
docs/implementation-plan.md. The walking-skeleton spec (what's real, what's stubbed, done-when) and the engineering-foundations checklist. If missing, derive a minimal skeleton from the architecture and confirm it with the user. - UX foundations —
docs/ux-foundations.md,docs/design.md,docs/tokens.json. The UI-shell contract: tokens wired into each frontend surface's token mechanism, design.md referenced from AGENTS.md file. - SRS —
docs/srs.md, light touch: constraints (§2.5) affecting tooling.
Source-gated traceability: scaffold decisions cite ADR and container names when the documents exist; prose otherwise; never fabricate a reference.
RTM: no write-back. Scaffolding realizes containers, not requirements —
nothing here maps to a requirement row, and per the RTM column-ownership
contract this skill does not touch docs/rtm.md.
Outputs
- The repo — generated per-unit structure (monorepo by default), module
boundaries enforced (folders + import/lint rules), skeleton wired
end-to-end, one passing end-to-end test, CI config, environment configs,
deployment config written (not executed),
docs/carried in. - Agent instructions —
AGENTS.mdat the root carrying the substance (pipeline documents, design.md, conventions, commands), plusCLAUDE.mdcontaining only@AGENTS.mdas a pointer: one source of truth, every coding tool covered, so any future session inherits the context. docs/scaffold-notes.md— the project-owned record: generators + versions + flags actually used, deviations from expectation, decisions made, what's stubbed where. Consumers: future sessions on this project, the build phases, and the skill author if they ever hand-promote a durable lesson into the skill. Notes live in the project, never in the skill folder.
Workflow
Phase 0 — Resume check (always first)
Read references/checkpointing.md. Look for docs/.scaffold-progress.md and
signs of a partial scaffold. If found: never regenerate over it —
regeneration over a half-built repo is destructive. Summarize what exists,
what's pending, confirm, and resume at the first pending unit/step. Fresh
start: create the tracker and proceed.
Phase 1 — Ingest and confirm the scaffold plan (the one gate)
Read the input documents. Extract the build contract: per container — language/ framework (cite the ADR), store bindings, boundaries; plus the skeleton spec and foundations checklist from the plan. Then play back a short scaffold plan — units and their stacks, repo shape, local data story, CI target, the done-when condition — and get explicit confirmation. This is the single gate before real files are created; after the nod, the skill executes without further ceremony.
Repo shape: monorepo by default; ask on
阅读完整来源 ↗