Skip to content
Skills Library
AI & agents · Automation

orchestrate

/orchestrate

Use when executing a locked implementation plan (PLAN.md or equivalent) that is too big for one context window — "execute the plan", "implement PLAN.md", "orchestrate this implementation", "split the plan into phases and build it". Not for edits you can finish inline.

Repository
tgc-skills ↗
Licence
MIT
Last repository change
17.07.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 17.07.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when executing a locked implementation plan (PLAN.md or equivalent) that is too big for one context window — "execute the plan", "implement PLAN.md", "orchestrate this implementation", "split the plan into phases and build it". Not for edits you can finish inline.

Triggers from the description

execute the planimplement PLAN.mdorchestrate this implementationsplit the plan into phases and build it

Arguments

/orchestrate [plan-path]
Original author description

Use when executing a locked implementation plan (PLAN.md or equivalent) that is too big for one context window — "execute the plan", "implement PLAN.md", "orchestrate this implementation", "split the plan into phases and build it". Not for edits you can finish inline.

How it works

  1. Phase 0 — Inputs
  2. Phase 1 — Split the plan into phases (+ detect parallel lanes)
  3. Phase 2 — Repo prep & the brief
  4. Phase 3 — The per-phase loop
  5. Hard rules
  6. What NOT to do
Original SKILL.md headings · 194 lines, 1,508 words
SKILL.md preview
---
name: orchestrate
description: Use when executing a locked implementation plan (PLAN.md or equivalent) that is too big for one context window — "execute the plan", "implement PLAN.md", "orchestrate this implementation", "split the plan into phases and build it". Not for edits you can finish inline.
disable-model-invocation: true
argument-hint: "[plan-path]"
---

# Orchestrate — execute a plan via fresh-context agents, one phase at a time

You are the **orchestrator** (manager). You do NOT write the implementation yourself.
You split a locked plan into **context-window-sized phases** and dispatch one **fresh
subagent per phase** (Agent tool, `general-purpose`). A new subagent IS a pristine
context, so every phase starts clean and re-grounds from disk (the plan + the brief +
`git log`) instead of inheriting a lossy summary.

Three non-negotiables:

1. **One phase per subagent.** A phase is a coherent slice of the plan sized to fit one
   context window (it may be several commits). Split anything bigger; cluster anything
   trivially small. Never bundle "do phase N then N+1" into one dispatch.
2. **Every phase re-grounds from disk.** The phase prompt is self-contained: absolute
   plan path + this phase's scope + explicit stop point. The agent reads the plan, the
   brief, and `git log` fresh — it inherits nothing from you or the previous phase.
3. **Keep the orchestrator's context clean.** Never read implementation source files
   into your own window. Verify phases with git plumbing and narrow greps; delegate
   deeper checks to a throwaway read-only agent that returns one-line PASS/FAIL.

**Prerequisite:** a locked plan file exists (written and reviewed — not a vague idea).
If there is no plan, write one first and get it approved before orchestrating.

## Phase 0 — Inputs

Resolve the **absolute path** to the plan file and the target repo directory(ies).
Read the plan ONCE to derive the phase list — after that, rely on disk, not memory.

## Phase 1 — Split the plan into phases (+ detect parallel lanes)

Parse the plan into an ordered list of phases. For each phase record:

- **number + one-line title** and which plan section(s) it covers;
- **repo** it touches (its lane);
- a **description**: concrete scope + an explicit **stop point** ("…and nothing else");
- **GATED?** — true if irreversible or outward-facing (deletes code, deploys, runs
  migrations, hits staging/prod). Gated phases need explicit human OK before they run;
- any **watch-items** (risks to carry into later phase prompts).

**Detect parallel lanes.** Group phases by repo. If the plan spans multiple repos that
can progress independently — each side codes to a contract the plan already pins down,
with no phase in repo A needing a not-yet-built phase in repo B — mark them as parallel
lanes and dispatch one agent per lane concurrently (multiple Agent calls in a single
message). If phases cross-depend, keep them sequential. When unsure, default to
sequential and say why.

**Track progress.** Create one todo/task per phase in execution order so progress
survives compaction. Within a lane, phases run strictly in order; at most one phase
`in_progress` per lane.

