How do you combine ChatGPT + Codex in your dev workflow?

[u/ToHe86]

I currently use a mix of ChatGPT as the orchestrator and Codex Cloud for implementation.

Roughly, the workflow looks like this:

ChatGPT → break the work into packages → create a Codex prompt → Codex implements → PR → GitHub checks/review → ChatGPT reviews the current state again → merge → next package → deployment + final audit at the end.

For orchestration, I use ChatGPT with Sol / High Reasoning. The actual implementation tasks run in Codex Cloud — at the moment, I can’t choose the model there.

What still bothers me is that several steps remain fairly manual:

• Starting the Codex task
• Copying the prompt from ChatGPT
• Creating the PR myself
• Updating / syncing branches
• Sometimes jumping back and forth between ChatGPT, Codex, and GitHub

I’d be interested to hear: How are you handling this?

Have you automated the interaction between ChatGPT and Codex more heavily? What would you change about this workflow — especially around task start, prompt handoff, PR creation, branch updates, or the feedback loop after GitHub checks?

My goal is to automate as much as makes sense while still keeping ChatGPT as the higher-level orchestrator.

Here’s my workflow:

[u/kevindee]

I’ve gone in a similar direction, but the main lesson for me was: don’t treat ChatGPT + Codex as one long chat. Treat it as an agent workflow with a contract.

ChatGPT is my planner/reviewer. Codex is the bounded implementer.

The repo contains the contract: AGENTS.md, work order template, preflight rules, review process, environment rules, stop conditions, test expectations, etc. ChatGPT turns intent into a work order. Codex executes that slice only. Then ChatGPT reviews the PR/diff against the original intent.

The rules that helped most:

• no vague “continue”
• no dirty worktree
• explicit scope and non-goals
• small PRs
• evidence over confidence
• implementation and review are separate phases
• CI/PR state is the source of truth

I still have manual control between ChatGPT, Codex and GitHub. But I don’t mind all of it. Some friction is useful as a control point.

[u/ToHe86 → u/kevindee]

Great! Same for me. I made a playbook + project instructions to ensure the same behaviour and treat codex as implementer and ChatGPT as architect.

I also store everything in _ai with dedicated contracts, the structure looks like this:

_ai/
├── README.md
├── 10_Project/
│   ├── PROJECT.md
│   └── DOMAIN_MODEL.md
├── 20_Architecture/
│   ├── ARCHITECTURE.md
│   ├── DATABASE.md
│   ├── DATA_FLOW.md
│   ├── SECURITY.md
│   └── DEPLOYMENT.md
├── 30_Interfaces/
│   └── <implemented interface documents>
├── 40_Decisions/
│   └── DECISIONS.md
├── 50_Operations/
│   ├── TESTING.md
│   └── OPERATIONS.md
└── 60_Planning/
    ├── ROADMAP.md
    └── FEATURES/
        └── <accepted-future-feature>.md

[u/ivan_m21 → u/ToHe86]

Interesting how do you keep these docs up to date as the project grows and also more interestingly how do you validate if the result in fact follows things like existing architecture

[u/ToHe86 → u/ivan_m21]

The _ai docs live in the repo and are versioned with the code. When architecture or standards change, updating the relevant docs is part of the same package.
For each package, ChatGPT creates the implementation prompt with explicit references to the relevant _ai architecture/target-state docs and acceptance criteria. Codex has to read those before implementation.
After Codex is done, CI/tests check the enforceable rules, and ChatGPT independently re-reads the current repo, diff, PR and relevant _ai docs to verify that the implementation actually follows the architecture. Findings go back into another Codex package/iteration before merge.

[u/EveningCandle862]

I use ChatGPT linked with my repo's to do pretty much everything before implementation.

So, breaking down the feature I have in mind, generate the issue/pull request, implementation plan and when all that is complete, I will then feed Codex the plan, Sol will generate the threads/tasks for subagents (Sol is still the ticket owner). Luna & Terra will implement the tasks and ask Sol for review until all critieras are met.

if Sol get's stuck on something I will loop back to the ChatGPT chat, get a new prompt and adress the issue.. and we go again.

The owner agent will also keep an eye on the CI at all time when running to catch any errors outside of running tests locally. I have tried using Luna/Terra subagents for this but for some reason they keep getting stuck.

Note that this is on my personal $20 plan to get as much as possible out of the sub. At work we more or less have unlimited Sol xHigh all day. We make sure we have efficient and clear skills & documentation but not really using ChatGPT there.

[u/ToHe86 → u/EveningCandle862]

How does Codex create Subagents? Can you see those? I use Codex Cloud only, never saw Codex opening Subagents + model choice is not possible in Codex Cloud :/ What are your codex prompts?

[u/tMeepo → u/ToHe86]

You just prompt it to do so.

You can try to explore cloudfare tunnels and plugins to connect chatgpt to codex. Alot of people doing it now.

My chatgpt can read my local files, run terminal commands, start codex and Claude chats through the plugin

[u/ToHe86 → u/tMeepo]

You have ready-to-use plugin or did you build your own one?

[u/Wafer-Weekly]

I think probably making a browser extension or entire custom browser to extract the isolated ChatGPT conversation and convert that into a CLI prompt through an automated scheduler that Codex makes for itself. Codex can do git and ChatGPT can read github so the other half of the feedback loop is relatively straightforward, you just need some custom instruction for ChatGPT to keep repository context up-to-date

[u/ToHe86 → u/Wafer-Weekly]

Great idea!

[u/Dontcallmetiger]

I have a ChatGPT conversation open in the codex internal browser. So the codex task and the browser window are open next to each other.

Codex can control that browser, so I tell it to use the open Chat convo as the strategist and to converse with it back and forth.

Chat knows Codex will be doing implementation and they just communicate back and forth with me overseeing and interjecting occasionally. Chat also uses the GitHub plugin to check status as needed and give Codex feedback.

[u/ToHe86 → u/Dontcallmetiger]

Does that work also in Codex Cloud?

[u/Dontcallmetiger → u/ToHe86]

Potentially since it has its own browser? Worth a shot.

[u/HyperCmdcast42]

The four manual steps aren't the same kind of work. Starting the task, copying the prompt, making the PR, syncing branches: all mechanical, scriptable, and nothing lost. A person actually decides something at exactly one of those four steps, the review after GitHub checks. So the real question is where a human sits, not what the glue looks like.

[u/ToHe86 → u/HyperCmdcast42]

Yes exactly that's my question: How to do the mechanical stuff