Key Takeaways

  • Faced with a $43,000 annual SaaS quote for speaker management software, the AI Engineer team ran the "Kill My SaaS" contest, drawing 72 submissions averaging 91,000 lines of code.
  • Single-model workflows failed at scale: Claude Code and OpenAI Codex tied in overall adoption, but 40 out of 66 qualifying teams combined both models.
  • Model isolation produces cleaner codebases: Cboard HQ used Claude to plan and review while delegating bulk generation to Codex, cutting execution costs on massive repositories.
  • Green Room HQ instituted off-policy cross-verification, locking Claude and Codex into separate workspaces where neither model could merge code without approval from the other.
  • These architectures establish The Three Multi-Agent Coding Orchestration Patterns.

When an enterprise vendor quoted the AI Engineer team $43,000 per year for speaker management software, swyx and his team opted to build instead. They launched the "Kill My SaaS" competition, challenging engineers to recreate the product using autonomous coding agents. The result was 72 submissions running agents for days on end, producing codebases with a median size of 91,000 lines of code.

The real discovery was how top developers coordinated their tools. Claude Code and OpenAI Codex tied in popularity, but builders quickly abandoned single-agent setups. Forty of the 66 qualifying submissions paired both models together, establishing clear boundaries between planning, execution, and review.

The Three Multi-Agent Coding Orchestration Patterns

Pattern 1: Planner-Worker Hierarchy

A smart model decides what to do and acts as the planner and reviewer, while a cheaper model serves as the code execution worker writing the specified implementation (e.g., Claude plans and reviews while Codex writes code).

Pattern 2: Specialized Builder-Tester Split

One model builds the implementation and a different model tests and verifies it, specifically delegating browser driving or automated testing to whichever model family handles verification best.

Pattern 3: Off-Policy Cross-Verification Teams

No model is permitted to approve its own work. Teams run isolated workstreams (e.g., a Claude agent team and a Codex agent team in separate workspaces) where pull requests cannot merge until the opposing model verifies them to prevent self-evaluation bias.

When This Works (and When It Doesn't)

This method applies when building complex, full-scale software with coding agents to overcome agent context decay, cost limits, and on-policy evaluation blindness where agents are too lenient on their own bugs. When an agent tests its own logic, it brings the same blind spots to verification that it brought to the initial implementation. Cross-model handoffs force strict interface contracts and catch silent edge cases.

It breaks down when latency matters more than code volume. Running two competing models in separate workstreams doubles or triples token consumption. If the two models disagree on code style, typing strictness, or architecture patterns, they can trap each other in continuous review loops. Without a deterministic tiebreaker or a human gatekeeper, an autonomous pull request war can drain API budgets overnight.

What to Do With This

Take your most complex engineering task this week, such as writing a Stripe billing webhook handler or rebuilding an internal admin panel. Do not point a single agent at the entire prompt.

Split the workload across two separate workspaces. Have Claude Code draft the API specification, generate test scenarios, and write the pull request requirements. Export that specification to an isolated branch where OpenAI Codex writes the actual implementation code. Finally, block merge permissions on GitHub until Claude runs the test suite, drives a headless browser across the UI, and signs off on the pull request. If the reviewing model spots an issue, it must bounce the ticket back to the worker workspace rather than patching the file itself.