Coordinator

Orchestrate skills through a phased workflow: brainstorm, challenge, design/plan, challenge, implement, finish.

Announce at start: "Using the coordinator skill to orchestrate this workflow."

Determine Scope

Classify the request before starting:

Ask if unclear: "Is this an idea exploration, a plan, or a full build?"

Phases

Phase 1: Brainstorm

1. •Load and apply the brainstormer skill
   • •Generate diverse ideas across multiple thinking frameworks
   • •Produce 2-4 ideas per framework, covering 3-5 frameworks
2. •Load and apply the brainstorming skill
   • •Refine the best ideas through collaborative dialogue
   • •Present design in sections, validate incrementally

Output: Refined ideas with rationale and top picks.

Checkpoint: Present top ideas. Continue unless redirected.

Phase 2: Challenge Ideas

1. •Load and apply the challenger skill
   • •Attack ideas across all dimensions (security, correctness, performance, scalability, UX, maintainability, edge cases)

Gate:

• •Critical issues found → STOP. Present issues, ask how to proceed.
• •Medium/low only → Summarize findings, continue automatically.

Output: Challenge report with severity ratings.

For Idea scope: Stop here. Present final deliverable.

Phase 3: Design & Plan

Run applicable sub-phases:

3a. Design (if UI/UX involved):

• •Load and apply the designer skill
• •Review and improve UX, produce design recommendations

3b. Plan:

• •Load and apply the planner skill
• •Create structured plan with approaches, trade-offs, risks

3c. Implementation Plan (Build scope only):

• •Load and apply the writing-plans skill
• •Create detailed task-level implementation plan with file paths and code examples

Checkpoint: Present the plan. Continue unless redirected.

For Plan scope: Stop here. Present final deliverable.

Phase 4: Challenge Plan

1. •Load and apply the challenger skill again
   • •Evaluate the plan for risks, missing steps, wrong ordering, feasibility

Gate:

• •Critical issues found → Revise plan based on findings, re-challenge. Max 2 revision cycles.
• •Medium/low only → Summarize, continue automatically.

Output: Validated, battle-tested plan.

Phase 5: Implement

1. •Load and apply the test-driven-development skill
   • •TDD is mandatory: no production code without a failing test first
2. •Load and apply the executing-plans skill
   • •Execute plan in controlled batches with review checkpoints

Within each batch:

• •RED: Write failing test
• •GREEN: Minimal code to pass
• •REFACTOR: Clean up, stay green
• •Review between batches

Gate:

• •Tests failing after 2 fix attempts → STOP. Report issue, ask for direction.
• •Batch complete → Brief summary, continue to next batch.

Phase 6: Finish

1. •Load and apply the finishing-a-development-branch skill
   • •Verify all tests pass
   • •Present completion options (merge, PR, keep, discard)
   • •Clean up worktree if applicable

Autonomy Rules

Workflow Diagram

[Request] → Classify scope (Idea / Plan / Build)
     │
     ▼
Phase 1: Brainstorm ──────── brainstormer → brainstorming
     │ checkpoint
     ▼
Phase 2: Challenge Ideas ─── challenger
     │ STOP if critical
     ▼                        ← Idea scope ends here
Phase 3: Design & Plan ───── designer → planner → writing-plans
     │ checkpoint
     ▼                        ← Plan scope ends here
Phase 4: Challenge Plan ──── challenger
     │ STOP if critical → revise → re-challenge
     ▼
Phase 5: Implement ────────── TDD + executing-plans
     │ STOP if stuck
     ▼
Phase 6: Finish ───────────── finishing-a-development-branch

Key Principles

• •One skill at a time — Load and complete each skill before moving to the next.
• •Challenge gates — Critical issues block progress; medium/low don't.
• •TDD is non-negotiable — No implementation code without failing tests first.
• •Incremental validation — Check with human at phase boundaries.
• •Skip what doesn't apply — Not every request needs all phases.
• •Autonomy with guardrails — Run freely, stop when uncertain or blocked.

Skills Referenced