Claude Code vs OpenAI Codex: Real AI Coding Tool Comparison

discussions comparing Claude code with OpenAI's  Codex are getting heated with people even accusing   each other of being bots. In this video, I wanted  to give my own try at comparing Claude code with   Codex and letting you in on the secret that  all the six figure actual senior engineers  

know about when it comes to AI coding and chasing  all these latest shiniest tools. And by the end of   this video, you'll know just as much as me when it  comes to chasing the hype. So, how do we compare   and contrast clawed code with OpenAI's codecs?  Well, for that I'm using this demo application  

here that allows you to create an auction in both  Python and Java. And I use this application a lot   to showcase the difference between these two  languages and how it's like to do AI coding   together with them. So, what I can basically  do here is create a new auction. And then once  

I've done so, you can actually see that I can  create bids on this Raspberry Pi cluster kit. So,   let's go ahead and actually bid 230 bucks  here with Python P. And you can see indeed   that I'm now the highest bidder. There was also  a buyout price. So in theory, if I bid 260 bucks,  

I should immediately be able to get this Raspberry  Pi cluster kit. If I bid 260 bucks, then you do   see that actually I am the highest bidder, but the  auction isn't closed. And in fact, Python Pete is   able to just bid a ridiculous amount of money  and still be the highest bidder. So something's  

going wrong here, right? Actually the thing is  in my code in both the Python version as well as   the Java version I introduced a bug on purpose.  Basically what I'm doing here is I am assigning   the closed status to an unused variable instead of  actually changing the status of the auction object  

itself. So when I commit the latest version of the  auction object, the status is not actually set to   closed. And I'm introducing this exact same bug in  both Python as well as Java. You can see it here   as well where status is actually a variable that's  never read or really used in a repository at all.  

Now, the reason why I introduced this bug on  purpose in these two different languages is just   to showcase whether claude code and Codex can pick  up on this exact same bug across two different   languages without me explicitly instructing it to  find it. So, what we're going to be doing here is  

we're actually going to be using OpenAI Codex  here on the right. And then here on the left,   I'm actually going to go ahead and start a  clawed code session. Now I want to make sure   that this is a fair game. So I actually have not  connected either claude code or Codex to my IDE.  

So they don't know that the bug is in these files  specifically. No need to worry about that. And   when it comes to the models that we'll be using,  if you check out /model here, you can see that I'm   just selecting opus for every operation. And on  the codec side, let's actually go for GPT5 high.  

Effectively choosing the best model for both of  these coding tools. So here we go. We can actually   select both of those models. And then I'm going to  paste the exact same prompt into both terminals.   And I'm going to keep my prompt a little bit vague  on purpose to see and challenge these models. So  

I'm going to say the buyout price option does not  seem to work even if I bid that price or higher.   The auction doesn't close. Now, in this specific  prompt, I'm not actually directing the models to   actually fix this for both the Python and the  Java environments. I'm kind of expecting them  

to properly read the repository and actually  figure that out from themselves. So now I've   got the prompt in both of these models and I'm  going to go ahead and just submit them to both   and then we'll see how they are both going to  actually try and solve this problem. Now, while  

these tools get working on the problem, I kind of  wanted to have a discussion with you for a moment   about how it can actually be a bit of a waste of  time to even compare these tools directly because   before I even got started, I already showed you  a couple of variables at play. You might have  

different programming languages for your project.  You might be using different models next to the   AI tools. And then the way that you prompt these  models also really influences their behavior. So,   this is really not a be and end all test. In  fact, there is no way to compare these kinds of  

tools together with each other because everyone's  workflow is so very different. So, in that case,   I've kind of trapped you in this video, right?  Because I'm comparing these two models, but at   the same time, I'm telling you there's not really  a point in doing it. So, then why am I creating  

a video like this when I don't even agree with  the idea of directly testing these tools? Well,   I just want to point out that all these AI tools  are great tools for your toolbox, but in the end,   they rely on your expertise as a developer.  If, for example, you don't know any Java or  

Python at all, then these tools can be great  if they help and solve a bug for you. But what   if they don't? Every AI coding tool is going  to break at one point or another. So, if you   don't actually know any programming yourself,  you're going to get into trouble. This is not  

the message that the vibe coders or YouTuber  are telling you, but as a senior engineer,   I know what it's like to get stuck with these  AI coding tools. And I can tell you that my real   developer experience has helped me out of these  ruts very often. As a senior engineer myself,  

I have seen how often these AI coding tools get  stuck. And then I thank the stars for actually   having the developer expertise to be able to  guide the models into the right direction and   sometimes even just start coding manually. If you  don't have the ability to do that as a developer,  

then you are going to get stuck very quickly. No  matter what all the vibe coders on YouTube and   other platforms are telling you, if you're working  on real applications, then these AI coding tools   are just a way for you to develop faster. they're  not a full replacement for you as an engineer.  

That being said, it is very important to know  how to use all of these tools correctly. And   instead of going with all of the hype and trying  to follow the latest trends, you should really   pick the tool that makes you more productive and  master it first before moving on to the next shiny  

thing. But with that being said, you are here to  see a comparison between Claude Code and Codex,   right? So, let's actually have a look at how  they both approach this problem. And to do that,   let's go ahead and open up these terminals and  extend them a lot more so we can see what's going  

