PABCD Workflow Default Active

Structured Plan → Audit → Build → Check → Done development workflow with mandatory user checkpoints at each gate.

Auto-active skill. dev-pabcd is one of the 10 development skills injected into every session automatically. It activates during orchestration mode and provides the structured 5-phase workflow that ensures nothing gets built without a reviewed plan.

Quick Reference

PropertyValue
Skill namedev-pabcd
CategoryDevelopment / Orchestration
Default activeYes — injected at session start
Requires /skill loadNo
PhasesP (Plan) → A (Audit) → B (Build) → C (Check) → D (Done)
User gatesP, A, B require approval — C, D auto-advance
Worker roleRead-only verifiers (never write code)
Reset commandcli-jaw orchestrate reset

State Machine

PABCD is a one-way loop — forward only, no skipping phases. Each phase must complete before advancing to the next.

IDLE ──→ P ──→ A ──→ B ──→ C ──→ D ──→ IDLE
         │      │      │      │      │
        STOP   STOP   STOP   auto   auto
        wait   wait   wait

Phases P, A, and B halt and wait for user approval before advancing. Phases C and D proceed automatically once their work is complete.

Transition Commands

CommandTransitionPrerequisite
cli-jaw orchestrate PEnter PlanningMust be in IDLE
cli-jaw orchestrate AEnter Plan AuditMust be in P (plan approved)
cli-jaw orchestrate BEnter BuildMust be in A (audit passed)
cli-jaw orchestrate CEnter CheckMust be in B (build approved)
cli-jaw orchestrate DEnter DoneMust be in C (check complete)
cli-jaw orchestrate resetReturn to IDLEAny state

Phase Details

P — Plan User Approval Required

The planning phase reads project docs and dev skills, then produces a plan with two parts:

  • Part 1 — Easy explanation: What will be built, in non-developer terms. Anyone should understand this.
  • Part 2 — Diff-level precision: Exact file paths (NEW / MODIFY / DELETE), before/after diffs for MODIFY, complete content for NEW.

Scope Clarification

If the request has unclear scope or unspecified technology, the planner clarifies first:

  • Presents 2-3 options as <TechName> -- <plain explanation>
  • Recommends one with project-specific reasoning
  • Confirms once, then proceeds

Repository Scan (broad changes)

For broad changes or unfamiliar repositories, the P phase MUST include:

  • Compact tree of the current repository shape
  • Detected repo conventions: docs, plans, architecture notes, source-of-truth logs, naming, tests
  • Whether existing structure/, devlog/, docs/, plans/, or equivalent logs were read and will be reused
  • Whether structure/ or devlog/ is proposed

Devlog Naming Convention

If PABCD work creates or updates devlog/ plan artifacts, the plan MUST list exact numbered Jawdev filenames:

00_overview.md
01_phase1_<slug>.md
02_phase2_<slug>.md

Bare filenames like PLAN.md, DIFF_PLAN.md, PHASES.md, RCA.md, or plan.md are not allowed as new devlog phase files.

Gate Questions

Before presenting the plan, the planner asks:

  1. "Any business logic I shouldn't decide alone?"
  2. "Does Part 1 match your intent?"

The plan is presented and revised on feedback. When the user approves, transition with cli-jaw orchestrate A.

A — Plan Audit User Approval Required

A worker is spawned to audit the plan (not the code). The worker verifies:

  • All file paths and imports in the plan actually exist
  • Function signatures match real code
  • No integration risks
  • Existing source-of-truth docs/logs were read when present
  • No new structure/, devlog/, docs, or AGENTS files are introduced without user approval
  • New JS/TS files follow TypeScript preference rules unless the plan states why JS is required
  • New TypeScript is strict-compatible or limitations are stated
  • New devlog phase documents use the numbered Jawdev filename convention

Worker outputs JSON for the audit. Results are reviewed:

  • FAIL → Fix the plan, re-audit
  • PASS → Report results to the user

When the user approves, transition with cli-jaw orchestrate B.

B — Build User Approval Required

Implementation phase. The boss writes all code directly. Workers are read-only verifiers only.

After implementing, a worker is dispatched for verification — checking that code exists and integrates cleanly:

  • NEEDS_FIX → Boss fixes the issues, re-verifies
  • DONE → Report results to the user

Does not create structure/ or devlog/ unless approved in P or explicitly requested.

When the user approves, transition with cli-jaw orchestrate C.

C — Check Auto-advance

Final sanity check that runs automatically:

  1. Verify all files saved and consistent
  2. Run npx tsc --noEmit (if TypeScript project)
  3. Update project structure docs if applicable
  4. Report completion summary

When done, automatically transitions to D via cli-jaw orchestrate D.

