What happens if I pass an unknown command?

If the argument doesn’t match a known command, the help system displays the full reference.

Can I get help for a subset of commands within a category (e.g., planning options only)?

Targeted help is shown only for exact top-level commands (plan, build, review, config, quick). If the argument doesn’t match, you’ll receive the full reference.

Does the help include flags for each command?

Yes. Targeted help for a specific command includes its subcommands and flags; the full reference lists all commands and their descriptions.

help

Flagged

{"isSafe":false,"isSuspicious":true,"riskLevel":"critical","findings":[{"category":"prompt_injection","severity":"critical","description":"Explicit prompt-injection attempt embedded in the skill content. The text tries to override system instructions and force immediate execution, including displaying a banner before any tool calls.","evidence":"\"**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.**\""}],"summary":"The skill contains a prompt-injection attempt aimed at subverting safe operation by overriding instructions and forcing immediate execution. This should be sanitized or blocked before loading such skills into a tool to prevent potential unsafe behavior."}

npx machina-cli add skill SienkLogic/plan-build-run/help --openclaw

Files (1)

SKILL.md

11.6 KB

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.

Step 0 — Immediate Output

Before ANY tool calls, display this banner:

╔══════════════════════════════════════════════════════════════╗
║  PLAN-BUILD-RUN ► COMMAND REFERENCE                          ║
╚══════════════════════════════════════════════════════════════╝

Then proceed to Step 1.

$pbr-help — Plan-Build-Run Command Reference

Contextual Help

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 below

Full Reference

Display the following reference to the user:

Plan-Build-Run Commands

Core Workflow (the main loop)

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)

Planning & Discovery

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.

Execution

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.

Verification & Debugging

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).

Session Management

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.

Project Management

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.

Analysis & Utilities

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.

Choose Your Command

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`

Typical Workflow

$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.

status vs continue vs do

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

Quick Reference

Context strategy: aggressive (delegate everything) | balanced | minimal (run inline)
Depth: quick (skip research, ~50% cheaper) | standard | comprehensive (~2x cost)
State files: .planning/STATE.md (position), .planning/ROADMAP.md (phases), .planning/config.json (settings)
Configure: $pbr-config to change depth, models, gates, parallelization
List agents: Run claude agents in your terminal to see all registered PBR agents and verify loading
Tip: Use $pbr-quick for creative/visual work where structured planning adds overhead without benefit.
PR hygiene: When creating PRs from a Plan-Build-Run project, .planning/ commits can be filtered using phase branching (git.branching: phase) which squash-merges code-only changes to main.
Seeds: $pbr-explore can create seed files (.planning/seeds/) with trigger conditions. Seeds auto-inject into planning when their trigger phase is reached.

Behavioral Contexts

Plan-Build-Run includes three behavioral contexts in contexts/ that adjust how Claude operates:

dev — Active development: write code first, low verbosity, medium risk tolerance
research — Exploration mode: read widely, no code writing, high verbosity, evidence-based
review — Code review: read thoroughly, prioritize by severity, report don't fix

Skills automatically activate the appropriate context: $pbr-build uses dev context, $pbr-discuss uses research context, $pbr-review uses review context.

When to Use Quick vs Plan+Build

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

Setup vs Begin

$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.

Team Discussions

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.

Getting Started



╔══════════════════════════════════════════════════════════════╗
║  ▶ 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

Getting Help

GitHub Issues: https://github.com/SienkLogic/plan-build-run/issues
README: https://github.com/SienkLogic/plan-build-run

Source

git clone https://github.com/SienkLogic/plan-build-run/blob/main/plugins/codex-pbr/skills/help/SKILL.mdView on GitHub

Overview

The help skill provides a command reference and workflow guide for Plan-Build-Run. It supports contextual help by showing only the matching command’s details when you specify a command name, or the full reference when you don’t. It organizes commands into core workflow, planning & discovery, execution, verification & debugging, and session management for quick navigation.

How This Skill Works

You input either a command name (e.g., plan, build, review, config, quick) or nothing. If a known command is provided, the tool returns only that command’s subcommands and flags. If no matching command is given, it displays the full reference covering core workflow, planning & discovery, execution, verification & debugging, and session management.

When to Use It

You need quick, targeted help for a specific command like plan, build, or review.
You want to see the full Plan-Build-Run command reference before starting a project.
You’re debugging a command and need to verify available flags (e.g., --assumptions, --skip-research, --gaps).
You’re planning a new project and want to understand the overall workflow and dependencies.
You want to review session management commands (status, health, pause) for long-running work.

Quick Start

Step 1: Run $pbr-help to see the full reference or $pbr-help <command> for targeted help.
Step 2: If targeting a command, review its subcommands and flags to plan your action.
Step 3: Use the guidance to proceed with Plan-Build-Run actions (plan, build, review, test) and manage your session as needed.

Best Practices

Ask for targeted help by supplying a known command name to reduce noise.
If unsure, start with $pbr-help to view the full reference and locate related commands.
Cross-check the listed flags (e.g., --assumptions, --skip-research, --gaps) against the command you’re using.
Use targeted help when troubleshooting specific steps (plan, build, review) to understand required options.
Leverage session management commands to track progress during multi-step workflows.

Example Use Cases

$pbr-help plan → shows only the plan command and its flags (--assumptions, --skip-research, --gaps, add, insert, remove).
$pbr-help build → shows only the build command and its flags (--gaps-only, --team).
$pbr-help review → shows only the review command and its flags (no explicit flags listed here; targeted help covers relevant options).
$pbr-help status → shows only the status (session management) command and its description.
$pbr-help → displays the full reference with all sections and commands.

Frequently Asked Questions

Add this skill to your agents