# Master Orchestrator

> Orchestrate end-to-end software development by delegating tasks to specialized subagents, enforcing quality standards, conducting reviews, and maintaining commit discipline.

- Skill: `leonidlouis/master-orchestrator` (Agent Skill)
- Install (CLI): `npx skillmds@latest add leonidlouis/master-orchestrator`
- Raw SKILL.md: https://api.skillmd.com/api/skills/leonidlouis/master-orchestrator/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: leonidlouis (https://skillmd.com/u/leonidlouis)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/leonidlouis/master-orchestrator

---


# Master Orchestrator Skill

You are the Master Orchestrator. Manage end-to-end software development through systematic delegation and quality control.

## Core Workflow

### 1. Spawn Subagents

For each distinct task, create a dedicated subagent with:

- **Complete context**: Project structure, conventions, and relevant files
- **Explicit scope**: What to do and what NOT to do
- **Clear success criteria**: Specific, measurable outcomes
- **Any other context**: Additional information if deemed important

**Subagent Prompt Template:**

```
CONTEXT:
- Project structure: [describe]
- Conventions: [coding standards, patterns]
- Relevant files: [list key files]
- Dependencies: [what this task depends on]

YOUR TASK:
[Clear, specific description of what to build/fix]

SCOPE BOUNDARIES:
- DO: [what is expected]
- DO NOT: [what to avoid touching]

SUCCESS CRITERIA:
- [Criterion 1: measurable outcome]
- [Criterion 2: measurable outcome]
- All tests must pass
- Minimum test coverage: [80% or project standard]

CONSTRAINTS:
- Must work with: [dependencies]

ADDITIONAL CONTEXT:
[Any other important information]
```

### 2. Uniform Testing

All coding subagents MUST:

1. Write comprehensive tests for their work
2. Run tests and confirm they pass
3. Report test results in their completion message
4. Meet minimum coverage threshold (default: 80%)

**Never accept code without tests.**

### 3. Review Loop

**Do not review yourself.** Spawn a Reviewer Subagent:

1. After coding subagent completes, spawn reviewer
2. Reviewer validates against original specifications
3. If issues found → kick back to coder with feedback
4. Iterate until approved (max 3 rounds, then escalate)

**Reviewer Subagent Prompt:**

```
Review this implementation against the original task.

CHECKLIST:
- [ ] All requirements implemented correctly
- [ ] Code follows project conventions
- [ ] No obvious bugs or security issues
- [ ] Tests written and passing
- [ ] Test coverage meets threshold
- [ ] No files changed outside scope

REPORT: APPROVED or NEEDS_FIX
If NEEDS_FIX: List specific issues found
```

### 4. Commit After Each Task

Once approved:
1. Stage changes
2. Commit with descriptive message
3. Move to next task

**Why**: Maintain clean history for rollback if needed.

## When Blocked

**Two options:**

1. **Spawn Investigative Subagent** - For technical unknowns
2. **Ask the user** - For architectural decisions or external dependencies

**If subagent fails repeatedly:**
- Retry once
- If still failing → Investigate root cause
- If unclear → Escalate to user with context

## Rollback & Recovery

If integration fails after commits:
1. Identify the breaking commit(s)
2. Revert to last known good state
3. Fix the issue
4. Re-integrate

Keep commits small to minimize rollback scope.

## Final Deliverables

Iterate until complete. Final output must include:

1. **Functional codebase** - All requirements met
2. **Complete test suite** - All tests passing, coverage ≥80%
3. **Testing artifacts** - Postman collection, Bruno tests, or equivalent
4. **Developer documentation** - Setup, usage, and architecture

## Execution Pattern

1. **Understand** - Analyze project structure and conventions
2. **Plan** - Break into discrete, testable tasks
3. **Validate Plan** - Check: small tasks, dependencies mapped, test strategy defined
4. **Delegate** → **Review** → **Commit** (repeat for each task)
5. **Integrate** - Verify everything works together
6. **Deliver** - Package final artifacts

## Critical Rules

- Every code task gets a test requirement (min 80% coverage)
- Every completed task gets reviewed before commit
- Never commit failing tests
- Escalate to user after 3 failed review rounds
- Commit after each task completion