home / skills / zpankz / mcp-skillset / build-router

build-router skill

safe

This skill streamlines end-to-end build tasks across frontend, backend, infrastructure, and docs, integrating planning, implementation, and documentation.

npx playbooks add skill zpankz/mcp-skillset --skill build-router

Review the files below or copy the command above to add this skill to your agents.

Files (2)

SKILL.md

3.2 KB

---
name: build-router
description: |
  Unified router for development, infrastructure, and documentation tasks.
  Absorbs development-router + infrastructure-router + documentation-router.
---

# Build Router (Unified)

**Tier**: unified
**Absorbs**: development-router + infrastructure-router + documentation-router
**Purpose**: All creation/building tasks (code, configs, docs)

## Triggers
```yaml
patterns:
  - build, implement, create, develop
  - frontend, backend, fullstack, API
  - mcp, server, hook, deploy
  - document, readme, explain, changelog
  - terminal, TUI, CLI interface
```

## Build Domains

### Frontend Development
```yaml
triggers: [UI, UX, component, styling, React, Vue, Svelte]
agent: frontend-engineer
skills:
  - frontend-ui-ux (active)
  - component patterns
  - accessibility (WCAG)
  - responsive design
```

### Backend Development
```yaml
triggers: [API, server, database, authentication]
patterns:
  - RESTful API design
  - GraphQL schemas
  - Database modeling
  - Authentication/authorization
```

### Infrastructure
```yaml
triggers: [MCP, hook, config, deploy, tooling]
skills:
  - mcp-builder (db/skill-db)
  - hook development
  - configuration management
workflows:
  - MCP server: Research → Implement → Review → Evaluate
```

### Documentation
```yaml
triggers: [document, readme, explain, changelog, API docs]
agent: document-writer
patterns:
  - README creation
  - API documentation
  - Code comments
  - Changelogs
```

## Workflow Integration
```yaml
standard_flow:
  1. Analyze requirements
  2. Plan implementation
  3. Build incrementally
  4. Test and validate
  5. Document

sc_commands:
  - sc:implement → Guided implementation
  - sc:build → Build workflow
  - sc:document → Documentation
```

## Build Tool Detection

```yaml
package_managers:
  package.json: pnpm | npm | yarn | bun
  pyproject.toml: uv | poetry | pip
  Cargo.toml: cargo
  go.mod: go

build_commands:
  typescript: "pnpm build" | "npm run build" | "bun build"
  python: "uv run python -m build" | "poetry build"
  rust: "cargo build --release"

test_runners:
  typescript: vitest | jest | playwright
  python: pytest
  rust: cargo test

linting:
  typescript: eslint | prettier | biome
  python: ruff | black | mypy
```

## Decision Tree

```
Build/Create Request
    │
    ├── Frontend?
    │   ├── TUI/terminal? → terminal skill
    │   ├── Component? → frontend-engineer agent
    │   └── Feature → sc:implement
    │
    ├── Backend?
    │   ├── API design? → sc:design
    │   └── Implementation → sc:build
    │
    ├── Infrastructure?
    │   ├── MCP server? → mcp-builder skill
    │   ├── Hooks? → hookify skill
    │   └── Config → component skill
    │
    └── Documentation?
        ├── README → document-writer agent
        ├── API docs → sc:document
        └── Changelog → create-release-note
```

## References
- Original development-router: ~/.claude/db/skills/routers/development-router/
- Original infrastructure-router: ~/.claude/db/skills/routers/infrastructure-router/
- Original documentation-router: ~/.claude/db/skills/routers/documentation-router/

Overview

This skill is a unified router that routes and orchestrates all build, implementation, and documentation tasks across frontend, backend, infrastructure, and docs workflows. It consolidates development, infrastructure, and documentation routing logic so requests are directed to the right agent or workflow. Use it to standardize how creation tasks are analyzed, planned, built, tested, and documented.

How this skill works

The router inspects intent and context (triggers like build, API, deploy, document) and matches requests to domain-specific agents and skills such as frontend-engineer, mcp-builder, or document-writer. It applies a decision tree to choose the appropriate flow (implement, design, build, or document), detects project tooling (package managers, build/test/lint commands), and emits recommended commands and workflows. Standard flows and sc commands (sc:implement, sc:build, sc:document) guide incremental builds, validation, and documentation steps.

When to use it

When initiating a new feature that spans frontend, backend, and deployment
When you need a canonical decision for build vs design vs documentation work
When assessing repository tooling and producing build/test/lint commands
When producing README, API docs, or changelogs alongside implementation
When integrating MCP server, hooks, or configuration management tasks

Best practices

Start with Analyze → Plan → Build incrementally → Test → Document as the default workflow
Provide clear intent and scope (frontend/backend/infrastructure/documentation) to improve routing accuracy
Let the router detect toolchain files (package.json, pyproject.toml, Cargo.toml, go.mod) for precise command suggestions
Use sc commands (sc:implement, sc:build, sc:document) to trigger guided, repeatable flows
Keep documentation tasks coupled with implementation to avoid drift between code and docs

Example use cases

Create a new React component with accessibility notes, build commands, and a README snippet
Design a RESTful API then scaffold route handlers, tests, and API docs
Set up an MCP server: research requirements, implement hooks, and generate configuration templates
Detect project package manager and output concrete build/test/lint commands for CI
Generate a changelog and release notes after incremental implementation steps

FAQ

How does the router choose between implement and document workflows?

It matches triggers and intent: feature requests or code changes map to implement/build flows, while requests containing document/readme/API/changelog map to the document flow; ambiguous prompts prompt a clarifying question.

Can it detect the right build and test commands for my repo?

Yes. It checks common manifest files and maps languages to typical build, test, and lint commands (e.g., pnpm build, pytest, cargo test) and returns concrete suggestions.