Big Idea

The argument in one line.

The best AI coding setup doesn't pick one frontier model, it routes each task by cost and difficulty across a whole model lineup, then has a separate, unrelated model check the first one's work.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You're paying for Claude Code or Codex and want to stop burning premium-model tokens on tasks a cheap model could handle just as well.
You've been unimpressed by Claude Sonnet 5 and want a genuinely cheap alternative instead of assuming you have to switch AI ecosystems entirely.
You run large AI-assisted builds and want a second model checking the first model's plan or code before anything ships.

SKIP IF…

You only use one AI provider and have no interest in ever calling a second one.
You're not comfortable installing a third-party GitHub skill into Claude Code or Codex.

TL;DR

The full version, fast.

The video argues against picking one favorite frontier model. GPT-6 Astra and Claude Fable 5.1 are the two flagships, priced identically at $10 input / $50 output per million tokens, but most coding tasks don't need that firepower. OpenAI's cheaper Terra and Luna tiers beat Claude Sonnet 5 on the DeepSWE benchmark at a fraction of the cost, closing a gap Anthropic-only users have felt since Haiku fell behind. The second argument: never let a model grade its own work, since every model rates its own output generously. Two open-source skills, Claudex Route and Claudex Loop, automate both ideas: Route picks the cheapest model for a task, and Loop runs a plan-build-review cycle where the opposite provider always inspects the work.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 00:38

01 · The Numbers

Opens on the real question: not which model is better, but how to route between GPT-6 Astra, Claude Fable 5.1, and their cheaper siblings depending on the task.

00:38 – 06:43

02 · Why We Should Use Both

Compares flagship pricing against OpenAI's cheaper Terra and Luna tiers on the DeepSWE cost-vs-score benchmark, then argues the model that builds a plan should never be the one that grades it.

06:43 – 10:53

03 · The Skills

Walks the claudex-loop GitHub repo: Claudex Route recommends a model for a one-off task, and Claudex Loop runs a four-stage plan/build cycle where the opposite provider always reviews the work.

10:53 – 12:11

04 · Final Thoughts

Closes with a recommendation to split an AI budget across both OpenAI and Anthropic rather than committing to a single ecosystem.

Atomic Insights

Lines worth screenshotting.

GPT-6 Astra and Claude Fable 5.1 are priced identically at $10 per million input tokens and $50 per million output tokens.
OpenAI's Luna model costs 20 cents per million input tokens and $1.20 per million output tokens, making it near-free next to the flagship models.
On the DeepSWE benchmark at max effort, Claude Sonnet scored 54 versus 70 for Terra and 67 for Luna.
At max effort on DeepSWE, Sonnet averaged $26 per task versus $4 for Terra and 60 cents for Luna.
Even at low effort, Sonnet cost $2.19 per task against Luna's 1 cent and Terra's 34 cents on the same benchmark.
Pushing Luna from low to max effort barely raises its cost while sharply improving its results, a curve Anthropic's models don't show.
A model that drafts a plan will almost always rate its own work favorably, so the reviewer should always be a different, unrelated model.
The Claudex Loop skill has one provider draft a plan, hands it to the opposite provider for review, and cycles the disagreement back and forth until both sides approve.
Claudex Loop caps the back-and-forth with a round budget so the review cycle can't loop forever and burn tokens.
The Claudex Route skill reads a task description plus the frontier labs' own published usage guidance to recommend the cheapest model that can do the job.
Claudex Loop runs recon (deep research via sub-agents) and clarifying questions before either model is allowed to draft a plan.
Both skills work from inside either Claude Code or Codex and can hand work to the other CLI headlessly.
The presenter recommends splitting a roughly $400/month AI budget in half between an OpenAI plan and an Anthropic plan instead of committing to one ecosystem.

Takeaway

Route by cost, verify with a different model

MODEL ECONOMICS

Picking one favorite AI model wastes money on easy tasks and misses that no model can be trusted to grade its own work.

Flagship models like GPT-6 Astra and Claude Fable 5.1 both charge $10 per million input tokens and $50 per million output tokens, so reserve them for genuinely hard, ambiguous work.
Cheaper sibling models can beat a flagship on price-adjusted performance: in this video's benchmark, cents-per-task models scored higher than a pricier mid-tier model while costing a fraction as much.
If a subscription's default model feels underwhelming, check whether a cheaper model from the same or a different provider now beats it on both price and benchmark score before assuming you need to pay more.
A model almost never rates its own plan or code harshly, so any real quality check needs a second model with no stake in the first one's answer.
Splitting review duty across providers, one drafts and the unrelated one inspects, catches blind spots you wouldn't catch yourself, especially once a project outgrows your own technical depth.
A review loop needs a hard stop, like a round budget or an explicit approve/revise/block verdict, or two models arguing with each other will happily burn unlimited tokens.
Before committing an entire budget to one AI provider, it's worth testing the cheapest models from a second provider on real tasks, since the price-to-performance gap between providers isn't constant.

