Big Idea

The argument in one line.

Routing tasks to the right agent based on ambiguity level and using handoff documents as portable context lets you parallelize work that would otherwise bottleneck through a single agent.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You already use Claude Code or Codex daily and notice each agent has blind spots you route around manually.
You work on multi-phase projects where some tasks are well-defined and others still need design exploration.
You want to run agents in parallel work trees rather than waiting for one agent to finish before starting the next.
You have hit context limits or quality ceilings in a single-agent session and want a structured escape hatch.

SKIP IF…

You are new to AI coding agents and have not yet used Claude Code or Codex in a real project.
You work solo on small scripts where a single agent session is sufficient from start to finish.

TL;DR

The full version, fast.

Different AI coding agents excel at different points in development. Claude Code handles ambiguous exploration and architecture planning; Codex handles low-ambiguity execution against a clear plan. The /handoff skill bridges the two by writing a condensed context document a fresh agent can pick up in a new work tree, enabling true parallelization. For larger plans, GitHub Issues serve the same purpose with built-in tracking. When a handoff document feels like overkill, the official Codex plugin for Claude Code lets you call Codex inline for review, rescue, or adversarial deep-dives without leaving the current session.

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 – 01:53

01 · The ambiguity line

Introduces the core mental model: Codex for low-ambiguity execution, Claude for high-ambiguity exploration. Shows the animated slider diagram with examples: implementing a known plan or TDD (Codex) vs. exploring design options or building an architecture wiki (Claude).

01:53 – 03:31

02 · Bridging plan to implementation

Shows how a session starts ambiguous and moves toward a concrete multi-step plan using /grill-me. Real example: rewriting a React app with React Router into a 3-phase plan. Recommends dividing into work trees for parallel Codex execution.

03:31 – 05:04

03 · /handoff skill

Demonstrates using /handoff to extract P0 context into a markdown document. Shows installing Matt Pocock skill via the skills CLI. Pastes the handoff doc into a Warp work tree and starts Codex. Notes the document is model-agnostic.

05:04 – 06:06

04 · GitHub Issues for large plans

For plans too large for a single session (6-10 phases, multi-day), recommends breaking each phase into a GitHub Issue instead of a markdown file. Agents can pull issues, work on them, and post comments back.

06:06 – 07:27

05 · Side-quest handoffs

When a bug or distraction surfaces mid-session, /handoff can spawn a separate work tree to handle it while the main agent keeps going. Shows a real file-overwrite bug handed off to Codex so the main thread stays unblocked.

07:27 – 09:29

06 · Codex plugin for Claude Code

Introduces the official OpenAI plugin adding /codex:adversarial-review and /codex:rescue inside Claude Code. Demonstrates adversarial review catching state management issues in a React front end, and rescue solving a terminal theme problem Claude incorrectly declared impossible.

09:29 – 11:20

07 · Model-switching harnesses

Covers Warp, OpenCode, and Py as model-agnostic options. Key tradeoff: mid-conversation switches carry full context (more tokens, no parallelization) vs. handoff documents which are condensed and forkable.

Atomic Insights

Lines worth screenshotting.

Claude Code is better for ambiguous tasks; Codex is better when scope is clear -- routing the wrong agent to the wrong task wastes time and tokens.
A handoff document is a condensed context file: the next agent reads it and gets a running start without replaying the full conversation history.
Parallelizing work trees requires a handoff document -- staying in one conversation forces sequential execution regardless of which models you use.
GitHub Issues beat markdown handoff files for multi-day plans because they provide tracking and comments without extra tooling.
The /grill-me skill converts a vague idea into a concrete multi-step plan by having the agent ask you challenging questions before any code is written.
Flipping models mid-conversation is convenient but token-expensive -- the full context travels with every model switch.
The Codex plugin for Claude Code adds three inline skills: code review, rescue, and adversarial review for deeper scrutiny.
Codex tends to do deeper codebase research before writing code, which is why it gets things right on the first try for well-defined tasks.
Side-quest issues spotted mid-session deserve their own work tree, not a distraction in the current thread -- /handoff makes this low-friction.
Handoff documents work across model providers; a Claude Code session can hand off to Codex or vice versa using the same file format.

Takeaway

Match the agent to the task, not the habit.

WHAT TO LEARN

