orchestrate
The orchestrate skill structures complex feature development into four sequential phases: research with confidence scoring, planning with approval gates, phased implementation with quality checkpoints, and final code review. Use this when building features spanning multiple files, requiring architectural decisions, involving unclear requirements, or touching cross-cutting concerns like authentication or logging where structured validation between phases prevents costly rework.
git clone --depth 1 https://github.com/rohitg00/pro-workflow /tmp/orchestrate && cp -r /tmp/orchestrate/skills/orchestrate ~/.claude/skills/orchestrateSKILL.md
# Orchestrate - Multi-Phase Feature Development
Build features through structured phases with validation gates.
## The Pattern
```text
/develop <feature>
│
├── Phase 1: Research (orchestrator agent)
│ └── Score confidence → GO/HOLD
│
├── Phase 2: Plan (orchestrator agent)
│ └── Present plan → wait for approval
│
├── Phase 3: Implement (orchestrator agent)
│ └── Execute plan → quality gates
│
└── Phase 4: Review (reviewer agent)
└── Code review → commit
```
## Usage
When asked to build a feature:
1. **Start with research**: Delegate to the orchestrator agent or scout agent to explore the codebase
2. **Wait for GO/HOLD**: Don't proceed if confidence is below 70
3. **Present a plan**: List all files to change, the approach, and risks
4. **Get approval**: Never implement without explicit "proceed"
5. **Implement step by step**: Quality gates every 5 edits
6. **Review before commit**: Run the reviewer agent on changes
## When to Use This
- Feature touches >5 files
- Architecture decisions needed
- Requirements are unclear or complex
- Cross-cutting concerns (auth, logging, error handling)
- New patterns not yet established in the codebase
## When NOT to Use This
- Quick bug fixes (just fix it)
- Single-file changes
- Well-understood patterns (follow existing code)
- Documentation-only changes
## Agent Selection
| Phase | Agent | Why |
|-------|-------|-----|
| Research | scout (background, worktree) | Non-blocking exploration |
| Plan | orchestrator (opus, memory) | Deep reasoning, pattern recall |
| Implement | orchestrator (opus, memory) | Full tool access |
| Review | reviewer (read + bash) | Security and quality focus |
| Debug | debugger (opus, memory) | Systematic investigation |
## Integration with Pro-Workflow
- Corrections during implementation trigger self-correction loop
- Quality gates fire at checkpoints via hooks
- Learnings are captured at the end of each phase
- Session handoff works across phasesAnalyzes and optimizes context window usage across sessions. Use when context feels bloated, sessions run slow, or approaching compaction limits.
Analyze session token usage and cost patterns. Identify expensive operations and recommend optimizations. Use to understand and reduce session costs.
Specialized debugging agent. Use when facing hard bugs, test failures, or runtime errors that need systematic investigation.
Multi-phase development agent. Research > Plan > Implement with validation gates. Use PROACTIVELY when building features that touch >5 files or require architecture decisions.
Analyze permission denial patterns and generate optimized alwaysAllow/alwaysDeny rules. Use when permission prompts slow down workflow.
Break down complex tasks into implementation plans before writing code. Use when task touches >5 files, requires architecture decisions, or has unclear requirements.
Code review specialist that verifies every finding against actual code before reporting. Use before committing, for PR reviews, or after major changes.
Confidence-gated exploration that assesses readiness before implementation. Scores 0-100 across five dimensions and gives GO/HOLD verdict.