Claude Code, Codex, and Today's Development Desk

Lately, my development environment has gradually started to settle down.

In the past, I feel like I spent more time tinkering with editors and frameworks. These days, I spend more time adjusting how I work with AI. Times have changed.

My current setup is simple: Claude Code is my main tool, and Codex is my backup.

To be honest, there is a fairly large gap in intelligence between them.

Claude Code can handle design, research, and even breaking down complex problems. Codex, on the other hand, is the type that faithfully does what it is told. Put negatively, it is not very flexible. Put positively, it does not do unnecessary things.

In the past, I might have agonized over which one to use. Now I separate their roles completely.

Claude Code is the engineer.

Codex is the part-time worker.

That is the image I have in mind.

Why I Still Use Codex

The main reason I use Codex is to save tokens, but that is not the only reason.

It is also a form of risk management.

Sometimes I cannot log in to Claude Code, or work stops because of a service-side issue. In those moments, I cannot simply say, “I could not get any work done today.”

That is why I keep using Codex in normal times.

It is like an evacuation drill.

If you wait until a disaster happens to start training, it is already too late.

AI is the same. If I only touch an alternative tool for the first time after my main tool becomes unavailable, I cannot put it into real production work.

Do Not Skimp on High-Performance Models

There is another reason, and it is also a reminder to myself.

In the past, I once pushed ahead with research using Claude Code’s Sonnet and later regretted it, thinking, “I should have used the higher-end model from the beginning.”

Of course, using a higher-end model does not guarantee the right answer.

But at least for the first step of research or design, there is no reason to be stingy with model performance.

If I am going to realize the mistake after wasting half a day, it is cheaper to use the smartest model from the start.

Compared with labor costs, model fees are basically a rounding error.

Since then, I have set a rule for myself.

• Claude Code is reserved for the highest-performance model
• Codex handles chores

It is a division of labor.

My Current Workflow

Recently, this setup has become familiar on my desk as well.

I place two screens side by side: Claude Code on the left, Codex on the right.

That said, the collaboration between Claude Code and Codex is not perfect.

Sometimes I ask Claude to write instructions for Codex, but in the end they are AI tools from different companies.

The world is not yet futuristic enough for AIs to talk to each other on their own and complete the work without me.

The flow looks something like this:

1. Ask Claude Code to write the work plan or procedure
2. A human passes that procedure to Codex
3. Codex performs the actual work
4. A human judges the result

I now send work such as document preparation, test case execution, and routine research tasks to Codex, even though I might previously have given those jobs to Sonnet.

The Manager Is Still Human

That said, I do not think this setup is the final form.

AI capabilities change almost every month.

An AI that was a part-time worker yesterday may become a mid-level employee next month. Conversely, an AI that looked like the star performer may be overtaken by another model.

So this role division will probably change again in a few months.

But there is one thing that has not changed.

In the end, the human is the one who takes responsibility.

Claude Code thinks through the direction, and Codex executes the work.

That is certainly convenient.

From the perspective of my past self, it would look like a dream development environment.

But both of them make mistakes.

And they make those mistakes with complete confidence.

That means a human still has to decide which AI to use, how much to delegate, and whether the result can be trusted.

Before I knew it, I had become less like a programmer and more like the manager of a small development team.

The team members are capable.

They do not complain.

They work 24 hours a day.

However, they occasionally misunderstand something on a grand scale.

And for now, cleaning up after those misunderstandings still seems to be the human’s job.

At least on today’s desk, the engineer is on the left and the part-time worker is on the right.

Between them, I, the oldest software in the room, am doing the management work.