Defaulting to one AI agent for every phase of a project is the main reason sessions stall -- the agent you reach for first is rarely optimal for every task in the queue.

Ambiguous tasks (design exploration, architecture planning) and clear-scope tasks (implementing a known plan, TDD) require different cognitive modes -- current AI agents are genuinely better at one than the other.
A handoff document is a condensed context file, not a full conversation replay. Writing one at transition points lets a fresh agent start with the right framing rather than wading through tokens it did not need.
Parallel work trees are only possible when context is portable. Without a handoff document, switching models forces sequential execution regardless of how much work could theoretically run in parallel.
GitHub Issues work better than markdown files for multi-day plans because agents can read, update, and comment on them without a separate tracking system, and the plan stays co-located with the code.
The rescue skill is a useful diagnostic tool: if an agent declares something impossible, routing to a second agent with different search strategies often finds a solution the first missed.
Mid-conversation model switching is a convenience trade, not a power move -- the full context travels with every switch, making it progressively more token-expensive than starting a scoped new session.

Glossary

Terms worth knowing.

/handoff skill: A Claude Code skill by Matt Pocock that compresses the current session into a context document so a new agent in a fresh work tree can pick up the task without replaying the conversation.
Work tree: A separate Git working directory attached to the same repository, letting multiple agents work on different branches simultaneously without interfering.
/grill-me: A Claude Code skill that has the agent ask you probing questions to surface gaps before producing a plan or writing code.
Ambiguity line: A mental model for choosing between Claude Code and Codex: ambiguous exploration tasks favor Claude; clear-scope execution tasks favor Codex.
Codex plugin for Claude Code: An official OpenAI plugin that adds Codex-powered skills (code review, rescue, adversarial review) directly inside a Claude Code session.
/codex:adversarial-review: A skill from the Codex plugin that runs a critical review of the current codebase with more depth than a standard review pass.
Rescue task: A skill mode where Codex steps in to finish something Claude Code got stuck on or incorrectly declared impossible, via deeper web search or file inspection.
Multimodel harness: A terminal or IDE (Warp, OpenCode, Py) that lets you switch the active AI model mid-conversation, passing accumulated context to the new model.

Resources

Things they pointed at.

00:00toolWarp Terminal ↗

03:57tool/handoff skill (Matt Pocock) ↗

01:22tool/grill-with-docs skill (Matt Pocock) ↗

07:27toolCodex plugin for Claude Code ↗

09:29toolOpenCode

09:29toolPy

Quotables

Lines you could clip.

01:45

“Your goal as an engineer is to go from a highly ambiguous idea space to a low ambiguity space.”

Clean standalone principle, no setup needed→ TikTok hook↗ Tweet quote

10:23

“Handoff documents are the absolute best way to take something you are working on and move it to a work tree somewhere else.”

Direct recommendation backed by concrete tradeoff explanation→ IG reel cold open↗ Tweet quote

11:05

“I think handoff documents are the most flexible option, but the Codex plugin is pretty freaking cool.”

Punchy close that validates both options→ 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.

metaphoranalogy

A lot of people are either diehard Claude code or Codex fans, but it's getting more common now to hand off tasks between each of these agents since they're each uniquely strong in certain areas. So I wanted to show you some strategies that I've been using to hand off work between these agents while accomplishing a task to lead to the best outcome.

And also talk about some new tooling like the Codex for Claude code plugin to make it even more seamless. So to start, I wanted to show when you might use Codex or Claude code for certain things. And the way I think about it is the ambiguity line, meaning how ambiguous is the task that we're trying to work on.

For certain tasks, the scope is really clear. Like, if you already have a plan and you want an agent to implement a certain phase of it, or if you're using goal, which is a common skill in Codex or Cloud Code, to work until unit test pass or test driven development, I would put those into a less ambiguous bucket.

And when tasks fall into this, I would say that Codex is going to be the best tool for the job. It tends to do a deeper research on the code base before it starts working, so it tends to get things right on the first try.

And it's also less verbose. It doesn't go off on side quest as much. It takes what it's given and accomplishes the task as described.

Now there's other tasks that don't have clear requirements up front. Like, maybe you're exploring a few different options for the design of an application, or you're turning a code base into an architecture wiki, and you don't really know what the structure's going to be yet.

