Skip to content
Skills Library
Programming · Planning

development-workflow

/development-workflow

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.

Licence
MIT
Last repository change
18.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 18.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

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.

Triggers from the description

start developmentbegin buildingready to codewhatwhat do I do nowdevelopment checkliststart codinghow do I start
Original author description

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.

How it works

  1. Step 0: Verify Monorepo
  2. Step 1: Assess Current State
  3. Step 2: Report Findings
  4. Step 3: Recommend Actions
  5. Step 4: Present the Development Workflow
  6. Step 5: Quick-Reference Skill Map
  7. Behavior
Original SKILL.md headings · 166 lines, 612 words
SKILL.md preview
---
name: development-workflow
description: >
  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.
allowed-tools:
  - Bash
  - Read
  - Glob
  - Grep
  - Skill
---

# Development Workflow Bridge

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.

## Step 0: Verify Monorepo

First verify `packages/` exists. If not, inform the user this skill requires a monorepo
scaffolded by `prototyping:init-prototype` and suggest running that skill first.

## Step 1: Assess Current State

Run these checks automatically:

### Detect packages

```bash
ls packages/
```

### Check test infrastructure per package

For each detected package, check if `tests/` directory exists:

```bash
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
```

### Run existing tests

```bash
bun test 2>&1 || echo "Tests failed or no tests found"
```

### Check lint status

```bash
bunx @biomejs/biome check . 2>&1 | tail -5
```

### Check CI configuration

```bash
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
```

## Step 2: Report Findings

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]
```

## Step 3: Recommend Actions

Based on findings, recommend specific actions:

### Missing test infrastructure

If any package lacks a `tests/` directory:

> Run `prototyping:generate-tests` to scaffold test infrastructure for packages missing tests.

### No test files

If test directories exist but contain no `.test.ts` files:

> Start with `superpowers:test-driven-development` to write tests alongside new features.

### Lint failures

If Biome reports issues:

> Run `bun run fix` to auto-fix lint and formatting issues before starting development.

### CI missing test step

If `.github/workflows/ci.yml` lacks `bun test`:

> Add `- run: bun test` to the CI workflow to gate merges on passing tests.

## Step 4: Present the Development Workflow

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`
```

## Step 5: Quick-Reference Skill Map

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:generate-api` — Add API routes
- `prototyping:generate-ui` — Add UI pages/components
- `prototyping: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
```

## Behavior

This skill is **active, not passive**. When triggered:

1. Immediately run the assessment checks (Step 1)
2. Present the readiness report (Step 2)
3. Recommend specific actions based on findings (Step 3)
4. Always show the prescribed workflow and skill map (Steps 4-5)
5. Ask the user what they want to build first

Versions

RepositoryScoreLicence
This page · kjgarza/marketplace-claude100MIT
CrowdStrike/foundry-skills100MIT
kid-sid/codex-spellbook100MIT
toss/react-simplikit95MIT
PracticalSwan/agent-skills95MIT
chthollyphile/folia-major90AGPL-3.0
masscodeio/masscode90AGPL-3.0

Database snapshot: 13.11.2026 · package version 79885bb7ce27 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100start
    Guides a first-time user through onboarding and picks the right workflow. Use when the user is new, just cloned or installed the studio, has no idea or engine yet, asks where to begin, or wants to bring in an existing game.
  • 100prd-v07-implementation-loop
    Execute implementation within EPICs following test-first development, continuous SoT updates, and code traceability during PRD v0.7 Build Execution. Triggers on requests to start building, implement an epic, begin coding, or when user asks "start building", "implement epic",…
  • 100init-prototype
    This skill bootstraps a new prototype monorepo with the standard package structure: core, api, ui, mcp, and types packages — all wired up with Bun workspaces. It should be used when the user wants to start a new prototype, create a new project, scaffold a monorepo, or says…
  • 100start
    Guides a first-time user through onboarding and picks the right workflow. Use when the user is new, just cloned or installed the studio, has no idea or engine yet, asks where to begin, or wants to bring in an existing game. A request for a game itself ('make me a game where...') is /prototype's.
  • 95start
    Use when starting work on any task, when the user mentions metaswarm, or when the user wants to begin tracked development work
  • 100agent-readiness
    Score how ready the current repository is for AI-assisted development against the Agent-Readiness Scorecard. Use when the user asks "how agent-ready is this repo", "score this repo for agents", "agent readiness", or wants a tiered readiness report. Scores YOUR project repo's…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.