Then **present the phase breakdown + lane plan to the human and get confirmation
before dispatching anything.** If the session is running autonomously toward an
already-approved goal, state the breakdown and proceed.

## Phase 2 — Repo prep & the brief

**Pick the branch base from the remote** (per repo). Resolve the GitHub default branch
and fetch its current tip:

```bash
DEFAULT_BRANCH=$(gh repo view --json defaultBranchRef --jq '.defaultBranchRef.name')
git fetch origin "$DEFAULT_BRANCH"
```

Use `origin/$DEFAULT_BRANCH` unless the approved plan explicitly names another base.
If it does, fetch that ref and verify its relationship to the default branch with
`git merge-base --is-ancestor` before creating the feature branch.

**Create one session directory for the whole run** outside every repo, before touching
any lane:

```bash
SESSION_DIR=$(mktemp -d "${TMPDIR:-/tmp}/tgc-orchestrate.XXXXXX")
```

Keep it for the lifetime of the run; the lane briefs live inside it. When the run ends —
whether every lane finished, a lane failed, or the user aborted — remove it as the final
step so temporary briefs never linger:

```bash
rm -rf "$SESSION_DIR"
```

For each lane:

1. **Require a clean repo, then branch.** Run `git status --porcelain` and stop on staged,
   unstaged, or untracked work. Create the feature branch off the verified remote base.
   Never work on the default branch; never force-push.
2. **Write the lane brief into the shared session directory.** Use
   `<SESSION_DIR>/<lane>-WORKER-BRIEF.md` as the standing orders every phase agent
   re-reads. Pass its absolute path in every phase prompt. Never create cleanup artifacts
   in the repo root.
3. **Discover the repo's local gate before writing the brief** — read the
   repo instructions, pre-push hook, and project scripts. Put the complete reproducible
   local gate into the brief. Do not claim that isolated GitHub Actions `run:` lines
   reproduce action steps, matrices, services, or external checks. If no local gate
   exists, say CI is authoritative instead of inventing one.

### Lane brief template

```markdown
# Worker Brief — <plan title> — <repo> lane

You are executing ONE phase of a locked plan with a fresh context. At the start you MUST:
1. Read the full plan at <ABSOLUTE PLAN PATH> (the authoritative spec).
2. Read this brief.
3. Run `git log --oneline -20` to see which phases are already committed.
4. Implement ONLY the phase named in your prompt, up to its stated stop point.

## Ground truth (overrides any stale wording in the plan)
- Repo: <abs path>. Branch: <feature-branch> (off <verified remote base>). Never switch
  branches; never touch the default branch; never force-push.
- Already done / out of scope: <what's committed; what NOT to do>.
- Contracts this builds against: <pinned API shapes etc.>.

## Conventions (from the repo's CLAUDE.md / AGENTS.md)
- Commits: <repo-documented or recent-log convention; conventional fallback>.
- <lint / typecheck / test commands>.
- Code comments must never reference the plan or its scaffolding (no "Phase N",
  "per the plan", banner separators). Comment only non-obvious WHY.

## Per-phase workflow
1. Implement the one named phase, up to its stop point.
2. Self-verify with the repo's reproducible local gate: <exact command, or explicit
   CI-only limitation>. Fix local failures; never claim an unavailable gate passed.
3. Run a simplification pass over your changes (delete reinvented stdlib, needless
   abstractions) and apply reasonable findings; re-verify if you changed anything.
4. Commit using the repo's convention, staging ONLY intended files. Never commit this
   temporary brief. Treat plans and documentation according to the repo and user intent.
5. Return a short report: what changed, commit hash(es), verification results, any
   watch-items for later phases — then STOP. Do not start the next phase.
6. If blocked after one real attempt, report `BLOCKED: <reason>` instead.
```

## Phase 3 — The per-phase loop

For each phase, in lane order:

1. **Dispatch a fresh `general-purpose` agent** with a self-contained prompt:

   > Read the full plan at `<ABSOLUTE PLAN PATH>`, then the lane brief at
   > `<ABSOLUTE BRIEF PATH>`,
   > then run `git log --oneline -20` to see completed phases. You are on branch
   > `<branch>`; do not switch. Implement ONLY phase `<N>`: `<description>` and stop
   > after `<stop point>`; build nothing beyond it. `<Watch-items from prior phases.>`
   > Follow the brief's per-phase workflow: reproducible local gate, simplification
   > pass, and repo-convention commit staging only intended files. Report what changed, commit
   > hashes, and verification results. Do NOT start the next phase.