In those cases, I would call those more ambiguous. And I would reach for a tool like Claude, usually in planning mode or using Matt Pocock's grill with docs skill to collaborate on how something might work, explore an idea space, and then come back with clear engineering requirements.

And your goal as an engineer is to go from a highly ambiguous idea space to a low ambiguity space. So I've tended to start things with Claude, especially when we're planning things out, and finish with Codex with delegation strategies. Now as you're working on a task, it's not going to neatly fall into one of these buckets beginning to end.

Usually, you'll start from a more ambiguous place, planning out your architecture, exploring different options, then slowly walking yourself down to a less ambiguous multistep plan.

A common place to start is going from plan to implementation. I often use the grill me skill, which is a very popular skill that you can go research that just has the agent ask you questions to challenge your thinking. And, for example, if you're doing a high level architecture change, you may work through a number of engineering questions and end the session with a plan of each step that you may want to do.

Ideally, divide it up into work trees so each agent can work on its own. And when I'm doing that kind of progression, I would think to start with Claude to explore the idea space, write it down into a set of actionable steps, and then have Codex come along and pick these up in independent work trees and carry them through to the finish line.

So in this task, we're spreading the full gambit slowly working our way down. And somewhere in the middle, we'll need a strategy to hand off between each of these agents, and there's a number of tools for this. You may use an explicit skill in order to hand it off, and we'll be talking about that one.

You may also use the Codex plug in, which has a series of skills to call into Codex from a ClaudeCode instance, or you may use a multimodel harness to manually switch harnesses in the middle of a task. Let's start with handoff from plan to execution agents.

Here, I had a Cloud Code conversation about a game that I'm building. It's a game that's driven by GitHub issues. If that's confusing, I'll have content on it at some point.

And we found a clear dividing point to create two work trees to get this done a bit faster. The first one would work on all the GitHub infrastructure, and the second one would work on the game's display that would read that in. And each of these felt pretty parallelizable and also low ambiguity.

So both of these seem like good candidates to start some Codex work trees to work on each of those. So to make that happen, I use the handoff skill to take all the information needed for p zero so that the agent has a pseudo plan that it can start working on. And slash handoff is a skill written by Matt Pocock.

It's very easy to install. If you use the skills CLI, you can add Matt Pocock skills and then select handoff along with grill me. Those are the two that I tend to recommend.

And this skill is quite simple. It just tells the agent to write up a document. It includes some suggested skills so that the next agent can get to a running start, but otherwise, it's pretty free to just describe what needs to be done.

And once you have this document, you can easily paste it into a new work tree so that an agent can get going. Shout out to Warp, by the way, for making it easy to spin up work trees. I'll hit add work tree for this directory, and then I can start a codec session and then just paste in the path and tell it get going or add any additional instructions I want.

This is kind of like compaction or forking or things like that, but a lot more flexible. Since this is a file, you can hand it off to an agent that's running a different model, like Claude to Codex, or you can use that to create other artifacts if you want to.

For example, if your plan is a lot larger, maybe it's six to 10 phases, and you know you're not gonna work on it all at once. Maybe you wanna delegate some of it to cloud agents or work on some of it tomorrow. In those cases, you don't really wanna use documents.

You wanna track them on some sort of, you know, task board or Trello or even GitHub issues, since that's where your code's living anyways. So something that I've started doing is handing off to GitHub issues issues rather than markdown documents for very large plans. Here on a project that I'm working on, we had a plan that ended up taking a couple days of review to get through, and each of these were broken out into separate GitHub issues.

So if I wanted to start up an agent, I could say, hey, go pull down this GitHub issue, start working on it, and even post back comments on that GitHub issue if you run into things while you're working. This is really convenient for larger scale projects.

You also might use handoff in the other direction for very, very small offshoots that are kinda distractions for what you're working on right now, but still important enough that you want an agent to work on it. Now you might use things like slash b two w or slash side to do these side quests.

But if it's a big enough side quest, you probably want a separate work tree and commit process to explore whatever that is. For example, while working on a task and I was clicking through the web app, I noticed an issue where creating a file would overwrite other files on the system. So I thought, let's go ahead and track this.

Could be a GitHub issue if you want, or can just use a handoff document if you wanna start an agent right away. So I had Codex go ahead and do that. If you want an example of how literal Codex is, it literally named the file with these x's instead of filling that in with information.

