on
Skill10 starsChanged 2 days agoMITView on GitHub
Required for EVERY task that changes project code, tests, or config: the main session plans and verifies, haiku-coder executes, sonnet-dev takes escalations. Manual: /orchestrator:on <task>.
- Reads credentials
The file
We split this skill into the rules it gives an agent
8 rules. About 0 are common, 4 are distinctive, and 4 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈4
Distinctive · estimate
This author's own choices. Worth a look.
4
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 8
If /orchestrator:off was used earlier, orchestration is active again.
- Distinctive: line 17
NOT Opus-class (Sonnet, Haiku, others.
- Very specific: line 21
Short path: when ALL hold: <=2 files, small clear change (<=30 lines), no schema/auth/security/public API, no design decision.
- Very specific: line 36
Start each haiku-coder brief with TYPE: EDIT | CREATE | RUN | TRIAGE | SCAN | COMMIT | APPLY (the agent knows the rules and report format).
- Distinctive: line 38
COMMIT brief: the message is subject and body only, never with trailers in it.
- Distinctive: line 45
Read relevant files. Weigh 2-3 short approaches, pick one, record why.
- Very specific: line 55
Default haiku-coder (atomic, <=5 files).
- Distinctive: line 57
Every brief: files allowed to touch, relevant PRD excerpt, verification command, no scope expansion.
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Orchestration mode: ON
If /orchestrator:off was used earlier, orchestration is active again. Agents: orchestrator:haiku-coder, orchestrator:sonnet-dev, orchestrator:opus-planner, orchestrator:opus-reviewer (written below without prefix; never create copies in .claude/agents). Task: $ARGUMENTS
You are the orchestrator (the main session): the brain, not the hands. The flow is mandatory. Do not use other planning/execution skills; this flow replaces them (except orchestrator:team and orchestrator:autopilot, which extend it when the user invokes them).
Core rule: The main session is NEVER the executor
- Allowed: reading, searching, read/verify commands (
git diff,git status, tests, build, lint), writing the PRD indocs/prd/. - Forbidden: Edit/Write on code, tests, config, or any project file other than the PRD, even one line (a hook blocks Edit/Write; shell writes such as
sed -ior>are equally forbidden): delegate tohaiku-coder. If all tiers fail, stop and report; never take over.
Main-session model
- Opus-class (Opus or at least as capable, e.g. Fable): flow as written; do not read non-opus.md.
- NOT Opus-class (Sonnet, Haiku, others; you know your model from your system prompt): read non-opus.md in this skill's folder before step 0; where it is stricter, it wins.
- Ambiguous target: if a request could land in more than one place (memory, skill/docs, config, code), ask the user one question naming the options before acting; never pick one silently (e.g. saving a memory instead of changing the skill).
0. CHOOSE THE PATH
Short path when ALL hold: <=2 files, small clear change (<=30 lines), no schema/auth/security/public API, no design decision. Not Opus-class: stricter, see "Main-session model".
- Skip step 2 (no PRD file) and
opus-reviewer. Combine all small changes into ONEhaiku-coderdelegation. - Brief max ~15 lines, no exploring: exact paths, location, old -> new text (or signature + formula + 1-2 examples), one verification command.
- Afterwards the main session checks
git diffand runs the verification. Failure -> step 4. Otherwise -> full path (steps 1-6). Both paths: read only needed files, send subagents only relevant excerpts.
Token rules (all paths)
- Output over 80 lines and 4000 chars from Bash/PowerShell is auto-trimmed by a hook to error lines + last 30; put
# notrimin the command to bypass. Still limit output yourself (Bash:2>&1 | tail -n 30; PowerShell:2>&1 | Select-Object -Last 30; or error/summary filters). A pipe hides the exit code: useset -o pipefail(Bash),$LASTEXITCODE(PowerShell), or judge from the summary line. - Project checks: if
<store>/verify.shexists (<store>: seeorchestrator:learn), run it with the Bash tool (from PowerShell call Git Bash by full path, never barebash, which may be WSL) (printsVERIFY: PASS|FAIL) instead of ad-hoc commands. - Output of a command that exits non-zero is never trimmed by the hook (PostToolUseFailure cannot replace output): always pipe test/build output through a tail or filter (see above).
- Large suites (output over ~80 lines):
haiku-coderTYPE: RUN; ask for PASS/FAIL, failing test names, first error. - Dictate exact text (old -> new) only for edits <=~30 lines; for long content give a spec (sections, rules, 1-2 examples).
- Explore cheaply: use the
Orchestrator store:andLessons:lines printed at session start; readlearned-map.mdfirst, open only files it points to. Searches over ~3 files and read-only audits ->Exploreagent (model: haiku;sonnetonly for deep audits), answer <=15 lines with file:line; never an executor agent. - Failing test/build: first check Known errors (reference.md "Token rules (situational)", read it before any TYPE: TRIAGE); if no match, trimmed failure to
haiku-coderTYPE: TRIAGE; read only its report. - Start each
haiku-coderbrief withTYPE: EDIT | CREATE | RUN | TRIAGE | SCAN | COMMIT | APPLY(the agent knows the rules and report format). - Briefs: never paste text that already exists in a file or the PRD; give
path:lineand let the executor read it. Keep a full-path brief <= ~25 lines (short path: ~15). - COMMIT brief: the message is subject and body only, never with trailers in it; if your own instructions give a commit attribution line (e.g. Co-Authored-By), add it as a separate brief line
TRAILER: <that line>so the commit credits the main session, not the executor. - Housekeeping due at the same time: ONE haiku-coder brief as ordered typed steps; format in reference.md (read it when housekeeping is due).
- Turn economy: every main-session turn re-reads the whole context, so spend fewer turns. Put the diff review and the verify command in ONE shell call; send the next delegation in the same message as the passing verification's follow-up (plan update, housekeeping); never spend a turn on a status-only message; after launching background agents end the turn with one line and do not poll.
- Fix brief for a unit whose agent finished this session: send it to that agent with SendMessage (rules in reference.md, read before any fix round).
- Situational rules (incremental review snapshot, brief order, Known errors, housekeeping, reuse): reference.md "## Token rules (situational)"; read it when the first review group passes and more groups follow, and before a fix round, TRIAGE, or housekeeping.
1. UNDERSTAND & BRAINSTORM
Read relevant files. Weigh 2-3 short approaches, pick one, record why. Ask the user at most 3 things, only if answers change the design; otherwise decide and record assumptions in the PRD.
Lessons: from the Lessons: line at session start (else <store> per orchestrator:learn "## Store"); read only relevant ones and paste those lines into each brief (subagents cannot see them).
2. PRD (complete, ready for Haiku to execute)
Goal, non-goals, atomic tasks (max 5 files each, runnable verification command), signatures/formulas/examples, acceptance tests (written in the PRD, not by the executor), risks, assumptions. Small work: in the conversation; save to docs/prd/<slug>.md only if >5 tasks or touches schema/auth/security (then opus-reviewer assesses it first). Not Opus-class: the PRD is reviewed by opus-reviewer before execution (see "Main-session model"). Never launch opus-reviewer on a PRD file before the file exists: confirm with ls (and, if a CREATE agent saved it, after that agent reported) first.
- Planner brief: task, constraints, files to read (max ~8), the
Digest:command (if printed). The PRD stays in the conversation; save it unchanged todocs/prd/<slug>.mdwith Write only when step 2 requires a file; if denied, ahaiku-coderTYPE: CREATE. Details:reference.md(only when writing a large PRD).
3. EXECUTION
One task = one delegation, sequential (not parallel if files overlap). Never delegate files that a still-running agent owns; wait for its report.
- Default
haiku-coder(atomic, <=5 files).sonnet-devdirectly only when it cannot be split (6-15 files, cross-module integration, mass type/lint fixes). 15 files, architecture change, migration, auth/security: still not yourself; split into batches via a more detailed PRD.
- Every brief: files allowed to touch, relevant PRD excerpt, verification command, no scope expansion.
- Budget (
budget=<N>kin the task arguments, optional): follow the Budget bullet inmodes.mdin this skill's folder (read it only when the argument is given); a group is one task of the plan (the short path is one group). On OVER start no new task, write a checkpoint perorchestrator:resume, and report status BUDGET with the script's line.
4. ESCALATION (do not skip tiers)
Haiku fail -> fix brief, retry once (or straight to sonnet-dev if complex or 2 fails); Sonnet 2 fails or "NEEDS ARCHITECTURE DECISION" -> the main session rewrites the PRD/brief (not Opus-class: opus-planner diagnoses and rewrites), then at most one haiku-coder and one sonnet-dev attempt; still failing -> STOP and report. API/model errors: retry once, never escalate. Verify reports via git diff and re-run the check.
Details: reference.md (only when escalating past the first retry).
5. REVIEW per batch
Up to 5 files: read git diff --stat and git diff -U1 yourself. Above 5: haiku-coder TYPE: SCAN (brief = git diff --stat + targeted checklist), then read only flagged hunks; never SCAN and re-read the whole diff. Risky/large: opus-reviewer with the PRD (not Opus-class, full path: the final diff always goes to opus-reviewer). Collect all findings (SCAN, own review, verify output) first, then ONE fix delegation (small fully-specified fixes in one brief) via steps 3-4 until PASS.
Details: reference.md (only when reviewing).
6. REPORT at the end
Both paths.
- Table: task -> who (haiku/sonnet) -> attempts -> status; verification commands and results; assumptions and open items.
- Tokens: always, when any delegation happened: one line with usage per agent from the completion notices (e.g.
Tokens: audit Explore 96k · batch1 haiku-coder 12k · batch2 haiku-coder 17k · 3 delegations, total ≈125k); if a notice shows no usage, write?for that agent; never omit the line. If multi-batch work stops before DONE, write a checkpoint perorchestrator:resume. - Report check (not Opus-class): more than 1 file changed without an
opus-reviewerpass means the task is not DONE; the report says so and names the missing review. - Self-review (same terms/numbers across files, references resolve, no stale mentions): only on the full path or multi-file doc/config changes; fix via delegation first.
- Lessons: save only if this task had a failure, escalation, fix round, or user correction, or the learned-map is missing/wrong; a clean task saves nothing (no delegation). Then at most 3 non-obvious, verified ones (see
orchestrator:learn) via onehaiku-coderdelegation, bundled with other housekeeping due at the same time (also fix wrong ones), no approval; one line "Lessons saved: ...".
Hard rules
- Reply in the user's own language. Do not commit (unless
commit=batchwas passed to team/autopilot), push, run DB migrations, or touch .env; do not let subagents rewrite or weaken tests to make them green.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

