I Used Claude Opus and OpenAI Codex for a Week — The Results Weren't What I Expected
Let me be upfront about something before we get into this. I did not go into this experiment as a neutral observer. I had a bias. I'd been using Claude for a few months, had quietly grown fond of how it writes, and expected that spending a week seriously comparing it against OpenAI Codex would mostly confirm what I already suspected — that Claude was better for my workflow and Codex was the programmer's tool that non-developers didn't need to think about.
I was wrong about almost everything I assumed going in. And the ways I was wrong are more interesting than a simple "X beats Y" conclusion would have been.
Here's what actually happened.
What I Was Actually Testing — and Why It Matters
Quick context on what these two tools actually are, because there's a lot of confusion in how people talk about them.
Claude Opus is Anthropic's most capable model — the version you reach for when you need the heaviest lifting. Long documents, complex reasoning, nuanced writing, tasks where you need the AI to genuinely think through something rather than just pattern-match to a likely answer. It's not the fastest Claude model, but it's the most thorough.
OpenAI Codex is different in nature. It's less of a chatbot and more of an autonomous coding agent — something that can take a task, open files, write code, run it, catch errors, and iterate, largely without you needing to hold its hand through every step. Where Claude sits in a conversation window, Codex operates more like a junior developer you've given access to your codebase.
So comparing them directly is a bit like comparing a surgeon to a physiotherapist. The overlap exists, but they're built for different primary purposes. I tested both across tasks where they compete — writing, analysis, research summarisation, content creation — and tasks where Codex is clearly in its home territory: code generation and debugging.
Day One and Two: Writing Tasks
I started with the thing I do most: writing. Articles, email drafts, content outlines, rewrites of my own rough notes into something readable.
Claude Opus was, genuinely, very good at this. It understood tone without needing it spelled out. When I gave it a rough paragraph and said "make this less stiff," it didn't just swap formal words for casual ones — it restructured sentences, varied the rhythm, and produced something that sounded like a person rather than a document. The output needed less editing than I expected. Sometimes almost none.
Codex surprised me here. I went in assuming writing was not its territory — it's marketed primarily as a coding tool, after all. But when I gave it writing tasks, it handled them with more competence than I expected. The writing was clean, structured, and coherent. What it lacked was texture. The difference between Claude's output and Codex's output on writing tasks was the difference between something that had been considered and something that had been correctly assembled. Both functional. One noticeably more alive.
By day two I had stopped using Codex for writing and wasn't going back. That part of the comparison resolved quickly.
Day Three: The Reasoning Tests
This is where things got more interesting and considerably less clean.
I gave both models the same set of problems — scenarios that required multi-step reasoning, holding conflicting information in mind simultaneously, and arriving at a conclusion that acknowledged nuance rather than forcing a false binary. The kind of thinking that separates a tool that's genuinely reasoning from one that's predicting what a reasonable answer looks like.
Claude Opus performed the way I expected it to. It worked through problems methodically, acknowledged uncertainty when it existed, and — importantly — pushed back on premises it found questionable rather than just accepting the framing of my question. That last behaviour is underrated. An AI that tells you your question contains a flawed assumption is more useful than one that produces a confident answer to the wrong question.
Codex, given the same reasoning tasks through a non-coding interface, was more variable. On structured logical problems it was sharp. On problems that required reading between the lines — understanding implication, detecting when something was missing from the information provided — it was noticeably weaker. It tended to answer the question asked rather than the question behind the question.
But here's where my expectations started to crack. When I gave Codex reasoning tasks embedded in a coding context — debug this, explain why this logic is failing, identify the flaw in this approach — it was exceptional. The reasoning wasn't weaker. It was just contextual. Codex reasons very well about the things it was built to reason about. Strip that context away and the reasoning becomes more surface-level.
That observation kept coming back to me throughout the rest of the week.
Day Four and Five: Actual Code
I'll be transparent: I'm not a developer. I write code occasionally, understand the basics, and can follow logic well enough to know when something is wrong even if I couldn't always tell you exactly why. So my coding tests were not advanced. But they were real tasks I actually needed done.
I needed a script to automate a repetitive file management task. I needed some logic cleaned up in a small web project. I needed an explanation of why something I'd built was behaving unexpectedly.
Claude Opus handled all of these adequately. It produced working code, explained what it was doing, and was patient with my follow-up questions. For someone at my level, it was genuinely helpful.
Codex was in a different category entirely.
The thing that separates Codex from a coding-capable chat model isn't just that it writes better code — though it does. It's that it works the way a developer works. It doesn't just generate a solution and hand it to you. It runs the code, sees what happens, catches the error it didn't anticipate, adjusts, runs it again. The iteration happens autonomously, in the background, without you needing to copy-paste error messages back into the conversation and wait for a new response.
I gave Codex a task that would have taken me a back-and-forth conversation of probably eight to ten exchanges with any chat-based model. It came back with a working result in a single session. The autonomy is the product. That's what you're actually buying with Codex, and experiencing it directly makes it much harder to describe as just another AI coding assistant.
By the end of day five I had completely recalibrated my mental model of what Codex is. It's not trying to beat Claude at writing or reasoning. It's trying to replace the junior developer who sits next to you and handles implementation while you handle direction.
Day Six: The Overlap Zone
I spent day six deliberately pushing both tools into territory where they'd have to compete directly — tasks that were genuinely ambiguous about which tool was the right call.
Technical documentation: writing clear explanations of how something works, aimed at a non-technical reader. Claude was better. The prose was more considered, the analogies were more apt, the explanations landed more naturally for someone without a technical background.
Code review with written feedback: looking at a piece of code and explaining, in plain English, what could be improved and why. Codex was better. The feedback was more specific, more actionable, and showed a deeper understanding of what the code was actually trying to do versus what it was doing.
Strategic thinking about a project: given a set of constraints and goals, what approach makes the most sense? Claude was better, and by a meaningful margin. It held more variables in mind, surfaced tradeoffs I hadn't considered, and was more honest about which recommendations were confident versus which were genuinely uncertain.
Content ideation: generating angles for articles, post ideas, ways to approach a topic differently. Roughly equal, with Claude having a slight edge on originality and Codex occasionally producing ideas that felt slightly templated.
The pattern that emerged across day six was consistent with what I'd seen all week. Claude's advantage is breadth and depth of reasoning across open-ended tasks. Codex's advantage is precision and autonomy within a defined domain.
Day Seven: What I Actually Think
The conclusion I kept resisting all week — because it felt like a cop-out — turned out to be the honest one. These are not competing products in any meaningful sense. Choosing between them is the wrong frame entirely.
If I had to keep only one, I'd keep Claude Opus. My work is primarily writing and thinking, and Claude is better at both. The reasoning is more nuanced, the writing has more texture, and the ability to engage with complex, open-ended problems without needing a structured prompt is something I use constantly.
But that choice would cost me something real. The week showed me that there are tasks — specifically anything involving code that needs to be executed, tested, and iterated — where Codex's autonomous approach saves an amount of time that a chat model simply cannot match. If I wrote code for a living, or even as a significant secondary activity, the calculus would flip.
What genuinely surprised me most wasn't the performance of either tool. It was realising how differently they are designed to be used. Claude is built to be a thinking partner. Codex is built to be an executing agent. Those are different relationships with different interaction patterns, and treating them as interchangeable leads to using both of them worse than you could.
The question isn't which AI is better. The question is what you're actually trying to do — and whether you've thought clearly enough about that to pick the right tool for it.
A week of forcing myself to use both deliberately, back to back, on real tasks, gave me an answer to that question I couldn't have gotten any other way. I'd recommend the experiment to anyone who's been assuming one tool is just better than the other without actually testing the assumption.
You might find out, like I did, that you were comparing the wrong things the whole time.