We love you, Codex. So we created that handoff document, and then I was able to create a work tree to work on that a little bit later while this main agent was cooking.

And in this case, I didn't even switch between model providers. I was just using handoff to offload work to someone else. Now handoff documents are a great general purpose tool for handing off between Cloud Code and Codex and vice versa, but there are also times where taking that document, creating a new tab, working on it from beginning to end can be a little bit cumbersome.

It might be more convenient to just have Claude Code directly tap Codex's shoulder and say, hey. Can you look at this? Can you work on this task?

And then get back to whatever you're doing. And for that, there's actually an official plugin from Codex that lets you bring in Codex to your Claude code sessions. It's called the Codex plugin for Claude code, very plain name, and it integrates a few skills into your Claude code setup to tag in codex for certain tasks, like having codex do a code review, having it rescue or step in and finish the implementation of something that Claude code did, and even an adversarial mode to go extra deep.

I've been using this in a couple places where a handoff document would have been a little bit too much, and I also really like it. In this example, I was using ClaudeCode to implement the front end scaffolding for my project because it tends to have a better design sense. And I noticed it also implemented some of the full stack state management of that React front end.

And I thought I could hand off to Codex to finish this out, but it might be easier to just have Codex review the code than have Claude Code work on the notes. So that's what I did. I just called Codex adversarial review to see how spicy it would be.

And sure enough, it was able to come back with some recommendations, and ClaudeCode finished it out. I also had a use case for the rescue task recently because I noticed Clogcode is generally better at just doing tinkering around my computer.

Here, it was just changing, uh, terminal theme for me. And after a bit of research, it told me that something wasn't possible, and I was a little bit suspicious. So I decided to just tag it off to Codex to investigate further.

And sure enough, Codex did a deeper web search and traced through the files, and it was able to find exactly the design tokens to insert, and it worked. I could have used a handoff document here to make it all happen, but finishing it out in a single thread and then going back to Claude code to do more of the tinkering is exactly the flow that I was looking for.

Another option I'll mention in this vein is using a coding harness that lets you switch models in the middle of a conversation. This is common if you're using something like OpenCode, Py, or the Warp Terminal's built in agent because maybe you're working with a certain model, you're not super happy with the results, and you just need to flip over to another model for a period of that conversation.

So kinda like rescue, but model agnostic. In Warp, for example, you could flip a conversation from Codex over to Claude code. In this example, I had Codex implement this state management for React Router, and I may wanna switch to Claude code to work on the design side.

So I might switch over to Claude. Implement the layout structure using outlet components, and then have Opus pick up the task from here. Now there are a few consequences to this approach.

First off, you are staying in the same conversation, so it means you can't really parallelize different tasks.

Handoff documents are the absolute best way to take something you're working on and move it to a work tree somewhere else. Additionally, when you flip models in the middle of a conversation, it will take the full context that you have up until that point and pass the context along. So compared to a handoff document, which is a very condensed view of what you were talking about, this will be more token expensive as well.

But if you're okay with those caveats and your company's subsidizing all of your usage, then flipping models mid conversation is very convenient. With that, I invite you to try out some strategies to see where Cloud Code or Codecs Excel and whatever your workflows are.

And share your learnings in the comments if you have other strategies of working with these. I think handoff documents are the most flexible option, but the Codex plug in is pretty freaking cool.

Like and subscribe for more content about coding agents. I'm gonna be covering a lot more as I keep exploring these CLIs, and I will see you in the next video.

Take

The Hook

The bait, then the rug-pull.

Every developer who uses AI agents long enough hits the same wall: the tool that planned the work is not the best tool to finish it. This breakdown covers the handoff layer -- the skills, documents, and plugins that let Claude Code and Codex pass work to each other without losing context.

Frameworks

Named ideas worth stealing.

00:29model

The Ambiguity Line

Less ambiguous (Codex)
More ambiguous (Claude)

A spectrum for routing tasks to the right agent. Low-ambiguity tasks go to Codex; high-ambiguity exploration goes to Claude. Engineering work moves tasks from right to left on this line.

Steal forDeciding which AI agent to use on any given task

03:57concept

Handoff Document

A markdown file written by /handoff that condenses the current session context and describes what needs to be done. Portable across model providers and usable to spawn parallel work trees.

Steal forAny workflow that needs to pass partial work between agents or sessions without token-expensive context replay

CTA Breakdown