D — Done Auto-advance

Summarizes the entire PABCD flow:

  • What was planned (P), audited (A), built (B), checked (C)
  • List of files changed
  • Any follow-up items

State returns to IDLE automatically.

Rules

#RuleDetails
1One phase per responsePresent work, then wait for user approval at P, A, B gates. Never skip ahead.
2Strict sequenceP → A → B → C → D. Use cli-jaw orchestrate reset to restart from IDLE.
3Workers verify, boss writesWorkers are read-only. All code is written directly by the boss in B phase.

Repository Root Contract

Before writing a PABCD plan or dispatching a worker, determine the actual working repository root with pwd -P from the target repo.

Every A/B phase cli-jaw dispatch task body MUST begin with:

Project root: /absolute/path/to/current/repo
RuleDescription
Project root = working repoMust be the current working repository, not JAW_HOME
No inferenceNever let workers infer the repo root from ~/.cli-jaw*, process.cwd(), or an employee temp directory
Absolute pathsResolve all relative repo paths (src/, tests/, structure/, skills_ref/) against Project root
Unknown root = STOPIf Project root is unknown, stop and ask before dispatching

Shared Plan Injection

When P completes, the plan is saved to the worklog ## Plan section (single source of truth) and kept in ctx.plan. No project-root file is created.

Auto-injection: In A and B phases, the orchestrator automatically injects the full plan body at the top of every cli-jaw dispatch task under ## Approved Plan. Workers never need to read a plan file — it is prepended for them.

Your dispatch task body should contain only the actual audit/verify instruction. Example:

cli-jaw dispatch --agent "Backend" --task "Project root: /path/to/repo

Audit: verify the imports in src/routes/auth.ts..."

No "read the plan" line is needed — the plan is already injected.

Pitfalls

Critical anti-patterns to avoid during PABCD execution.

Delegation Trap

In B phase, the boss writes all code. Workers are READ-ONLY verifiers.

DispatchExample
ForbiddenWriting/implementing"implement the feature", "write the code", "create the file"
AllowedVerifying/checking"verify src/x.ts compiles", "check integration of Y", "report DONE or NEEDS_FIX"

Context Drift

If a worker says "I'll proceed based on my assumption of the plan"STOP. Verify the dispatch went through /api/orchestrate/dispatch (only that path auto-injects the plan). Never let workers reconstruct the plan from a short task description.

Phase Skip

A (audit) is never "unnecessary". Even trivial plans can hit integration issues. Audit first. B verification is never "skippable". Untested code is not "done". The orchestrator does not enforce these gates today — YOU do.

"~해줘" Usage Examples

Real-world examples of triggering PABCD workflow in natural language.

Feature development
"이 프로젝트에 WebSocket 채팅 기능 추가해줘"

Triggers full PABCD: plans the WebSocket architecture, audits imports and integration points, builds the implementation, checks TypeScript compilation, and summarizes changed files.

Refactoring with plan
"인증 시스템 전체 리팩토링해줘 -- JWT에서 세션 기반으로"

Scope is broad, so P phase scans the repository tree, identifies all auth-related files, and produces diff-level precision plans. A phase audits that no import paths are broken.

Database migration
"D1 데이터베이스 스키마 마이그레이션 계획 세워줘"

P phase clarifies migration scope (which tables, backwards compatibility), produces Part 1 easy explanation and Part 2 exact SQL migration files. A phase verifies existing schema references.

Multi-file feature
"API 라우트 5개 새로 만들고 테스트도 다 붙여줘"

P phase lists all NEW files with complete content. B phase implements each route and test file. C phase runs tsc --noEmit across the project to catch type errors.

Bug fix with audit
"프로덕션 에러 원인 찾아서 고쳐줘 -- PABCD로 진행해"

Even for bug fixes, PABCD ensures the root cause is documented in P, the fix plan is audited in A, the implementation is verified in B, and nothing else breaks in C.

Relationship to Other Skills

PABCD is the structured workflow layer that wraps around other development skills. When PABCD is active, specialist skills like dev-backend, dev-frontend, and dev-testing operate within the B (Build) phase under PABCD's supervision.

SkillRelationship to PABCD
devOrchestrator that can activate PABCD for complex tasks
dev-backend / dev-frontendSpecialist context injected during B phase implementation
dev-testingTest writing happens in B phase; test execution in C phase
dev-code-reviewerComplements A phase by reviewing code quality post-build
dev-debuggingCan trigger PABCD for structured bug-fix workflows
dev-securitySecurity checks integrated into A (plan audit) and C (check) phases
See also: Concepts → PABCD for the high-level overview, and Development Skills for the full list of auto-active development skills.