Key Takeaways

  • David Heinemeier Hansson benchmarked frontier models on rewriting a Python animation library into Rust; the autonomous run took under 45 minutes, cut startup time from 86 milliseconds to 2 milliseconds, and sped up execution by 9.6 times.
  • Cost variations between models are extreme: Fable completed the full task for $550, GPT Sol and Grok cost roughly one-tenth of that amount, and DeepSeek delivered at one-twentieth of the price.
  • Mikhail, CTO at Shopify, ran a scientific study demonstrating that pull requests reviewed by autonomous agents caused far fewer production incidents.
  • To prevent blind spots and hallucinations, Hansson verifies autonomous code using DHH's Multi-Agent Cross-Model Review Method.

The DHH's Multi-Agent Cross-Model Review Method

  • Step 1: Primary Planning and Generation: Instruct a primary frontier model (such as Claude Opus or Fable) with high-level outcome goals to autonomously draft a multi-step execution plan and generate code without overspecifying implementation details upfront.
  • Step 2: Cross-Model Peer Review: Pass the completed implementation to an independently architected frontier model (such as OpenAI Codex xHigh or xAI Grok) with the prompt 'review with Codex xHigh' to uncover logic flaws, race conditions, and overcomplicated structures.
  • Step 3: Automated CI Static Analysis: Push the refined branch to GitHub to trigger automated checks via GitHub Copilot and automated test suites running in isolated virtual machines.
  • Step 4: Macro Human Simplicity Filter: Inspect the overall shape, proportionality, and architecture of the change set rather than line-by-line syntax, providing direct feedback like 'make it simpler' if the agent overengineered the solution.

When This Works (and When It Doesn't)

Hansson developed this method for autonomous cycles where single-model blind spots need auditing before production. Every model family carries specific biases. An agent rarely spots its own structural mistakes or circular assumptions. Hansson explains his daily rhythm: “I'll have Opus or Fable do the work, and then I always end it, review with Codex xHigh. And I've also started using Grok just to test it out, and it's also quite good.”

This pipeline falters when applied to tiny bug fixes or greenfield prototypes where unit tests do not exist. If you lack automated CI test suites in Step 3, the cross-model review step can turn into a hallucination feedback loop, where Model B hallucinates a bug and Model A writes unnecessary boilerplate to fix it. Human judgment must step in at Step 4 to trim bloat. As Hansson noticed during his benchmark: “Fable, clearly the best. It was the fastest. It was the one that wrote the plan, but 550 bucks... The others, Sol, Grok, about the same 1/10 the cost. DeepSeek, 1/20 the cost, but you have to wait a little longer.”

What to Do With This

Take an existing slow service or utility script in your codebase this week. Define the target language and performance goals, then feed the specification to a frontier planning model like Opus. Do not micromanage the function signatures. Let the model generate the migration plan and draft the files.

Once the build compiles, take the entire diff and pass it directly to an alternate model family, like Codex xHigh or Grok. Give it a strict prompt: find race conditions, hidden memory leaks, and redundant abstractions. Run the resulting code through your automated CI test suite. Finally, open the pull request yourself. Do not read every variable name; look at the architecture. If the agent added four layers of unnecessary indirection, reject the commit with a single command: make it simpler.