13:12Mark Kashef · Tutorial
Claude Code and Codex Got an Upgrade Nobody Announced
The same update that let Claude Code and Codex turn a screen recording into a skill quietly taught both of them to watch raw video, no plugin required.
August 8thThe argument in one line.
Running Claude Opus 5.5 and GPT-6 Astra together, rather than picking one, works because each model has an opposite bias: Claude plans optimistically and builds well, while Codex reviews harder and handles logins and long unsupervised jobs Claude refuses to touch.
Read if. Skip if.
READ IF YOU ARE…
- Someone running both Claude Code and Codex/GPT-6 Astra day to day and wondering how to actually combine them instead of picking one as a daily driver.
- A solo builder who wants a second AI to catch blind spots in a plan before writing any code.
- Someone who wants a repeatable way to hand a project from one AI assistant to another without losing context.
SKIP IF…
- You only use one AI coding assistant and have no plan to add a second.
- You're looking for a beginner intro to what Claude Code or Codex even are — this assumes you already use both.
The full version, fast.
The video argues that using Claude Opus 5.5 and GPT-6 Astra together beats picking one, because a model reviewing its own plan in the same session just confirms it looks great, while a second model exposes real gaps. It walks through six ways to combine them: making the two argue over a plan, offloading image generation to Codex to avoid extra API costs, splitting a build 70/30 between execution and review, handing Codex anything that needs a login or credential Claude refuses to touch, giving either model a bounded /goal with a hard finish line, and writing a handoff file so either assistant can resume a project cold. It ends with a routing cheat sheet for which model to default to per task.
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 →Where the time goes.
00:00 – 00:32
01 · Cold open
States the thesis: use both models together instead of picking one, and previews the six levels.
00:32 – 01:14
02 · The six levels
Lists the six ways to combine Claude and Codex, from easiest to most nuanced.
01:14 – 03:30
03 · Three ways to connect them
Covers the Codex plugin for Claude Code, using both CLIs from either desktop app, and reviewing each other's pull requests.
03:30 – 04:55
04 · Level 1: Let them argue
Have one model draft a plan and the other push back until both agree, instead of a model grading its own homework.
04:55 – 05:21
05 · Level 2: Generate images
Route infographic and diagram generation through Codex's image ability instead of paying for a separate image API.
05:21 – 06:18
06 · Level 3: Split the work
Split a build roughly 70/30 between one model executing and the other reviewing and finishing.
06:18 – 07:47
07 · Level 4: Supervised computer use
Hand Codex anything that needs a login or credential Claude refuses to touch, using a simple decision tree.
07:47 – 09:12
08 · Level 5: Give it a finish line
Use a bounded /goal command with a hard stop condition so a model doesn't spin indefinitely on a task.
09:12 – 10:34
09 · Level 6: Hand it off
Replace scattered plan.md files with a single handoff command that lets either model resume a project cold.
10:34 – 11:25
10 · My routing cheat sheet
A default rule of thumb for which model to use for planning, building, reviewing, images, logins, and long problems.
11:25 – 12:10
11 · Get the free workflow kit
Points to the free prompt kit, PDF guide, and the creator's community and consulting site.
Lines worth screenshotting.
- Asking a language model to critique the plan it just wrote in the same session gets a rubber stamp, because every model is tuned to sound confident about its own output.
- Show the same plan to a different model, or to the same model in a fresh session, and the review changes completely.
- Claude tends to play the optimist about how smoothly a plan will go, while Codex tends to play the pessimist and pokes holes in it.
- Paying for a $20 Codex plan already covers image generation, so there's no need to pay separately for a Gemini or other model's API just to make diagrams.
- A single feature build can be split roughly 70/30: one model does most of the execution, the other reviews and finishes the last stretch.
- Even with full permission granted, Claude Opus 5.5 still refuses to copy a password or an API key, while Codex will do it without complaint.
- The decision of which model handles a task comes down to one branch: does it need your login, and if so, would you trust an assistant to do it unsupervised.
- A bounded goal command with a hard deadline, like 'stop after two hours and tell me why', keeps a model from spinning through every possible option before reporting back.
- Codex run against the same goal as Claude can take three to five times longer and burn far more tokens, because it tries to check every possible case.
- Saving decisions in a new dated plan.md file every session creates dozens of stale, conflicting files over time instead of one live source of truth.
- A slash command that writes 'where we are, what we decided, next step' into a handoff file lets a second AI assistant pick up a project with zero prior context.
- Three separate integration paths exist between Claude and Codex: an installable plugin, running each tool's CLI from inside the other's desktop app, and opening a pull request one model drafts and the other reviews.
Two AI models cover each other's blind spots better than one model alone.
WHAT TO LEARN
Claude and Codex have opposite biases (optimist planner vs. pessimist reviewer), so routing tasks between them by a few simple rules beats picking a single daily driver.
03Three ways to connect them
- Install OpenAI's Codex plugin for Claude Code from its GitHub repo, then run one setup command, to get slash commands like /codex:review and /codex:rescue inside Claude Code.
- Install both tools' CLIs and each desktop app can call the other directly, so from Claude Desktop you can ask it to run the Codex CLI and send a request to Astra, and vice versa.
- The third path is a pull request: one model builds a change on a branch, the other reviews it, and it merges once approved, which works even without deep Git knowledge.
04Level 1: Let them argue
- Have one model draft plan v1, then send it to the other model for review, and loop until both agree it's solid, instead of using a third-party orchestration skill or hook.
- A model asked to grade its own plan in the same session will almost always say it looks great, because it's tuned to sound confident about its own work.
- Showing the identical plan to a different model, or to the same model in a fresh session, produces genuinely different notes and pushback.
05Level 2: Generate images
- If you're already paying for a Codex plan, route infographic and diagram generation through Codex's image ability instead of paying separately for a Gemini or other image API.
- This offloads one more cost center onto a subscription you already have rather than adding a new billed API integration.
06Level 3: Split the work
- Instead of having one model plan and the same model execute everything, split a build so the primary model does the bulk of execution and the second model reviews and finishes the remainder.
- A simple version of this is: build the feature on a new branch, open a pull request, then have the other model review it before merging.
- A new branch is just an isolated copy of the work that doesn't touch the main project, which is worth explaining if you're not fluent in Git yet.
07Level 4: Supervised computer use
- Claude Opus 5.5 still refuses actions like copying a password or pasting an API key even with full permission granted, while Codex will do it without hesitation.
- The decision rule is one branch: if a step needs your login, decide whether you'd hand that step to an assistant unsupervised or do it yourself; if it doesn't need a login, keep it in Claude.
- This makes Codex the better fit for autonomous tasks like signing into an account or entering a credential while you're away from the keyboard.
08Level 5: Give it a finish line
- A /goal command paired with a hard finish line, like 'stop after two hours and tell me why', keeps a model from spinning indefinitely on the same problem.
- Codex tends to run 3 to 5 times longer and burn far more tokens on the same goal than Claude, because it tries to check every possible case comprehensively.
- Reserve open-ended, exhaustive goals for Codex when you're willing to pay for that thoroughness, and use Claude's tighter default behavior for everything else.
09Level 6: Hand it off
- Replace the habit of writing a new plan.md file every session, which piles up into dozens of stale, conflicting files, with a single handoff command.
- Running a handoff slash command writes one file that states where the project stands, what's been decided, and the next step, marked as the latest version.
- The other model picks up that handoff file with its own prime command, which lets it resume a project cold without needing the full chat history replayed.
10My routing cheat sheet
- Default to Claude for planning and for building and shipping; default to Codex for picking the plan apart, generating images, handling logins, and any long, exhaustive problem.
- Reviewing anything about to ship, whether a document or a production app, is worth running through Codex/Astra for a second pass regardless of which model built it.
Terms worth knowing.
- Codex plugin for Claude Code
- An installable plugin from OpenAI's GitHub repo that adds slash commands like /codex:review directly inside Claude Code, letting it call Codex without a separate CLI step.
- GPT-6 Astra
- The reasoning model behind Codex used throughout this workflow, positioned as the harsher reviewer and 'pessimist' counterpart to Claude's plans.
- Opus 5.5
- Claude's flagship model, used here as the default planner and builder in the two-model workflow.
- /goal
- A Codex command for giving the assistant a bounded task with a defined finish line, so it stops and reports instead of running indefinitely.
- /handoff
- A slash command that writes a file recording where a project stands, what was decided, and the next step, so another AI session can resume it cold.
- /prime
- The companion command an AI session runs to read the latest handoff file and pick up a project without needing the full chat history replayed.
- Pull request
- A proposed set of code changes on a separate branch that another person, or in this workflow another AI model, reviews before it's merged into the main project.
- Branch
- An isolated copy of a project's code where changes can be made and tested without touching the main version until they're approved.
- Computer use
- An AI feature that lets the assistant directly control a mouse, keyboard, or browser to complete a task on screen, such as signing into an account.
- Reasoning effort (medium)
- A setting that controls how much computation a model spends thinking through a task before responding, trading speed against thoroughness.
Things they pointed at.
Lines you could clip.
00:00
“Opus 5.5 and GPT-6 Astra are the two best models that you can use right now. But if you only use one, then you're leaving a lot on the table.”
04:15
“Claude is definitely an optimist and many times Codex is the pessimist.”
04:43
“As soon as you show that exact plan in a virgin session to a different language model, or in the same session to a different language model, you'll find completely different results.”
09:17
“You basically have Claude on the left-hand side, passing notes of what's completed and what are the next steps to Codex and vice versa.”
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
Opus 5 .5 and GPT -6 Astra are the two best models that you can use right now. But if you only use one, then you're . Because when you use them together, they complement each other.
Opus is great at planning and Astra is fantastic at finding what's wrong with that planning. But planning alone is just scratching the surface. So in this video, I'm going to walk you through the six different ways that you can use them together.
From the easiest and most straightforward, to the more nuanced ones that will take your setup to the next level. I can guarantee you that if you watch this till the end, you will find a nugget that you haven't seen on YouTube before. Let's jump in.
So instead of constantly switching your workspace from one LM to the next, the best solution is to have both. And you don't necessarily need a max plan for both depending on what you're trying to accomplish and what it involves. The six levels we're going to quickly go through is showing how we can make Claude and Codex argue and plan without the need for special skills or hooks.
Then I'm going to show you how you can avoid paying extra API costs to things like Gemini or OpenAI by combining Codex's image ability with Claude. Then instead of planning, I'm going to show you when it comes to execution, how you can use them interchangeably again with no plugins or skills whatsoever. And by the end, you'll know exactly which language model excels at what kind of task and exactly where to employ them.
Now to get the most out of this video, you're going to first need to connect them. The first way you can hook it up is by installing the Codex plugin that you can grab from their official GitHub page. And this has worked beautifully since April of this year.
All you'd have to do is send a prompt like this, that has the link to the GitHub repo, and then Claude should be able to download it, install the plugin and have it available for you for your next conversation. Once it's installed, you'll be able to use any one of these skills, whether it's reviewing Claude's code or going through a very specific.
set of features or additions to make sure that those were well designed. But even though this is quick and easy, it's not the most comprehensive and it's not the most straightforward. If you go to option number two, then all you have to do is literally install the CLIs of both tools.
And now both desktop apps are sophisticated enough to know exactly how to call the other CLI within the desktop app itself. Let me show you an example.
All right. So I'm in the cloud desktop app, and I'm just going to say something like this. I don't want you to use any plugins or any skills.
I just want you to use the codec CLI. And I want you to send a message to Astra on medium reasoning and ask it to basically give you a full analysis on all the different opportunities in cybersecurity when it comes to AI. And once we send it over, it'll be smart enough to send that exact request and forward it to the headless version.
of Codex. You can see right here when you see the words Codex exec, this is Codex execution without us having to use any form of intermediary to do so. And a few minutes later we get this Astra AI cyber .md file and it breaks down the entire response.
And we can do the exact same thing in Codex where we paste the exact request and all we're doing is swapping Codex CLI for Claude CLI and swapping Astra for Opus 5 .5 on Medium. And just like that, it's smart enough to run a terminal command using the CLI to forward that request over. And you can see exactly how this would work back and forth.
And boom, a few minutes later, we get this entire response from Opus. Now the last way you can connect them is by opening a pull request with one that is reviewed by the other. And just in case you don't use GitHub and you don't even know what a pull request is, you can think of it as you having a project and then you asking Opus or Astra to make a change in said project.
It creates a draft of it. This draft is reviewed by the other LLM. And once it's approved, it can be merged into the live application.
All right. So level one is to make them argue, and this is pretty much selecting your daily driver. This could be your codex or your cloud, having it create a V1 of a plan and having the other LLM.
constantly go back and forth until neither of them have anything else to say. So you'd send a prompt like this, where you say, create a task for insert name of project here, then have Codex, let's say GPT six Astra on medium effort, go back and forth until you both agreed solid. So instead of using something like Claudex or a Claudics loop or an additional third party skill or some form of glorified hook, which I used to use, you can literally tell today to go into a loop and it has all the built -in functions and infrastructure to do so.
So realistically it'll look like this, where you say, create the plan and have the other LM go through it. Then let's say Opus is the daily driver. It will create plan V1.
It will send that over to Codex for review. Codex typically is going to be very sassy. It will that Claude has sometimes for how well something will go.
and many times Codex is the pessimist. The core issue this solves is if you ask a language model that created the plan to assess its own plan, especially if it's in the exact same session. all of them are trained and tuned to be very confident.
So it will tell you, yes, this is a great plan. But as soon as you show that exact plan in a virgin session to a different language model or in the same session to a different language model, you'll find completely different results. The level two is generating images.
And this is something that took me many months to come up with a very simple idea to get around this. I've typically always relied on hooking up something like Gemini skills and paying for API costs to use any one of their models that can generate images and offloading all image into there. But if I'm already paying for Codex, even if it's the $20 plan, I can offload the infographic diagram creation to Codex and just bring that asset back to Claude.
Level three is splitting the work. So instead of just planning with both language models and then executing said plan with a single one of them, you could decide that 70 % of the execution could be with Claude and the last 30 % could be with Codex. So it could work like this where Opus goes and works on a brand new feature.
And in that prompt, you've already asked that daily driver to go to the other language model once it's done and either using the plugin or the CLI check what has been completed, review it, execute any changes, iterate until it's done and then merge it once it's good to go. So depending on the path you choose, you could say something like this, build a new feature on a new branch.
If you don't know what a new branch is, it's basically a separate isolated portion of your work that doesn't touch your main project. If you don't want to get too technical and use GitHub, then you can avoid this and say, build a new feature and then have Codex review it.
But if you wanna get more particular and you wanna use the plugin specifically, then this will give it exactly what it needs to execute. Level four is handling things like logins and anything that needs computer use. Because although Opus 5 .5 has been a dream to use to date, its computer use still lags greatly behind anything that Codex can do.
And on top of that, even though Claude can take care of the majority of your to -do list, as soon as it comes to something as simple as copying and pasting a credential or using an API key, even if you give it full permission to do so, it will refuse. Whereas something like Codex is . So assuming you're responsible enough to know where it's safe for it to be able to click log in on your behalf, to copy a credential, and do things autonomously if you're not at your desk, then combining both will remove a lot of the headaches and the friction that you get with dealing with cloud.
So of the four steps here, the first three could be purely code -based, and the last one could be one where you know it needs to manipulate a computer, your browser, or some account of some sort. So instead of having to go back and forth with Claude, you tell Codex nine times out of 10, assuming it's not sensitive or cybersecurity dangerous, it will take care of it.
If you want a quick mental model when you're planning out all the tasks in the entire project and all the phases, if there's no login whatsoever needed or you have everything hooked up like your connectors, your CLIs, your MCPs, then Claude is more than fine. If you know you want to hand it to an assistant and you want something like Astra to take care of it or Sol or Luna or what have you, then you can adjust that to send it to Codex.
Otherwise, you just do it yourself. Take care of those micro activities, especially if you're at your computer and then have Claw take it all the way. Level five, I called it grind it out.
And this is where you want to give a slash goal to either one of these language models. One has an advantage over the other over its ability to not keep spinning unless you purposely want it to keep spinning for a particular reason. The whole point of goal is you give a very spec'd out plan.
And typically Codex will take sometimes 18, 20, 30 hours to finish that goal because it tries to be comprehensive, but sometimes it's comprehensive to a fault. where it spins on the same situations multiple times, especially if you're using something like computer use, where it could click through every single nook and cranny of an interface and a webpage and spend your entire token budget in the process.
So Cloud 5 .5 won't be as aggressive and comprehensive when it comes to a goal. But if you give that exact same goal to Codex, then you should expect three to five times longer response times and way more token consumption. But if you're okay with spending more because you know that that particular goal has to check every single possible combination or option in your particular task, then Codex would be the right solution for that problem.
Now one way you can avoid the conflict with Codex, especially if you're using both Claude and Codex interchangeably, is you could say slash goal, get the checkout tests passing, so some form of rubric here, and then you give it a finish line, and you tell it, after two hours, if you're stuck, stop and tell me why, or you could say, stop and tell Claude why, and see what Claude can do about it.
Now last but not least, we have level six, which is the handed off workflow, where you basically have Claude on the left -hand side, passing notes of what's completed and what are the next steps to codex and vice versa. Now, just a few months ago, I would go back and forth with something like Claude and create a plan dot markdown file, basically a glorified text file with a series of instructions and phases as to what I'm trying to accomplish and how I'm trying to do so.
But the con of doing this is that over time you accumulate tens, if not hundreds of planned on MD files that have different dates, have different scopes and become out of date and expired very quickly. So my solution is simple and very straightforward. As soon as I'm done a session, I'll run slash handoff.
And this creates a Markdown file that says where we are, what we've decided and what the next step of the process is. And then it will write a small note saying this version of handoff is the absolute latest, but this becomes really handy because not only can we pick it up in Codex by doing slash prime and it will look for the latest handoff file.
But if I want to be able to go back in time through all of my decisions of a project. instead of bloating my chat saying, go and look through the entire chat history we've had on this computer, it can go and look at the summary of all the decisions we've made, all the changes we've made over time without bloating its context.
And like I said, if you want to be able to mix and match and add some local models or some cloud hosted open source models, you can use this workflow with this as well. To end things off, I'll give you my guide as to when to use Cloud versus Codex, depending on the situation. When it comes to planning, I'll almost always use Cloud.
When it comes to picking apart that plan, I'll use Codex. When it comes to creating images just to save on cost, I'll use Codex. When it comes to building and shipping, it's Opus.
When it comes to reviewing anything that is about to be shipped or added or created, whether that's a docx file or a production application, I will typically go through multiple rounds of either Astra or Sol. When it comes to computer use, Codex right now blasts Opus out of the park. And when it comes to long hairy problems where you're okay with spending tokens, and you know you want the job to be as comprehensive as possible, Codex would be a good pick here as well.
And that's pretty much it. So hopefully this gives you a cheat sheet as to where each one of these language models shine and the bigger picture that using them together will get you a lot farther. If you want this entire guide synthesized step -by -step in a way you can follow or implement or feed your AI, I'll make that available to you.
And I'll also give you my prime and handoff skills so you can take them add them to your workspace and have an elegant solution to hand off to any language model of choice. If you want to grab those resources, you can find it in the second link down below completely for free.
And as always, if you want to stay 10 steps ahead in everything, Claude. Codex AI, learning how to become an AI consultant and sell to enterprises, then make sure to check the first thing down below for my early AI adopters community. What you see here is typically scratching the surface of the level of depth that we get to and how to use these for agentic workflows in your day to day.
If you found this helpful, I'd super appreciate a like on the video and a comment for extra reach, and I'll see you in the next one.
The Hook
The bait, then the rug-pull.
Two AI coding assistants, run separately, waste half of what each one is good at. The fix isn't picking a favorite: it's making Claude and Codex argue, split work, and hand a project back and forth like two engineers on the same team.
Named ideas worth stealing.
00:32list
Six Levels of Combining Claude and Codex
- Let them argue
- Generate images
- Split the work
- Supervised computer use
- Give it a finish line
- Hand it off
A ranked progression from the simplest way to combine two AI coding assistants (having them critique each other's plan) to the most involved (a persistent handoff file that lets either model resume a project cold).
Steal forAny workflow doc for running two AI tools together instead of picking one
07:31model
Login Decision Tree
- Does this step need your login?
- No -> keep it in Claude
- Yes -> would you hand it to an assistant?
- Yes -> Astra does it while you watch
- No -> do it yourself
A three-question flowchart for deciding whether a task belongs to Claude, to an autonomous Codex/Astra session, or to the human, based purely on whether login or credentials are involved.
Steal forAny checklist for delegating computer-use tasks to an AI safely
How they asked for the click.
VERBAL ASK
11:25link
“If you want to grab those resources, you can find it in the second link down below completely for free.”
Verbal CTA pointing to the free 16-page PDF + prompt kit on GitHub, plus a plug for his Skool community and consulting site, delivered in the final chapter.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
