Cole Medin, 14 minutes (with a sponsor spot for Scrimba Explain). The premise is the practical consequence of harness engineering and software factories: once agents write most of the code, model quality stops being the binding constraint — tokens per week does.

The trigger

  • He hit the rate limit on his $200/month Claude Max plan and his $200/month Codex Pro plan in the same week, both days away from reset, without a big jump in workload
  • Opus 5.5 helps, but not nearly enough; the limits have been tightening all year
  • So “just be more token-efficient” stops working as a strategy. The lever is which model does which step

The routing rule

  • Planning and review get the most capable model. Implementation gets a cheap one.
  • The plan is the highest-leverage step: with a well-written plan, the implementer doesn’t have to be that capable — planning with Fable 5.1 and implementing with a small model lands essentially where Fable-for-everything does
  • Implementation is the token-heavy part of the workflow, so that’s where the savings come from
  • Exceptions: genuinely novel or unexplored work can justify a large model end to end; small, bounded tasks with a human in the loop can run open models for everything

Same game, built three ways

A storm-chasing multiplayer game on Neptune, built three times from the same PRD through his AI Software Factory:

  • Open models only (DeepSeek V4.1 Flash planning/review, GLM 5.3 Flash implementing): barely a proof of concept — bad visuals, sluggish movement, not even a good starting point
  • Claude Fable 5.1 only: clearly better — navigation works, movement is choppy, a solid proof of concept limited by how many tokens he was willing to spend
  • GPT-6 Astra planning/review + GLM 5.3 Flash implementing: about 4x cheaper and, in his judgement, the best of the three — smoother movement with an open model writing every line
  • He says the same pattern held across every other app he built that week

The workflow shape

Everything runs as an Archon workflow and the shape never changes:

  1. Input is a GitHub issue describing what to build
  2. Plan node — the most capable model (GPT-6 Astra in his favorite setup)
  3. Implement node — the cheap model, reached through an AI gateway
  4. Review node — the capable model again
  5. Findings route back to the cheap model to fix, with a max-retry loop
  6. Tests/build must be green before the merge at the end

Tools involved: Archon (his open-source harness builder), Pi as the coding-agent harness, Neon’s AI Gateway for at-cost access to open models like GLM 5.3 Flash and Kimi K3, and Omnigent as another mixed-provider harness. The zero-tooling version is just having each agent emit a handoff markdown document for the next one.

The model picks behind it

  • LiveBench top of each stable: DeepSeek V4.1 Flash among open models, Claude Fable 5.1 with max effort, GPT-6 Astra with max effort
  • His current favorite combination: GPT-6 Astra for planning and review, GLM 5.3 Flash for fast, cheap implementation

“You don’t always have to have the best large language model for every step of your process.” — Cole Medin

Disclosure: the video’s mid-roll is a paid spot for Scrimba Explain (generates a narrated video lesson from a pull request, plugged into Codex and Claude Code).