I tested GPT-5.3 Codex and Claude Opus 4.6 shortly after release to see what actually happens once you stop prompting and start expecting results. Benchmarks are easy to read. Real execution is harder to fake.

Both models were given the same prompts and left alone to work. The difference showed up fast.

Codex doesn’t hesitate. It commits early, makes reasonable calls on its own, and keeps moving until something usable exists. You don’t feel like you’re co-writing every step. You kick it off, check back, and review what came out. That’s convenient, but it also means you sometimes get decisions you didn’t explicitly ask for.

Opus behaves almost the opposite way. It slows things down, checks its own reasoning, and tries to keep everything internally tidy. That extra caution shows up in the output. Things line up better, explanations make more sense, and fewer surprises appear at the end. The tradeoff is time.

A few things stood out pretty clearly:

• Codex optimizes for momentum, not elegance

• Opus optimizes for coherence, not speed

• Codex assumes you’ll iterate anyway

• Opus assumes you care about getting it right the first time

The interaction style changes because of that. Codex feels closer to delegating work. Opus feels closer to collaborating on it.

Neither model felt “smarter” than the other. They just burn time in different places. Codex burns it after delivery. Opus burns it before.

If you care about moving fast and fixing things later, Codex fits that mindset. If you care about clean reasoning and fewer corrections, Opus makes more sense.

I wrote a longer breakdown here with screenshots and timing details in the full post for anyone who wants the deeper context.

That's really just my personal opinion, but I wonder how you guys see it... my month-long workflow was to use Opus for planning and implementation, Codex for review. Codex simply felt like (as another redditor wrote) "Beep beep, here's your code" - and it was slow. yesterday I got close to my weekly limits, so I kept Opus for planning but switched to Codex (in Codex CLI, not opencode) for implementation (2nd codex + Copilot + Coderabbit for review). And it actually feels faster - even faster when compared with Opus + parallel subagents. And the quality (and that's really just a feeling based on the review findings - but of course we can't compare different plans and implementations etc.) seems to be at least as good as with Opus' implementation.

What's your take on that?

i have the $200 Max plan. I've enjoyed it for a couple months now. However, when it comes to big plans and final code reviews I was using 5.2 Codex. It has better high level reasoning.

Now that Opus 4.6 is out, i have to say i can tell it's a better model than 4.5 it catches more things and seems to have a better grasp on things. Even Codex finds fewer issues with 4.6 implementation. HOWEVER...

Now that 5.3 Codex is out AND OpenAI fixed the number one thing that kept me from using it more often (it was slooooooow) by speeding it up 40% it has me seriously wondering if I should hang onto my max plan.

I still think Claude Code is the better environment. They definitely jump on workflow improvements quickly and seem to develop faster. However, I think I trust the code more from 5.2 Codex and now 5.3 Codex. If codex improves more, gets better multi-tasking and parallelization features, keeps increasing the speed. Then that $200 OpenAI plan is starting to look like the better option.

I do quant finance work. A lot of modeling, basically all backend logic. I'm not making websites or GUI's so take it with a grain of salt. I feel like most ppl are making websites and apps when I'm in forums. Cheers!

been spending a lot of time with Codex lately since GPT 5.4 dropped and they've been pretty generous with credits. coding speed is genuinely better, especially for straightforward feature work.

but here's what keeps bugging me. every time Codex finishes a task, the explanation of what it did reads like release notes written for senior engineers. I end up reading it three times to figure out what actually changed. Opus just tells you. one paragraph and I'm caught up.

I think people only benchmark how fast the model codes. nobody really measures how long you spend afterwards going "ok but what did you actually do." if you're not from a deep dev background that part is half the job. the time Codex saves me on execution I lose on comprehension.

ended up settling on Claude Code as the orchestrator and Codex as the worker. Codex does the heavy coding, Opus translates what happened. works way better than using either one solo.

anyone else running a similar combo? curious whether people care about the "explanation quality" thing or if it's just me.

There's a wide consensus on reddit (or at least it appears to me that way) that Claude is superior. I'm trying to piece together why this is so.

