Help us improve
Share bugs, ideas, or general feedback.
From prototyping-skills
This skill bridges the gap between scaffolding and active development. It should be used when the user says "start development", "begin building", "ready to code", "what's next after scaffolding", "what do I do now", "development checklist", "start coding", "how do I start", "check readiness", "run development checks", or "readiness report". It also applies when the user has just finished scaffolding with init-prototype and wants to begin building features.
npx claudepluginhub kjgarza/marketplace-claude --plugin prototyping-skillsHow this skill is triggered — by the user, by Claude, or both
Slash command
/prototyping-skills:development-workflowThis skill is limited to the following tools:
The summary Claude sees in its skill listing — used to decide when to auto-load this skill
Run automated checks on the current prototype monorepo and present an actionable
Guides through an 8-phase SDLC workflow from requirements to code review. Use for end-to-end feature building or individual phases like new requirements, design review, or testing.
Autonomously generates complete production-ready projects from descriptions: structure, code, tests, docs, config, git. Orchestrates pipeline with verification to ensure builds and tests pass.
Bootstraps new projects or improves existing ones with best practices for structure, git, documentation, testing, code quality, dependencies, dev workflow, and CI/CD.
Share bugs, ideas, or general feedback.
Run automated checks on the current prototype monorepo and present an actionable development checklist. This skill connects the scaffolding phase to active development by verifying readiness and prescribing the correct skill chain.
First verify packages/ exists. If not, inform the user this skill requires a monorepo
scaffolded by prototyping-skills:init-prototype and suggest running that skill first.
Run these checks automatically:
ls packages/
For each detected package, check if tests/ directory exists:
for pkg in packages/*/; do
name=$(basename "$pkg")
if [ -d "$pkg/tests" ]; then
count=$(find "$pkg/tests" -name "*.test.ts" | wc -l)
echo "$name: $count test files"
else
echo "$name: NO TEST INFRASTRUCTURE"
fi
done
bun test 2>&1 || echo "Tests failed or no tests found"
bunx @biomejs/biome check . 2>&1 | tail -5
if [ -f .github/workflows/ci.yml ]; then
echo "CI: configured"
grep -q "bun test" .github/workflows/ci.yml && echo "CI includes tests" || echo "CI MISSING test step"
else
echo "CI: NOT CONFIGURED"
fi
Present results as a readiness report:
## Development Readiness Report
### Packages Detected
List each package found by `ls packages/` with its status. Only include packages that exist.
### Test Infrastructure
- [package]: [X test files | NO TESTS]
### Lint Status
- [pass/fail with summary]
### CI
- [configured with tests | configured without tests | not configured]
Based on findings, recommend specific actions:
If any package lacks a tests/ directory:
Run
prototyping-skills:generate-teststo scaffold test infrastructure for packages missing tests.
If test directories exist but contain no .test.ts files:
Start with
superpowers:test-driven-developmentto write tests alongside new features.
If Biome reports issues:
Run
bun run fixto auto-fix lint and formatting issues before starting development.
If .github/workflows/ci.yml lacks bun test:
Add
- run: bun testto the CI workflow to gate merges on passing tests.
After reporting state, present the prescribed workflow:
## Prescribed Development Workflow
### Adding a Feature
1. Write tests first — use `superpowers:test-driven-development`
2. Implement the feature in the appropriate package
3. Run `code-simplifier:simplify` before committing (enforced by pre-commit hook)
4. Run `superpowers:verification-before-completion` to verify completeness
5. Run `superpowers:requesting-code-review` before merging
### After a Burst Session
Before merging, run the full verification chain:
1. `bun check` (Biome lint + format)
2. `bun test` (all packages)
3. `superpowers:verification-before-completion`
4. `superpowers:requesting-code-review`
Present available skills by development phase:
## Available Skills by Phase
### Planning
- `superpowers:writing-plans` — Structure implementation plans
- `superpowers:brainstorming` — Explore ideas and approaches
### Building
- `superpowers:test-driven-development` — TDD workflow (write test → implement → refactor)
- `superpowers:dispatching-parallel-agents` — Parallelize independent tasks
- `prototyping-skills:generate-api` — Add API routes
- `prototyping-skills:generate-ui` — Add UI pages/components
- `prototyping-skills:generate-mcp` — Add MCP tools
### Finishing
- `code-simplifier:simplify` — Review code for quality and efficiency
- `superpowers:verification-before-completion` — Verify work is complete
- `superpowers:requesting-code-review` — Get code review before merge
- `superpowers:finishing-a-development-branch` — PR/merge/cleanup workflow
This skill is active, not passive. When triggered: