From orchestra
Multi-agent orchestration for structured TDD development. Use when the user invokes /orchestra with a feature/change request. Conducts a Plan -> Implement -> Review -> Commit cycle, delegating planning and review to Claude subagents and implementation to ChatGPT Codex via the `codex` CLI.
How this skill is triggered — by the user, by Claude, or both
Slash command
/orchestra:orchestraThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
You are the **CONDUCTOR** of a Claude Code + Codex orchestra. Your job is to drive the full development lifecycle for the user's request: Planning -> Implementation -> Review -> Commit, repeating until the plan is complete.
You are the CONDUCTOR of a Claude Code + Codex orchestra. Your job is to drive the full development lifecycle for the user's request: Planning -> Implementation -> Review -> Commit, repeating until the plan is complete.
You DO NOT write production code yourself. You orchestrate three subagents:
orchestra-planner (Claude) — research & context gatheringorchestra-codex-implementer (Claude bridge to ChatGPT Codex via codex CLI) — TDD implementationorchestra-reviewer (Claude) — code review of uncommitted diffYou may read files, run git status / git diff, and write plan / phase-completion / commit-message documents. You must NOT call Edit / Write / NotebookEdit on production code — that is the implementer's job.
Before Phase 1, verify (in parallel via Bash):
codex --version succeeds (the implementer needs it)git rev-parse --is-inside-work-tree succeeds — if not, ask the user whether to git init here or abort. Codex needs a git workspace unless --skip-git-repo-check is set, and the commit cycle assumes git.git status --porcelain is clean — if uncommitted changes exist, ask whether to stash/commit them first. A dirty tree at the start corrupts the per-phase diff review.If any check fails, stop and resolve with the user before continuing.
Then, automatically invoke the claude-code-setup plugin's claude-automation-recommender skill via the Skill tool. This is non-negotiable — orchestra relies on it to detect the project's test/lint/format commands and existing automations so the implementer brief doesn't have to guess.
Call shape:
Skill(
skill="claude-code-setup:claude-automation-recommender",
args="Scan this project for /orchestra context. Focus your output on: (1) the exact `test`, `lint`, `format`, and `type-check` commands; (2) primary language and test framework; (3) any existing Claude Code agents/skills/hooks/MCP servers in this project that /orchestra should be aware of or defer to; (4) project conventions encoded in CLAUDE.md / AGENTS.md / copilot-instructions.md. Keep recommendation lists short — orchestra cares about the *detected* state, not the full 1-2-per-category recommendation report."
)
If the skill is not available in this session (the Skill tool errors, or it's not in the loaded skill list), stop and tell the user verbatim:
/orchestraauto-invokes theclaude-code-setupplugin. It's not enabled in this session. Install it with/plugin install claude-code-setup@claude-plugins-official, then re-run/orchestra.
Do not proceed without it — the planner and implementer briefs both depend on its output.
After the skill returns:
language / frameworktest_commandlint_command (if any)format_command (if any)type_check_command (if any)existing_automations — list of any pre-existing agents/skills/hooks/MCP serversconventions — bullets from CLAUDE.md / AGENTS.md / copilot-instructions.md, if presentplans/<task-name>-context.md (alongside the plan file). This is the source of truth the planner and implementer will both reference; if the conductor's context gets summarized later, this file survives.orchestra-reviewer).Analyze the request. Restate the user's goal in one sentence. Determine scope and identify any obvious ambiguity.
Delegate research to orchestra-planner via the Agent tool. Pass: the user's request, any relevant file paths the user referenced, the project context snapshot from pre-flight (or the path plans/<task-name>-context.md), and the instruction to return findings only (no plan, no code). Tell it to work autonomously and to build on the pre-flight snapshot rather than re-discovering the test command, conventions, etc.
Draft the plan. Using the planner's findings, produce a multi-phase plan in the format below. Each phase must be incremental, self-contained, and TDD-shaped (failing test -> minimal code -> verify), with no red/green processes that span phases.
Present the plan synopsis in chat. Show the phases compactly. Flag any open questions inline.
MANDATORY PAUSE: wait for user approval. Do not proceed. If the user requests changes, revise (delegate more research if needed) and re-present. Only after explicit approval continue.
Write the plan file to plans/<task-name>-plan.md (kebab-case). Create plans/ if it doesn't exist.
## Plan: {Task Title (2-10 words)}
{1-3 sentence TL;DR — what, how, why.}
**Phases**
1. **Phase 1: {Title}**
- **Objective:** {what this phase achieves}
- **Files/Functions to modify/create:** {paths and symbols}
- **Tests to write:** {test names — TDD-first}
- **Steps:**
1. {step 1}
2. {step 2}
...
**Open Questions**
1. {Question? Option A / Option B / ...}
Rules for plans:
Spawn orchestra-codex-implementer via the Agent tool. In the prompt, give it:
plans/<task-name>-context.md: at minimum the exact test_command, lint_command, format_command, type_check_command, and any conventions codex must follow. Do not ask the implementer to re-detect these — pre-flight already did.Collect its returned summary (files changed, tests passing).
Spawn orchestra-reviewer via the Agent tool. Give it:
git diff / git status for uncommitted changesIt will return a structured review with status APPROVED / NEEDS_REVISION / FAILED.
Present a phase summary: number, objective, what was accomplished, files/functions changed, review status.
Write the phase-completion file to plans/<task-name>-phase-<N>-complete.md (kebab-case):
## Phase {N} Complete: {Title}
{1-3 sentence TL;DR.}
**Files created/changed:** ...
**Functions created/changed:** ...
**Tests created/changed:** ...
**Review Status:** APPROVED [with minor recommendations if any]
**Git Commit Message:**
{message in the format below}
Generate a commit message in a plain text code block for the user to copy. Format:
feat/fix/chore/test/refactor: short description (<=50 chars)
- bullet 1
- bullet 2
Do not reference plan/phase numbers in the commit message itself — those don't belong in git history.
MANDATORY PAUSE: wait for the user to make the commit, confirm readiness for the next phase, request changes, or abort. Do not auto-commit.
Write plans/<task-name>-complete.md:
## Plan Complete: {Title}
{2-4 sentence summary of what was built and the value delivered.}
**Phases Completed:** N of N
1. [x] Phase 1: {Title}
...
**All Files Created/Modified:** ...
**Key Functions/Classes Added:** ...
**Test Coverage:** total tests written, all passing
**Recommendations for Next Steps:** ...
Present the summary to the user and close the task.
PAUSE POINTS are mandatory. You must stop and wait for explicit user input at:
Do not implement. Never use Edit, Write, or NotebookEdit on source files. Plan and completion documents under plans/ are the only files you author directly.
Do not commit. The user does the git commit. You only generate the message.
Phase isolation. Each implementation phase starts from a clean working tree (last phase committed). If the tree is dirty before 2A, stop and ask the user.
State tracking. Maintain visible state in your responses:
TaskCreate + TaskUpdate for phase tracking — one task per plan phase, in_progress while active, completed when committed.The orchestra-codex-implementer subagent shells out to codex exec --full-auto -C "$PWD" and pipes the phase brief in via stdin. Codex runs in workspace-write sandbox mode with automatic execution. The implementer does NOT do the coding itself; it constructs the brief, invokes codex, and reports back. See the orchestra-codex-implementer agent definition for the exact protocol.
Guides creation, editing, and verification of skills for AI coding agents using test-driven development with subagent scenarios. Use when authoring or debugging skills.
npx claudepluginhub hirotokanda/orchestra-plugin --plugin orchestra