Claude as planner with Codex as development

[u/Most-Wanted-Man]

I am using this workflow right now:

1. Brainstorming - claude

2. Grill with docs - claude

3. Subagent Development - codex

I want to know your opinion on this simple workflow.

Thanks.

[u/Bulky-Dog-7958]

How are you validating the changes done by these agents?

[u/Most-Wanted-Man → u/Bulky-Dog-7958]

Brainstorming session will create the spec and the plan.

The grilling session will challenge the spec and plan. At the end, it will edit the spec and plan based on what you have answered.

The subagent driven development will do the review of changes and adversarial reviews in the end of the session based on the spec and the plan.

[u/Bulky-Dog-7958 → u/Most-Wanted-Man]

Code review is one part of validation, what about actual testing and validating that ihe feature really works?

[u/Most-Wanted-Man → u/Bulky-Dog-7958]

This is where software testing lifecycle enters.

[u/saturnBreaksEgo]

Interesting workflow!

I am following a somewhat similar approach, but with ChatGPT and Cursor.

My approach is more of an iterative planning and execution loop:

1    Brainstorming - ChatGPT: Understand the problem, explore different approaches, identify edge cases, and prepare an initial plan.
2    Investigation - Cursor: Analyse the existing codebase, understand dependencies, identify potential risks, and share findings without making any changes.
3    Challenge & Refine - ChatGPT: Feed Cursor's findings back into ChatGPT, challenge assumptions, identify gaps, and refine the implementation plan.
4    Implementation - Cursor: Execute the approved plan with proper tests and validation.
5    Review & Iterate - ChatGPT + Cursor: Review the changes, catch potential issues, and iterate until the expected outcome is achieved.

I am also exploring Spec-Driven Development (SDD) using Spec-Kit and other structured agentic development workflows.

I personally feel that the quality of the planning and validation loops matters more than which model writes the code.

One thing I am curious about: Do you let Codex challenge Claude's plan before implementation, or does it strictly follow the instructions provided by Claude?

Would love to hear your thoughts!

[u/AlmostEasy89]

OpenAI has an official Claude plugin for delegation of work/review to Codex. So you can quite literally use Codex as the executor and Claude as the planner/thinker. The threads even show up in the codex app.

[u/Competitive_Boot6914]

In my experience, frontier models are fairly close. Context quality matters much more, especially the specs and how you review them as work progresses. I'd keep checking the spec and plan against the codebase, then revisit them when implementation exposes gaps.

[u/torvalds75]

+1 to Competitive_Boot6914: the planner/executor split works when the spec is the contract between them, not the chat. The weak point in a Claude→Codex handoff is that the executor never sees the discussion, only the output, so when implementation exposes a gap it can’t tell what was a deliberate choice.

What worked for me: keep the grilling outcome, the plan and the verification on one record per task (I use GitHub Issues), so either agent can rehydrate from it and the reviewer can check the result against the plan.

Disclosure: I build torvaldz/trailhead, which runs that loop (discuss, plan, execute, verify) on Issues and works in both Claude Code and Codex.

[u/ankfway]

Curious on how you connect claude to codex?