I had a dumb little experiment I wanted to try.
And, as dumb little experiments sometimes do, it got way more interesting than I expected.
I gave three coding agents the exact same task:
- Claude (Opus 5)
- Codex (GPT 5.6 Sol)
- Gemini (Gemini 3.7 Flash)
All set to medium.
The assignment was to build an Arkanoid-style browser game from the same specification.
Nothing particularly groundbreaking. Arkanoid is small enough that an agent can build a complete version in one session, but complicated enough to expose differences in physics, architecture, UI, audio, controls, testing, and general decision-making.
The important part was that they all started with the same instructions.
Then I let them work.
No fixing their mistakes afterward. No "you forgot this feature." No giving one of them another pass because something looked weird.
Whatever they decided was finished was their submission.
But building the games wasn't actually the most interesting part.
Afterward, I gave all three games back to all three agents, anonymized as CL, CO, and GE.
They did not know who created which game. They were just told that they were judging 3 contest submissions by the creators' initials.
And that's where things got, well, fun.
The three games
You can actually play all three versions:
Gemini:
https://arkanoid-gemini.pinkpixel.dev
Codex:
https://arkanoid-codex.pinkpixel.dev
Claude:
https://arkanoid-claude.pinkpixel.dev
All three produced working games, but they approached the assignment very differently.
That difference started showing up before I even looked closely at the code.
First difference: how long they worked
I didn't originally intend runtime to be part of the experiment, so unfortunately I wasn't sitting there with a stopwatch.
These are rough observations, not benchmark numbers.
But the difference was large enough to be impossible to miss.
Gemini: roughly 5 minutes
Codex: roughly 10 minutes
Claude: more than 20 minutes
Gemini absolutely flew through it.
That's not especially shocking since Gemini Flash models are already very fast, but watching it produce an entire playable game that quickly was still impressive.
Codex took about what I expected. It worked through the implementation at a reasonable pace, did its checks, and finished.
Claude was a completely different animal.
It kept going.
And going.
It ran tests. It launched the game. It took screenshots. It inspected those screenshots. It went back through its work. It performed visual checks. It verified behavior.
A significant chunk of Claude's total runtime appeared to be testing and verification rather than implementation.
It also used substantially more tokens than either of the other agents.
At first glance, you could summarize this as:
Gemini shipped.
Codex engineered.
Claude investigated its own work like it was preparing evidence for trial.
But then I looked at what they actually built.
Their different approaches showed up in the code
Claude produced by far the largest implementation.
Its version has 12 stages, a substantial procedural audio system with music, detailed collision handling, accessibility work, responsive behavior, a multi-phase DOH boss, and quite a lot of extra polish.
Codex went in almost the opposite direction.
Its implementation was much smaller and more restrained, but extremely deliberate from an engineering perspective. It built a headless game core, separated game state from rendering and input, included automated tests, and even wrote tooling to verify that source files stayed below the maximum line count from the original specification.
Gemini produced a solid, much faster implementation with a good amount of actual Arkanoid functionality, but less of the obsessive verification and architectural work found in the other two.
Already, I thought this was interesting.
Then I anonymized them.
Time for the agents to judge each other
The judges only knew the entries as:
- CL
- CO
- GE
I asked each agent to inspect the submissions and rank them.
And yes, I specifically did not tell them who made which one.
The results:
| Judge | 1st | 2nd | 3rd |
|---|---|---|---|
| Claude | CL | CO | GE |
| Codex | CO | CL | GE |
| Gemini | CL | GE | CO |
Now for the reveal:
CL was Claude.
CO was Codex.
GE was Gemini.
So Claude unknowingly voted for itself.
Codex unknowingly voted for itself.
Gemini did not.
Gemini voted Claude into first place.
I did not expect that result to be nearly as interesting as it was.
Were Claude and Codex biased toward themselves?
Technically, yes. They each selected their own work.
But I don't think "AI models are narcissists" is a particularly useful conclusion here.
They didn't know which implementation was theirs. They didn't even know that these were made by an AI at all.
Something else may be happening that I find much more interesting.
Each agent seemed to favor software that reflected its own idea of what good software should look like.
Claude's judging put a lot of weight on completeness, depth, collision quality, audio sophistication, accessibility, responsive behavior, and adherence to the full feature set.
Those happen to be areas where Claude spent an enormous amount of effort during implementation.
Codex placed much more emphasis on architecture, automated tests, self-containment, verification, correctness, and engineering discipline.
Those happen to be some of the strongest characteristics of Codex's own submission.
In other words, an agent's implementation choices and judging criteria may be coming from the same underlying preferences.
The model builds software according to its internal conception of "good."
Then, when asked what good software looks like, it selects the implementation that most closely matches those same priorities.
That's a much more interesting possibility than simple self-preference.
And Gemini makes the whole thing even better because it broke the pattern.
Claude actually preferred Codex visually
There's another detail that makes the result harder to dismiss as accidental self-selection.
Before inspecting the code, the agents were asked to evaluate the screenshots.
Claude ranked the visual designs:
- Codex
- Claude
- Gemini
So Claude did not think its own game looked best.
It specifically thought Codex had the stronger visual composition.
Only after inspecting the implementations did Claude move CL into first place overall.
Its reasoning was essentially that Codex had the better visual composition and excellent engineering discipline, but Claude's entry covered more of the original specification and implemented several of the difficult systems more deeply.
Codex reached almost the opposite conclusion.
It also liked CO's visual design, but considered its tests, compact architecture, self-contained implementation, and verification enough to put CO above the larger Claude submission.
That disagreement is probably my favorite part of this entire experiment.
Neither judge simply said, "mine looks better."
They disagreed about what should matter most.
There was still a consensus winner
Using a simple scoring system:
- 1st = 3 points
- 2nd = 2 points
- 3rd = 1 point
The final scores are:
| Entry | Points |
|---|---|
| Claude | 8 |
| Codex | 6 |
| Gemini | 4 |
Claude wins the blind consensus.
It received two first-place votes and one second-place vote.
More importantly, one of its first-place votes came from Gemini.
So Claude's extra time and token usage did appear to buy something.
But that introduces another question.
Was Claude actually the best value?
Claude produced the consensus winner.
It also took more than twice as long as Codex and roughly four times as long as Gemini based on my rough observations.
It consumed the most tokens by a substantial margin.
So which one actually "won"?
If your only metric is the best final artifact, Claude has a strong argument.
If you need a working prototype as quickly as possible, Gemini suddenly looks much more attractive.
And Codex may have landed somewhere in the middle: significantly more engineering rigor than the fastest submission without spending as much time and compute as Claude.
That gives us at least three different definitions of winning:
Best final result
Fastest usable result
Best result relative to agent effort
I hadn't intended to test any of that.
I just wanted to make three AIs build Arkanoid.
What I'm changing for the next experiment
Now I want to do this again.
This first round taught me that I should collect more than just the finished applications.
For future rounds I want to record:
- Exact wall-clock completion time
- Token usage
- Tool calls
- Number of files created
- Approximate lines of code
- Tests written
- Tests executed
- Browser or screenshot checks
- Self-corrections made before completion
- Visual rankings
- Code rankings
- Overall rankings
I'm especially interested in seeing whether the same behavioral patterns repeat across different kinds of applications.
Arkanoid rewards game logic, physics, controls, rendering, and polish.
A developer tool might reward architecture and usability differently.
A UI-heavy project might produce another completely different result.
And a deliberately vague product prompt could test how much product judgment each model exercises when I don't tell it exactly what to build.
If Claude repeatedly spends four times as long and wins, that's useful information.
If Gemini repeatedly gets surprisingly close in a quarter of the time, that's useful too.
If Codex repeatedly lands between them with strong engineering and reasonable efficiency, that's equally interesting.
And if none of those patterns survive another round?
That's interesting too.
This is definitely not a scientific benchmark
Three agents building one Arkanoid game is obviously not enough evidence to make sweeping claims about any model.
Different harnesses, tool access, context, model updates, sampling, and plain old randomness all matter.
I'm not trying to create the new definitive coding benchmark from my browser.
This was mostly for fun.
But I think there's something useful about looking at coding agents this way.
Most comparisons focus entirely on whether a model can solve a task.
Agents add another dimension.
How does the model choose to work when you leave it alone?
Does it ship immediately?
Does it test?
Does it inspect its own UI?
Does it keep polishing after the application already works?
What does it consider important enough to spend tokens on?
And, maybe most interestingly:
When it looks at someone else's work, what does it believe "better" actually means?
I started this experiment wanting to see which AI could build the best Arkanoid game.
I ended up considerably more interested in what the three agents revealed about how they think software should be built.
Not bad for a random Saturday afternoon experiment.
Top comments (0)