2. **On return, verify independently and lightly** — without reading source into your
   context:

   ```bash
   git log --oneline -5                         # the phase's commit(s) landed
   git show --stat HEAD | tail -n +2            # only intended files, sane sizes
   git status --short                           # nothing stray or unrelated
   grep -nE '<a key symbol this phase adds>' <changed file>   # narrow spot-check
   ```

   For deeper review, spawn a throwaway read-only agent that checks the phase and
   returns one-line PASS/FAIL.

3. **Verified →** mark the phase completed, dispatch the next. **`BLOCKED:` or a bad
   report →** resolve it from the plan/brief if you safely can (fix instructions and
   re-dispatch the phase to a NEW fresh agent), else escalate to the human. Failed
   phases are re-dispatched fresh, never "continued" — the broken context is gone.

4. **GATED phase →** stop and get explicit human confirmation before dispatching it.

Parallel lanes: dispatch one phase per lane concurrently (single message, multiple
Agent calls), verify each on return, advance each lane independently.

## Hard rules

- You orchestrate; you do not implement. One phase per fresh agent, always.
- The phase agent never advances itself — only you dispatch the next phase, after
  verifying the previous one.
- Parallel only for genuinely independent repo lanes. Cross-dependent phases stay
  sequential. At most one in-flight phase per lane.
- GATE before anything irreversible or outward-facing. Don't trust branch labels;
  confirm topology. Don't fake convergence; report real failures.
- Temporary briefs and logs live only in the session directory and are removed when the
  workflow finishes. Plans and repo documentation follow user intent and repo policy.

## What NOT to do

- Don't read implementation files or full diffs into your context "just to be sure" —
  delegate verification instead.
- Don't parallelize lanes that cross-depend; don't let one lane outrun a gated step.
- Don't let a phase agent batch phases or skip its self-verification.
- Don't silently resolve a real decision on the agent's behalf — a genuine design or
  irreversibility question goes to the human.

Versions

RepositoryScoreLicence
This page · eternalllight/tgc-skills100MIT
kriegcloud/beep-effect100Apache-2.0
zahidakhyar/skills100MIT
jkaloger/lazyspec100MIT
superset-sh/superset100MIT
boshu2/agentops100Apache-2.0
Ovich/charrette100MIT
matthew-eth724/orchestrate100MIT
nickthelegend/nick-skills100MIT

Database snapshot: 13.11.2026 · package version a1d635558181 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100orchestrate-plan
    Use when executing a locked, reviewed PLAN.md by delegating the implementation to cmux worker pane(s) ONE PHASE at a time — splitting the plan into context-window-sized phases, fully clearing the worker's context between phases, and (when the plan touches INDEPENDENT repos)…
  • 95plan-orchestrate
    Execute implementation plans with parallel TDD workers. Use when ready to run, execute, or start a plan. Triggers on "run the plan", "execute the plan", "implement the plan", "start the plan", "start implementation", "orchestrate", "begin autonomous execution". Requires a plan…
  • 100plan-orchestrate
    读取计划文档,将其分解为步骤,从 ECC 目录中为每个步骤设计智能体链,并生成可直接粘贴的 /orchestrate 自定义提示。仅生成 —— 从不调用 /orchestrate 本身。当用户有多个步骤的计划并希望通过 orchestrate 驱动而无需手动组合链时使用。
  • 100plan-orchestrate
    Read a plan document, decompose it into steps, design a per-step agent chain from the ECC catalogue, and emit ready-to-paste /orchestrate custom prompts. Generative only — never invokes /orchestrate itself. Use when the user has a multi-step plan and wants to drive it through…
  • 100common-subagent-driven-development
    Execute an approved implementation plan at the context boundary that preserves required independence and review. Use when implementing plans, executing multi-task PRs, choosing between main-loop and dispatched execution, or transitioning from planning to implementation.
  • 100implement-plan
    Execute an approved implementation plan from the configured plans directory. Use when the user wants to implement a plan phase by phase with verification.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.