on. And let's go ahead and scroll all the way to  the top to see how both of these models actually   approached it. Now, the nice thing about these  AI native editors is that they are able to first   actually have a look around the repository to  explore the relevant files where something like  

buy price might be present. So you can see here  that they basically both use a bunch of search   methods to find examples of code where buyout is  mentioned and in this case of course something   like Codex was a little bit more extensive in  the types of search terms that it was looking  

for but this is something that you could also  prompt for right if you asked claude code to   first do an extensive search with many keywords  it would pretty much do the same thing as codec   so yes Codex might have a slightly different  behavior because GBD5 might behave differently  

But the prompting that you do matters a lot  here as well. So in any case, they were both   able to find some pretty relevant files because  if we scroll down here, you can actually see how   they both edited logic in in this case the  Python file first and in Claw Code's case,  

the Java file first. And they are both doing a  couple of things. So first of all, they actually   double check if a bid meets or exceeds the buy  now price. Of course, the code looks a little bit   different between Java and Python, but we'll also  be comparing the actual backend implementations in  

a little bit. In any case, from here, Claude Code  should be checking the Python back end, whereas   codec still needs to do the Java implementation.  So, indeed, if I go ahead and scroll down here   in the Codex implementation, we can see  that the Java code is being picked up here,  

as well as the Python business logic here on the  left in Claude Code. and they are both basically   applying the same symbol fixes to both places.  For example, you can see here how the status is   now properly being applied to the auction object.  So you can see here that the end result is pretty  

similar. To further confirm this, if we look  at the git tree here on the left and the right,   we can see that the business logic Python file was  indeed changed by both. Here on the left, cloud   code simply changed the auction status. Codex  added a little comment. And if we scroll down,  

we can of course also see that there is some logic  changes to actually compare whether the current   bid is the equal to or more than the buy now  price. And if we check out the implementation, you   can see it differs a little bit here and there in  terms of the functions that are being used and the  

way that things are being logged, but the actual  implementations are pretty similar. But honestly,   the difference between these two models is just  due to the non-deterministic nature of large   language models. To prove that, I'm going to run  the following experiment. Let's actually go ahead  

and undo the changes that Codex made. And now what  I'm going to do is actually start a new Cloud Code   session inside of the Codex demo folder. And  then I'm actually going to run the exact same   prompt that I ran before. So we're going to do  the exact same prompt here. I'm just going to  

show you that we are still using Opus. And then  what you will see is that the implementation will   differ slightly even though we are using Claude  code. The point I'm trying to make here is that   because of the non-deterministic nature of large  language models, these singular tests are always a  

little bit silly because even if you're using the  exact same tool with the exact same prompt, the   output is going to differ. And I can already start  proving that to you while cloud code is thinking   because if I make this window a bit bigger and  compare it to the output of quad code here on  

the left, you can actually see how different it  already tries to find code related to the buyout.   You can see here that it uses different search  terms. It starts with the same search pattern   here, but then actually it starts to search for  something different. Here it just looks for buyout  

price and buyout price. Whereas here you can see  it's actually using a much different reax. Again,   with the exact same prompt, it's behaving much  differently. It actually placed more emphasis on   the different backends in this case. Whereas  here on the left, it pretty much immediately  

just started to change the Java code. Now, if we  go here to the right, you can actually see that   it starts with checking the Python business logic.  You can see here how the non-deterministic nature   of these language models makes them behave super  differently every time you test them with the  

same prompt and that is what makes these tests  so silly. Let's go ahead and accept all these   changes and then eventually we will see in our git  tree that the final implementation looks pretty   different. Now that we have the changes on the  left and the right side here we can actually see  

that the Java implementation happens to be pretty  similar to be fair. I mean the comment slightly   different but the actual code implementation is  the exact same. But I actually had a look at the   Python code and something is really off here. If  we check out the business logic Python file here  

compared to the one here on the right, there is  one big striking difference. There is an addition   made here at the end of the file where it properly  checks if the bid meets or exceeds the buy now   price. But here's a really big issue. If we scroll  up again, you can actually see that claude code  

this time did not pick up on the fact that this  status variable is never accessed and it actually   didn't change it such that the auction status is  properly changed. So we still have a bug remaining   in our code and that is not anything against claw  code in particular. I could have run that exact  

same sample with Codex. The point here is actually  just to show how random large language models   really are and that comparing these two tools with  each other doesn't really make a lot of sense from   that perspective. Even if large language models  were deterministic, the honest truth is that  

these tools are very competitive with each other  in terms of feature sets, they're both going to   be chasing each other, especially when tools like  codecs are open- sourced. Now, the point of this   video is that I wanted to show to you that if  you want to become a real AI native engineer,  

then you should choose one AI code tool and  promise to yourself that you're going to master it   instead of chasing all the hype and changing your  tool set every 3 weeks. It's much better to master   one tool because in the end, these AI tools are  just meant to help you as a developer get the most  

out of your productivity. As a senior engineer,  what I'm going to do instead is just sit back,   wait a couple of months, and then re-evaluate  my workflow instead of just jumping on codec   CLI because it's the newest, shiniest tool.  With that being said, if you disagree with me,  

leave a comment down below. But if you agree  with me, you should definitely check out my   AI native engineering community in the link in  the description below, where we help you get the   most out of AI coding tools to accelerate yourself  as a developer and get you ahead in your career.