Codex First

---
name: codex-first
description: "Route implementation work-orders to GPT-5.6 lanes via Codex; Claude specs, orchestrates, reviews, verifies. Use when a task is a frozen-spec build, mechanical migration, test fill, bulk sweep, or CI fix — anything that reads as a work order rather than a design problem."
---

# Codex First

Claude Code sessions only. Rationale: GPT-5.6 lanes run flat-rate on the ChatGPT plan and
top the coding index; Fable's edge is judgment, specs, orchestration, review. Codex types,
Claude thinks and verifies. (Adapted from steipete/agent-scripts for James's rig.)

## Route

**Delegate to Codex** (default for hands-on volume):
- implementation from a frozen spec; refactors; mechanical migrations/sweeps
- bug fixes with a known repro; test writing; coverage fills
- CI fixes, dependency bumps, scripts/tooling
- bulk exploration where raw reading ≫ the answer

**Keep in Claude (never delegate):**
- design, architecture, naming, product judgment — tasks where writing the spec IS the work
- tiny edits (<~20 lines, single obvious change) — delegation overhead loses
- anything needing session tools: MCP, browser, PostHog, memory
- **prod operations, always**: prod DB (psql), Railway env/deploys, Stripe, DNS, customer
  emails, anything reading `.env`/secrets. Codex never touches prod credentials or runs
  with them in reach.
- destructive/irreversible ops, releases, pushes, merges — Claude-side per repo protocol
- review of Codex output — never delegated, never skipped

Heuristic: prompt reads as a work order → delegate; writing it forces decisions → design,
keep it. Mixed task: Claude designs, freezes spec, delegates build-out.

## Model/effort routing (updated Aug 26 — James's strategic-loop topology)

- IMPLEMENTATION lanes: `gpt-5.6-terra`, effort **ultra** — big, BOLD, atomic
  work orders (whole migrations, whole screens, whole adapters). Clear frozen
  spec in, commits out. Claude reviews at the seams, not over the shoulder.
- REVIEWER / THINKING PARTNER: `gpt-5.6-sol`, effort high→max→ultra —
  adversarial passes, certification reads, design attacks, strategy
  pressure-tests. Sol is no longer escalation-only; it is the standing
  second brain in loops (build: terra → attack: sol → synthesize: Claude).
- Routine/cheap orders: `gpt-5.6-luna`, effort high. When the 5.6 weekly limit is out, `gpt-5.3-codex-spark` runs on a SEPARATE quota — use it for routine/mechanical lanes only; judgment and class-1 review stay on Claude seats.
- Opus 5 subagents (via Claude's Agent tool): completeness reads, design
  rulings, funnel/product craft — the divergent-thinking seat in loops.
- NAMED SEATS (Sep 1, `~/.claude/agents/`, load at session start): `designer`
  (Opus xhigh, gating design verdict), `completeness-reader` (Opus xhigh,
  scope/journey/doc-truth + overengineering strip list, before any merge or
  "live" claim), `explorer` (Sonnet low, read-only sweeps — file dumps never
  enter Fable's context), `verifier` (Sonnet xhigh, browser/MCP/walkthrough
  films with evidence, never verdicts). Fable keeps: WO authoring, prod ops,
  merges, final gate. Hands-on reading in the Fable seat is the priciest seat
  doing the cheapest work — delegate it. Skip Haiku (200K, a generation back).
- Escalate effort on failure; choose SEAT by role (terra builds, sol
  attacks, opus designs, Claude gates + synthesizes + ships).
- Every lane must COMMIT its work (atomic commits per tripwire/feature);
  Claude verifies commits exist + runs the repo's own proof set before any
  merge (for TS repos typically: lint, typecheck, unit tests, build, plus
  any disposable-infra verifier the repo carries).

## Invoke

Prompt via temp file in the scratchpad, never inline quoting:

```bash
P=$(mktemp "$SCRATCHPAD/codex-XXXXXX"); cat >"$P" <<'EOF'
<goal · repo + key paths · constraints ("don't touch X") · non-goals ·
 proof expected (exact test command) · output shape ("report files changed + test output")>
EOF
codex exec --yolo -C <repo> \
  -c model="gpt-5.6-terra" -c model_reasoning_effort="ultra" \
  -o "$SCRATCHPAD/codex-last.md" - <"$P" 2>/dev/null
```

- run long jobs with Bash `run_in_background`; read the `-o` file on completion
- `--yolo` only when the working dir is a repo without prod secrets in reach; otherwise
  default sandbox and review the command requests
- follow-ups: `codex exec resume --last` from the repo dir (cheaper, keeps context)
- parallel independent orders OK: separate worktrees/dirs, separate `-o` files
- PRUNE worktrees after each lane lands: `rm -rf /private/tmp/<repo>-*` + `git worktree prune`
  (Jul 30 incident: 219 accumulated worktrees filled the disk to 0 bytes mid-review)
- alternatively spawn the `codex:codex-rescue` subagent (plugin) for shared-runtime jobs

## Prompt contract

Codex starts with ZERO session context. Every prompt: goal, exact repo/paths, constraints,
non-goals, proof expected, output shape. Spec quality decides success.

## Verify (Claude, always)

- `git status -sb` + read the FULL diff; judge like a hostile contributor-PR review
- run the focused tests yourself or demand proof output; Codex claims are advisory
- iterate via resume; after 2 failed rounds, take over and do it directly
- ship through normal repo protocol (commit/create-pr skills, CI watch) — Claude's hands
  on the merge button, never Codex's
- substantive results feed [[adversarial-review]] before merge