Let's compare the latest models that were each released within minutes of each other - Codex 5.3 xhigh vs Opus 4.6. I have a plus plan on both - the 20 usd/mo one - so I regularly use both and compare them against each other.

In my observation, i've noticed that:

• While claude is faster, it runs into usage limits MUCH quicker.

• Performance overall is comparable. Codex 5.3 xhigh just runs until it's satisfied it's done the job correctly.

• For very long usage episodes, the drawback of xhigh is that the earlier context will wind up pruned. I haven't experimented much with using high instead of xhigh for these occasions.

• Both models are great at one-shotting tasks. However Codex 5.3 xhigh seems to have a minor edge in doing it in a way that aligns with my app's best practices because of its tendency to explore as much as it thinks it needs. I use the same claude.md/agents.md file for both. Opus 4.6 seems more interesting in finishing the task asap, and while it does a great job generally, occasionally I need to tell it something along the lines of "please tweak your implementation to make it follow the structure of this other similar implementation from another service".

I'm working on a fairly complex app (both backend + frontend), and in my experience the faster speed of Claude, while nice, isn't anywhere close to enough by itself to make it superior to Codex. Overall, the performance is what has the highest weightage, and it's not clear to me that Claude edges ahead here.

Interested to hear from others who've compared both. I'm not sure if there's something I could be doing differently to better use either Claude or Codex.

There's a wide consensus on reddit (or at least it appears to me that way) that Claude is superior. I'm trying to piece together why this is so.

Let's compare the latest models that were each released within minutes of each other - Codex 5.3 xhigh vs Opus 4.6. I have a plus plan on both - the 20 usd/mo one - so I regularly use both and compare them against each other.

In my observation, i've noticed that:

• While claude is faster, it runs into usage limits MUCH quicker.

• Performance overall is comparable. Codex 5.3 xhigh just runs until it's satisfied it's done the job correctly.

• For very long usage episodes, the drawback of xhigh is that the earlier context will wind up pruned. I haven't experimented much with using high instead of xhigh for these occasions.

• Both models are great at one-shotting tasks. However Codex 5.3 xhigh seems to have a minor edge in doing it in a way that aligns with my app's best practices because of its tendency to explore as much as it thinks it needs. I use the same claude.md/agents.md file for both. Opus 4.6 seems more interested in finishing the task asap, and while it does a great job generally, occasionally I need to tell it something along the lines of "please tweak your implementation to make it follow the structure of this other similar implementation from another service".

I'm working on a fairly complex app (both backend + frontend), and in my experience the faster speed of Claude, while nice, isn't anywhere close to enough by itself to make it superior to Codex. Overall, the performance is what has the highest weightage, and it's not clear to me that Claude edges ahead here.

Interested to hear from others who've compared both. I'm not sure if there's something I could be doing differently to better use either Claude or Codex.

At least in my testing for last 2 days. I’ve been solely on cc max for about 6mo. codex was always slow and not impressive. but now what is impressive is that it is fast but requires less back and forth to solve issues. Anybody else find this to be true. If yes then what are the use cases for opus 4.6 then? i’m a simple person. my stack is react, ts, convex.

Asked both Opus 4.6 and CODEX 5.3 to analyze my open source library which I'm writing

First 2 pics Claude

Last pic - CODEX 5.3

https://github.com/RtlZeroMemory/Zireael

Claude did analysis and overall praised my project

The only concern which Claude mentioned is enormous scope for alpha, meaning its too big and will be hard to manage (i am linking only C part of library here, TypeScript is not released yet, its a framework built on top of C, so its big)

Overall Claude's project analysis was correct AND not hallucinated like 4.5 did (4.5 could not handle it fully and made stuff up)

Now CODEX

CODEX analyzed library and while analyzing it also ran tests i did not ask for and said "I need to also run tests because assessment must not be only based on code reading"

CODEX also praised my library, but found several critical bugs / issues with ABI (application binary interface) and threading which i need to fix.

CODEX response was much shorter, CLAUDE much bigger

Overall both models did well but CODEX was more attention paying

Will test implementations now