Glossary

Terms worth knowing.

GPT-6 Astra: OpenAI's flagship model as referenced in this video, priced at $10 per million input tokens and $50 per million output tokens.
Claude Fable 5.1: Anthropic's flagship model as referenced in this video, priced the same as GPT-6 Astra.
Terra / Luna: Cheaper OpenAI models positioned in this video as more cost-efficient alternatives to Claude Sonnet 5 for simpler coding tasks.
DeepSWE benchmark: A coding-agent benchmark plotting model score against average cost per task, used here to compare Sonnet, Terra, and Luna.
Claudex Route: A GitHub skill that reads a task description and recommends which model, from cheapest to most capable, fits the job.
Claudex Loop: A GitHub skill that runs a plan-review-build-review cycle, always using a different, unrelated model to inspect what the first model produced.

Resources

Things they pointed at.

06:06productChase AI+ community (Claude Code + Codex Masterclass) ↗

06:06channelChase AI free community ↗

06:43toolclaudex-loop GitHub repo (Claudex Route + Claudex Loop skills)

Quotables

Lines you could clip.

02:25

“This is like what Haiku should be if they hadn't completely abandoned Haiku and just left it in the dumpster months ago.”

blunt, quotable dig that frames the whole cost argument→ TikTok hook↗ Tweet quote

06:06

“Fable's always going to think Fable's work is great. Astra's always going to think Astra's work is great, so on and so forth.”

tight, self-contained punchline about self-grading bias→ IG reel cold open↗ Tweet quote

11:47

“We need to be tool agnostic. And it's really hard to be tool agnostic if you don't play around with all of them.”

closing thesis line, works as a pull-quote→ newsletter pull-quote↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

metaphor

I'm going to teach you how to combine the powers of GPT -6 Astra and Claude Fable 5 .1, because the question you should be asking is not which of these two models is better, it's how can we get the most out of both of them? Furthermore, how can we get the most out of all the models under the open AI and anthropic umbrella?

Because oftentimes, we are working on features and problems that don't even require the power of Astra or require the power of Fable. What about things like Luna and Terra? When do we bring those into the fold when we need cheap models to execute simple tasks, even if we're working inside of something like Cloud Code?

Well, luckily, this is a riddle that is pretty simple to solve, and I'm going to walk you through it in today's video. Now, I will be giving you a set of skills that make this entire process super easy to execute. I have an updated version of CloudX Loop, which includes Astra, and a brand new CloudX Route skill, which makes it really easy to figure out which of these models I should be using.

But before we go into the skills section, let's kind of talk about why we even need this in the first place. Now, at this point, we know there's kind of two big players when it comes to the best frontier model in the game. We have GPT -6 Astra and Cloud Fable 5 .1.

We are coming up with huge tasks. We're planning something from scratch. It's a big project and we want to know who's going to come up with it.

These are the two models we are going to lean on. But another area that doesn't get talked about as much is what do we do? when we have some sort of simpler feature or simpler task that just doesn't require Fable 5 .1, just doesn't require Astra, because these are extremely expensive models.

They both cost the same. We're looking at $10 per input and $50 per output. So if you're someone who's on like API pricing, for example, this can be prohibitive.

On the other end of the spectrum, we have models like CloudSonic 5, as well as Terra and Luna. If you're someone who has used CloudSonic 5, Lately, I think you can agree that this model leaves something to be desired, especially when we compare it to the supposed benchmarks and the performance that we've seen.

Like it just really doesn't feel great. And so if you're someone who has been using primarily anthropic models over the last few months, there is this gap where if I want a model that's going to be cheap and effective, I just can't really find it in the anthropic library. But if we look at OpenAI, they have multiple models that satisfy this requirement when it comes to Terra and Luna.

Now, Terra is slightly more expensive than Sonnet 5 when we talk about token to token, but as I'll show you in a minute, it's cheaper overall because it's more token efficient. And what really is a standout is Luna. This is like what Haiku should be if they hadn't completely abandoned Haiku and just left it in the dumpster months ago.

We're looking at 20 cents. per input and the cash is two cents and output is $1 .20. Like this is basically free compared to everything else.

