Claude Code Orchestrates, Codex and OpenCode Build

I cancelled the big Claude plan. Now a small one runs the orchestrator and cheaper backends do the building. The work did not get worse. The bill got smaller.

Why one big plan is the wrong shape

An agent session is two jobs, not one.

The orchestrator frames the problem, splits it, reads diffs with suspicion, and decides what ships. Few tokens, all taste. Put your best model there and leave it there.

The builders read a scope list, make a red test green, and hand back a diff. Many tokens, almost no taste. The test already carries the spec.

Paying premium rates for the second job is the mistake.

My mix: a small Claude plan, a Codex plan on ChatGPT, and OpenCode Go at ten dollars a month. Those are my choices, not a recommendation. Prices move, so check Claude pricing, ChatGPT pricing, and OpenCode pricing before you copy me.

The setup prompt

Paste this into Claude Code in any project. It asks what you have, installs the orchestrate skill set, then writes a dispatch-router skill with the routing table in it.

Set up my Claude Code session as an orchestrator that delegates building to cheaper backends.

Work in this order and stop where I say stop.

STEP 1. Ask me, and wait for my answer, before you change anything:
  a. Do I have the Codex CLI installed and signed in? Run `codex --version` to check.
  b. Do I have the OpenCode CLI installed and signed in? Run `opencode --version` to check.
  c. Which OpenCode model should be the cheap build lane? Default to glm-5.3.
Report what the two version commands actually printed. Do not guess. If a CLI is
missing, tell me the install command and stop.

