Two coding agents, two different jobs. Getting them to hand off cleanly is the whole trick.
I use Claude Code as the orchestrator — it plans, reads the codebase, runs verification, handles git and deploys. I use Codex for the heavy generative lifting — design implementation and content generation across many apps at once. This blog you're reading was built that way: Claude wrote the design brief, Codex implemented it.
The division of labor
The split follows what each tool is good at under my setup:
- Claude — brainstorm → write a spec → decompose into tasks → verify → deploy. It holds the plan and the "did this actually work" gate.
- Codex — take a spec and produce files in bulk (a design system, dozens of content JSONs, per-app redesigns), running non-interactively:
codex exec -C <dir> -s workspace-write --skip-git-repo-check "$(cat PROMPT.txt)"I run Codex batches in the background (nohup) and let Claude pick up the results.
The handoff is a manifest, not a vibe
The failure mode with multi-agent work is drift: agent A thinks it produced X, agent B assumes Y. I kill that with an explicit "app name → commit hash" manifest. Codex does the per-app work and records exactly what it changed; Claude reads the manifest and batch-deploys from it. No "I think it's done" — there's a hash.
Placeholder — real capture pending. The manifest is the contract between the two agents.
The one-shot redesign
The biggest run so far: a single spec covering a full redesign (design system, shared components, per-app pages), handed to Codex, which worked through it section by section. Claude then batch-deployed ~30+ apps from the resulting manifest — deploying six at a time, in the background, because a naïve serial loop times out.
The one non-negotiable: a regression-verification gate before deploy. On the last app in the batch I had Claude re-verify against the requirements before shipping, rather than trusting the batch wholesale.
The pattern for content: SPEC → pilot → parallel
For bulk content I don't let Codex free-run. The pattern:
- Write a
SPEC.mdwith the schema, quality bar, and one example skeleton. - Codex generates one pilot batch. I verify it.
- Only then, parallel batches — with a strict schema parse (zod) as the build gate, so a malformed file fails the build instead of shipping.
The honest part: agents are only as good as your gates
The productivity is real — I've generated and shipped more than one person reasonably could by hand. But every disaster I've had came from skipping a gate: trusting a batch without re-verifying, or handing off without a manifest and letting drift creep in. The leverage isn't "the agent is smart." It's that a spec, a manifest, and a verification step make a fast agent safe to run at volume.
If you're pairing two agents, spend your effort on the seams — the spec you hand over and the check you run when it comes back. That's where the wins and the wrecks both live.