Displays Plan-Build-Run command reference with core workflow (/pbr:begin, plan, build, review), planning flags (--assumptions, --gaps), and execution options. Shows contextual help for specific commands.
From pbrnpx claudepluginhub sienklogic/plan-build-run --plugin pbrThis skill is limited to using the following tools:
Searches, retrieves, and installs Agent Skills from prompts.chat registry using MCP tools like search_skills and get_skill. Activates for finding skills, browsing catalogs, or extending Claude.
Searches prompts.chat for AI prompt templates by keyword or category, retrieves by ID with variable handling, and improves prompts via AI. Use for discovering or enhancing prompts.
Compares coding agents like Claude Code and Aider on custom YAML-defined codebase tasks using git worktrees, measuring pass rate, cost, time, and consistency.
STOP — DO NOT READ THIS FILE. You are already reading it. This prompt was injected into your context by Claude Code's plugin system. Using the Read tool on this SKILL.md file wastes ~7,600 tokens. Begin executing Step 1 immediately.
Before ANY tool calls, display this banner:
╔══════════════════════════════════════════════════════════════╗
║ PLAN-BUILD-RUN ► COMMAND REFERENCE ║
╚══════════════════════════════════════════════════════════════╝
Then proceed to Step 1.
If $ARGUMENTS contains a command name (e.g., plan, build, review, config, quick), show detailed help for just that command instead of the full reference. Match the argument against the command tables below and display only the matching section with its subcommands and flags. If the argument doesn't match any command, show the full reference.
Examples:
/pbr:help plan → Show only the plan command and its flags (--assumptions, --skip-research, --gaps, add, insert, remove)/pbr:help build → Show only the build command and its flags (--gaps-only, --team)/pbr:help → Show the full reference belowDisplay the following reference to the user:
| Command | Description | Cost |
|---|---|---|
/pbr:begin | Start a new project. Deep questioning, research, requirements, roadmap. | High (4-6 agents) |
/pbr:plan <N> | Plan a phase. Research, create plans, verify before building. | Medium (2-3 agents) |
/pbr:build <N> | Build a phase. Execute plans in parallel waves, verify results. | High (2-4 agents) |
/pbr:review <N> | Review what was built. Automated verification + walkthrough with you. | Low (1 agent) |
/pbr:test <N> | Generate tests for completed phase code. Detects framework automatically. | Medium (1-3 agents) |
| Command | Description |
|---|---|
/pbr:explore [topic] | Explore ideas, think through approaches. No phase number needed. |
/pbr:discuss <N> | Talk through a phase before planning. Captures decisions. |
/pbr:plan <N> --assumptions | Surface Claude's assumptions before planning. Zero cost. |
/pbr:plan <N> --skip-research | Plan without research phase. Faster. |
/pbr:plan <N> --gaps | Create gap-closure plans from verification failures. |
/pbr:plan add | Append a new phase to the roadmap. |
/pbr:plan insert <N> | Insert a phase using decimal numbering. |
/pbr:plan remove <N> | Remove a future phase and renumber. |
| Command | Description |
|---|---|
/pbr:build <N> | Execute all plans in a phase. |
/pbr:build <N> --gaps-only | Execute only gap-closure plans. |
/pbr:build <N> --team | Use Agent Teams for complex inter-agent coordination. |
/pbr:quick | Quick ad-hoc task with atomic commit. Low cost. |
/pbr:continue | Execute the next logical step automatically. No prompts. |
| Command | Description |
|---|---|
/pbr:review <N> | Verify phase + conversational UAT. |
/pbr:review <N> --auto-fix | Auto-diagnose and fix verification failures. |
/pbr:test <N> | Generate tests for completed phase code. Detects framework, targets key files. |
/pbr:debug | Systematic debugging with hypothesis testing. |
/pbr:scan | Analyze existing codebase (brownfield). |
| Command | Description |
|---|---|
/pbr:status | Where am I? Shows progress and suggests next action. |
/pbr:health | Check planning directory integrity. Find and fix corrupted state. |
/pbr:pause | Save session state for later. |
/pbr:pause --checkpoint | Save with a named checkpoint for easier resumption. |
/pbr:resume | Pick up where you left off. |
| Command | Description |
|---|---|
/pbr:milestone new | Start a new milestone cycle. |
/pbr:milestone complete | Archive completed milestone. |
/pbr:milestone preview | Dry-run of complete — show what would happen. |
/pbr:milestone audit | Verify milestone completion. |
/pbr:milestone gaps | Create phases to close audit gaps. |
/pbr:todo add|list|done | Persistent file-based todos. |
/pbr:todo work <NNN> | Work on a specific todo by ID. |
/pbr:note <text>|list|promote | Zero-friction idea capture. Quick notes that persist across sessions. |
/pbr:note --global | Save note to global notes directory (shared across projects). |
/pbr:config | Configure workflow settings. |
/pbr:import <N> | Import external plans (design docs, RFCs) into PBR format. |
/pbr:import --from <path> | Import from a specific file path. |
/pbr:import --skip-checker | Skip plan-checker validation on import. |
/pbr:setup | Interactive onboarding wizard for new projects. |
| Command | Description |
|---|---|
/pbr:audit | Review past sessions for PBR workflow compliance and UX quality. |
/pbr:audit --today | Audit today's sessions (default). |
/pbr:audit --from DATE --to DATE | Audit a specific date range. |
/pbr:audit --mode compliance|ux | Run compliance-only or UX-only audit. |
/pbr:do <description> | Route freeform text to the right PBR skill automatically. |
/pbr:dashboard | Launch the web dashboard for the current project. |
/pbr:dashboard --port <N> | Launch dashboard on a specific port. |
/pbr:statusline | Install or configure the PBR status line in Claude Code. |
Not sure which command to use? Follow this guide:
| I want to... | Command |
|---|---|
| Start a new project | /pbr:begin |
| Fix a bug or investigate an error | /pbr:debug |
| Think through an idea or approach | /pbr:explore |
| Do a small task (≤3 files) | /pbr:quick |
| Plan a complex change (4+ files) | /pbr:plan <N> |
| See where I am and what's next | /pbr:status |
| Auto-execute the next step | /pbr:continue |
| Describe something and let PBR route it | /pbr:do <description> |
| Lock decisions for a specific phase | /pbr:discuss <N> |
| Check project health | /pbr:health |
/pbr:begin ← Start project, define requirements, create roadmap
/pbr:discuss 1 ← (optional) Talk through phase details
/pbr:plan 1 ← Plan the first phase
/pbr:build 1 ← Build it
/pbr:review 1 ← Verify it works
/pbr:plan 2 ← Plan the next phase
... ← Repeat plan → build → review
/pbr:milestone complete ← Archive when done
Shortcut: After /pbr:begin, run /pbr:continue repeatedly — it auto-advances through plan → build → review → next phase, stopping at milestones and errors.
/pbr:status | /pbr:continue | /pbr:do <text> | |
|---|---|---|---|
| Purpose | Dashboard — show progress, suggest next | Auto-execute the next logical step | Route freeform text to a skill |
| Reads state? | Yes (full scan) | Yes (minimal) | No |
| Modifies files? | Never | Yes (via delegation) | Depends on routed skill |
| Asks questions? | If multiple options | Never — fully automatic | Only if ambiguous |
| Use when... | You want to see where you are before deciding | You trust PBR to pick and run the next step | You'd rather describe a task in plain English |
| Hard stops | N/A | Milestones, checkpoints, errors, verification gaps | N/A |
aggressive (delegate everything) | balanced | minimal (run inline)quick (skip research, ~50% cheaper) | standard | comprehensive (~2x cost).planning/STATE.md (position), .planning/ROADMAP.md (phases), .planning/config.json (settings)/pbr:config to change depth, models, gates, parallelizationclaude agents in your terminal to see all registered PBR agents and verify loading/pbr:quick for creative/visual work where structured planning adds overhead without benefit..planning/ commits can be filtered using phase branching (git.branching: phase) which squash-merges code-only changes to main./pbr:explore can create seed files (.planning/seeds/) with trigger conditions. Seeds auto-inject into planning when their trigger phase is reached.Plan-Build-Run includes three behavioral contexts in contexts/ that adjust how Claude operates:
Skills automatically activate the appropriate context: /pbr:build uses dev context, /pbr:discuss uses research context, /pbr:review uses review context.
Use /pbr:quick when... | Use /pbr:plan + /pbr:build when... |
|---|---|
| Change touches ≤3 files | Change touches 4+ files |
| ≤100 lines of code | 100+ lines of code |
| Single subsystem | Multiple subsystems or cross-cutting |
| No architectural decisions | Requires design choices |
| Bug fix, small feature, docs | New feature, refactor, migration |
/pbr:begin — Use this to start a new project. It handles everything: questioning, research, requirements, roadmap, AND config initialization. This is the standard entry point./pbr:setup — Use this only to reconfigure an existing project's settings (model profiles, gates, depth, parallelization) without re-running the full begin flow.If you're unsure, start with /pbr:begin. It will detect existing config and offer to reuse or overwrite.
The features.team_discussions config flag (and /pbr:build --team) enables Agent Teams for complex builds. When enabled, executor agents can coordinate with each other during parallel wave execution — sharing context about what they've built, resolving interface conflicts, and avoiding duplicate work. Best for phases where multiple plans have shared dependencies. Configure via /pbr:config.
╔══════════════════════════════════════════════════════════════╗
║ ▶ NEXT UP ║
╚══════════════════════════════════════════════════════════════╝
- `/pbr:begin` — start a new project
- `/pbr:status` — check current project status
- `/pbr:config` — configure workflow settings
- `/pbr:help <command>` — detailed help for a specific command