STEP 2. Install the orchestrate skill set.
  1. Clone https://github.com/cgraves09/claude-orchestrate-skill.git into a temporary
     directory.
  2. Run its ./install.sh. It copies skills/*/SKILL.md into ~/.claude/skills/<name>/ and
     agents/*.md into ~/.claude/agents/. It skips any file that already exists there. Do
     not pass --force unless I say so.
  3. Show me the output and list what was installed and what was skipped.
  4. Delete the temporary clone.

STEP 3. Write a new skill at ~/.claude/skills/dispatch-router/SKILL.md. Do not overwrite
an existing file there: if it exists, show me a diff and ask. The body must contain this
routing table verbatim, as a markdown table, plus one paragraph on when to load it.

  | Work | Backend |
  | Mechanical: renames, index regeneration, formatting | OpenCode glm-5.3-flash |
  | Research and code reading | Claude Sonnet subagent |
  | Scoped build, red test exists, small blast radius | OpenCode glm-5.3, or Codex gpt-5.6-terra when quota allows |
  | Hard build: editors, concurrency, crypto, shared contracts, unclear scope | Claude Opus 4.8 subagent |
  | Validation of every unit, whatever built it | Claude Opus 4.8 validator |
  | Prod-touching: migrations, secrets, deploys, payments | Never dispatched. Gate on the human. |

The skill must also state these rules:
  - The orchestrator never builds. It frames, decomposes, writes tests first, dispatches,
    verifies, and merges.
  - Every dispatch names its model explicitly. An omitted model is a bug.
  - A returned report is a claim. The orchestrator runs the tests itself before it counts.
  - A unit that fails twice gets re-decomposed into smaller units. It never gets escalated
    to a bigger model.
  - External lanes run in their own git worktree, never on a main-line branch.

STEP 4. Show me the finished SKILL.md and tell me to start a new session so the skills load.

Do not change anything else in ~/.claude. Do not install anything I did not confirm in
STEP 1. If git or the network is unavailable, stop and tell me instead of working around it.

Free, ungated, no email required. Copy it as many times as you like.

Set it up

1. Install the Codex CLI. Run npm i -g @openai/codex, then codex and sign in with your ChatGPT account. Check the vendor docs for the current command first.
2. Install the OpenCode CLI. Run npm i -g opencode-ai, then opencode auth login and pick your plan. Check the vendor docs for the current command first.
3. Pick the cheap build model. I use glm-5.3 for scoped builds and glm-5.3-flash for mechanical work.
4. Run the setup prompt above. It installs the skill set and writes the dispatch-router skill.
5. Add the lane pack template. Copy the block below into your repo so the orchestrator fills it in instead of inventing a brief each time.
6. Run the daily loop. Read NEXT.md, run /orchestrate <task>, let lanes run in worktrees, verify each result yourself, merge it yourself, run /compact, repeat.

npm i -g @openai/codex
npm i -g opencode-ai
codex --version
opencode --version

The lane pack

An external model is not in your session. It has none of your context and none of your habits, so the brief carries everything.

# Lane: <ticket id> <one-line title>

## Context
<what this repo is, what this file does, which convention to follow>

## Acceptance criteria
- <criterion 1, observable>
- <criterion 2, observable>

## Failing tests and the exact test command
Tests already written and currently red: <paths>
Run exactly this, nothing else: <command>

## Output contract
End your reply with `git diff --stat` and the verbatim test output.

## Self-check
Re-read your full diff. Remove any hunk that does not serve this task.
Walk each acceptance criterion and state met or not met with evidence.
Run the test command one final time after your last edit.

## Rules for this repo
- Work only in this worktree.
- Never switch, create, or delete a branch. Never push. Never open a PR.
- Never edit a file outside the scope list above.
- End with `git diff --stat` and verbatim test output.
- STOP and ask if anything is ambiguous. A wrong guess costs more than a question.

A dispatch.sh wrapper enforces what a prompt cannot. It refuses to run on a main-line branch, runs the tests itself after the backend returns, and writes a result.json with status (ok, backend_failed, timeout, tests_failed), diff_stat, files_changed, and test_exit. The orchestrator reads the file, not the model's summary of it.

The routing table

Version zero. Move a row when your own runs tell you to.

Why I compact so often

A small plan lasts all day only if the orchestrator context stays small. I run /compact after every merged wave and every time a lane returns. That is safe because the state lives in two places compaction cannot touch: git, and a NEXT.md ledger capped at 150 lines. A fact that only exists in the scrollback is one /compact from gone.

# NEXT.md

## Now
- <the one thing in flight, with its branch name>

## Next
1. <next unit, with its acceptance criteria in one line>
2. <the one after that>

## Blocked
- <thing> waiting on <person or decision>

## Done this wave
- <ticket>: <what shipped> on <commit sha>

## Landmines
- <the thing that will bite the next session>

Calibration: what I actually measured

On 2026-09-08 I took three closed tickets, checked out the commit before each fix, applied the red test from the real fix, handed the lane the same lane pack a live ticket gets, and scored the diff with an Opus 4.8 validator. Small sample. Here is all of it.

• OpenCode glm-5.3: promoted. Three of three green, zero P1 findings. Now my default scoped-build lane.
• kimi-k2.7-code: on hold. One P1. It hardcoded an English string instead of calling the repo's localization helper. The code worked. The judgement was wrong.
• gpt-5.6-luna: on hold. Zero P1 findings, two P2 findings, fastest lane in the set.
• Codex gpt-5.6-terra: not scored on 2026-09-08, usage limit. The ChatGPT account ran out mid-run, so all three terra lanes came back with a quota error and nothing to score. I am leaving that in the record.
• Codex gpt-5.6-sol and gpt-5.6-terra: promoted on 2026-09-09. I re-ran both on a lane pack that names the localization rule and the no em dash rule. Both came back green with zero P1 findings, so sol and terra are calibrated for the scoped-build class now. Sol is my first Codex choice. Terra is the faster second, and I check its output for em dashes because it typed one after being told not to.
• Codex gpt-6-astra: in calibration. Two first-try greens on hard-build units in the notes editor, zero scope defects, honest partial reports every round. The validator pass is still owed, so it is not promoted.
• gpt-5.6-luna on both backends: on hold. Fast, and still holding a P1 on the Codex side.

The surprise: scope discipline was never the problem. Across nine lane runs the cheap models stayed inside the scope list nine times out of nine. Every failure was domain judgement. That is what the validator is for, and why the validator never gets cheaper.

You can run this protocol in an afternoon. Three tickets is not science, but it beats a guess.

I wrote the whole setup up as a free course, module by module, with the field notes I keep adding: The Orchestrator Course.

Where the files live

The orchestrate skill set is public: github.com/cgraves09/claude-orchestrate-skill. It ships orchestrate, context-and-state, delegate-prompts, familiarize, orchestrator-delegation, tdd-protocol, validation-and-evidence, and workflow-patterns, plus the implementer, researcher, and validator agents. Clone it and run ./install.sh, or use the install prompt on the orchestrate skill page.

dispatch-router, dispatch.sh, calibrate.sh, and the lane report schema are not in that repo yet. They land in the repo next. Until then, the setup prompt above writes the skill for you, and the course carries the config files in full.

FAQ