And like I'm going to show you, this has outputs and this has performance that matches or exceeds Sonnet 5. So this idea of being able to call on open AI models is really, really important if you are someone who's been mostly an anthropic user, especially if you use APIs. And even if you're someone who's on say the 20X plan, with Anthropic and isn't on any plan with OpenAI, well, maybe it makes sense to just have sort of a $20 a month plan specifically to make these sort of Luna calls and save on tokens.

Now to quickly illustrate this idea, we're taking a look at the DeepSuite benchmark. We have Sonnet here in the orange and then Terra and Luna. So straight up in terms of performance, Terra and Luna.

perform better than sonnet at max sonnet is hitting 54 max on terra is 70 max on luna is 67 but what it really what really is the difference though is the cost you know when we look at max at sonnet 26 for average cost per task versus luna 60 cents so and then for terra four dollars Now this becomes a little less pronounced as we go down sort of the effort level.

But even on low, you know, $2 .19 for Sonnet versus $0 .01 for Luna. Granted, it's not doing anything for you. But with Terra, $0 .34.

And so there is this issue with the anthropic models where there is no great bang for your buck model. And Sonnet is just like always at risk of just going nuts in terms of the cost. And then just like...

taking way too many tokens to complete these things. We just don't see that with Terra and Luna. In fact, with Luna in particular, going from low all the way to max barely increases the cost and just like completely spikes in terms of its effectiveness.

So again, real value to be had here and being able to call down these models. Now, the second reason you want to be able to combine the power of open AI and Anthropic is something I've talked about at length in some of my previous videos dealing with CloudX loop. And that is the idea that if I have one model execute, I should have a different model take a look and evaluate its work.

So for example, if I have Claude Fable 5 .1 come up with a plan for some sort of project, then I probably want Astra to come in there with completely blank context without any of the idiosyncrasies that all the anthropic models have. And I want it to take a look at that plan Fable created and say, all right, this is good.

This is bad. Here's what we should fix. And ideally, and this is what the Claudic's loop skill does, it gives that.

feedback back to fable 5 .1 and then fable says agree disagree sets it back to astra astra says agree disagree and you have this continuous cycle this loop of these models going back and forth adversarially till they finally reach a point where like okay this is good to go now there's safeguards in place to make sure that just doesn't go on and on forever and burn all your tokens but even though on the surface that might seem kind of expensive it's going to save you tokens in the long run versus having to iterate after we've already spent a bunch of time building things and this is something we can extend to a lower level right we could have opus build something and have tara take a look or have luna take a look so on and so forth the idea is we never want the model that builds to be the model that evaluates because frankly it's just not going to do a great job and these models in general tend to grade their own work poorly i mean in like in a very favorable light

So Fable's always going to think Fable's work is great. Astra's always going to think Astra's work is great, so on and so forth. So that's why we're doing it.

And now we'll jump into the skill. But first, a quick word from today's sponsor, me. So inside of Chase AI +, I have just released both a Cloud Code and a Codex Masterclass.

So if you're someone who's trying to figure out how to use either of these tools and you don't come from a technical background, this is the perfect place for you. I update this every single week. We focus on real examples.

if this sounds like something you really want to master definitely check us out there it will be a link in the pinned comment hope to see you there so all the skills you need are found in this github repo the claudix loop github repo i will put a link to it in the pinned comment now the two big ones we're going to talk about today is claudix loop which i've done videos on the past on in the new claudex route so let's talk about claudex route first because this is the new one big picture if you run claudex route and you can run this inside of cloud code or inside of codex and you give it a brief description of what you're trying to do, like, hey, I'm trying to do this particular task.

Can you use CloudXRoute to figure out what model I should use? Well, the skill is then going to tell you, here's the model that makes the most sense for you. Maybe it's a very simple task, so it's going to use Luna.

Or maybe it's something that, hey, requires a lot of ambiguous work. It's pretty difficult. Let's use Astra.

So it takes away any sort of thought you need to do in terms of what model to use, because sometimes it's kind of like a gray area. And this is basing it off the actual model information that has been posted for all the models by the Frontier Labs, including some of the usage guidelines. And it takes into account like the actual cost.

And what that looks like in reality is let's say I'm inside of Cloud Code and I do slash CloudX route. And I say, hey, I'm starting this new project. I think it's gonna be pretty complicated.

What model should I use? And it says, go use Astra.

all the relevant information to a headless instance of Codex. So think of it pulling up Codex in the CLI, but it's invisible. Codex is going to do its thing, do all of its work, and then it will send all the information back to Cloud Code saying, here's what I did, here's where that sort of code is.

Now, this also works in the reverse. Like I said, you can start this from Cloud Code or Codex, doesn't really matter. Now, the next skill you need to pay attention to is CloudX loop.

I've done... full videos on Claudic's Loop taking you from the very beginning to the end. So I will link that above if you want to watch that.

For now, I'll kind of just go over some of the changes I've made to it and what it sort of does at a high level. So if Claudic's Route is for like one -off features, like, hey, what model should I use? Go send them to do it.

Claudic's Loop is sort of for really big implementations that walks you through, that kind of holds your hand from planning stage all the way to execution. And it's all about that idea I talked about earlier of, hey, if model A executes, then model b checks its work so first things first if i'm inside a cloud code or inside of codex it's going to use the opposite model to sort of be the inspector so hey if i'm inside a codex right who's going to be doing the plan what's going to be astra who's going to take a look at their plan it's going to be cloud code and vice versa depending on what platform you're on from there it goes through four stages So first things first, it's going to do some reconnaissance, which just means it's going to do deep research.

And let's say you're saying, hey, I want to clone something like Whisperflow. Well, it's going to spawn a bunch of subagents, figure out what Whisperflow actually is, what we need to think about. Has anyone already cloned this?

And like really sort of validate your assumptions. From there, it's going to ask you a few questions. Be like, okay, what do you want to change about it?

What do you care about? What is your vision for this project? Before finally it executes the plan.

Well, it doesn't execute the plan. It builds out the plan. So Astra builds out the plan, sends it to Cloud Code.

They have their back and forth for several rounds until they finally reach an approved verdict. From there, we kind of repeat that process. And it's going to ask you if you want Astra or Fable to actually execute it.

One of them executes the plan. And then the opposite one takes a look at the executed plan and says, hey, here's what you missed. Here's what looks good.

So at the end of the day, the Claudics loop is really just meant to have these opposite models sort of check for blind spots that you're not going to be able to figure out. Because let's be honest, for many of us, what we're building inside of Cloud Code and Codex goes well beyond the scope of our coding abilities.

So are you going to double check what Codex comes up with and Astra comes up with? Are you going to double check what Fable comes up with? Probably not.

But it will give you something of like a warm and fuzzy feeling knowing that Astra looked at fable's work or fable looked at astra's work and that is sort of the whole point of the claudix loop i think it's the easiest way to kind of get the best out of both of these models without some like super convoluted setup so if you want to get this working for yourself just go ahead copy the url here point cloud code edit point codex edit and it will install for you So that's where I'm going to leave you guys.

Remember, if you want to see the Claudix loop actually executed from beginning to end, check out that video I linked earlier. I go into depth showing here's what GPT found, here's all the errors, here's what it looks like when they have their back and forth, and here's sort of what the final setup sort of looks like. But besides that, I think we're in such an awesome place where we have these dueling models.

Like Fable 5 .1 is great. GPT -6 Astra is also great. So I don't really think it should be an either -and thing.

And I think the... sort of pricing of all these can kind of scare you off. Like, should I be on a 20X here and a 20X there?

Should I be paying 400 bucks a month? I don't think so. I think for a lot of people who have kind of been, you know, clawed pilled for the last six, nine, 12 months, you've been probably on a $200 plan.

I would suggest going half and half. Do the 5X with GPT, do the 5X with Anthropic, and really see what you like. You know, maybe you like using them in tandem.

Maybe you love GBT6. I think in general, though, when it comes to all these AI tools and how fast everything is moving, we need to be tool agnostic. And it's really hard to be tool agnostic if you don't play around with all of them.

So that's my suggestion. Definitely check out the skill. Let me know what you think.

Let me know if you have any improvements for it. Always trying to keep it updated. And besides that, I'll see you around.

The Hook

The bait, then the rug-pull.

The pitch here isn't which frontier model wins, it's that treating any one model as your default is leaving money on the table. Chase AI walks through what GPT-6 Astra and Claude Fable 5.1 actually cost against their cheaper siblings, then hands over two skills built to automate the routing and the review.

Frameworks

Named ideas worth stealing.

06:43concept

Claudex Route

A GitHub skill that reads a plain-language task description plus the frontier labs' own published usage guidance and tells you which model, from cheapest (Luna) to most capable (Astra), actually fits the job.

Steal forany AI coding workflow where you're defaulting to the most expensive model out of habit

08:20model

Claudex Loop

Recon
Requirements
Plan review
Build and inspect

A four-stage cycle where one provider drafts a plan or writes code and a different, unrelated provider is required to review it before anything ships; review stops only at an explicit approve/revise/block verdict, with a round budget so it can't loop forever.

Steal forany big AI-assisted build where you don't have the technical background to sanity-check the output yourself

CTA Breakdown