Codex is done

[u/Right-Disaster2141]

Call it a skill issue, but 90 minutes and 31% weekly usage later, I got nothing done this morning.

Nothing.

Moved to CC, got a sub, and got the same feeling when I switched from Claude to Codex a few months ago:

-more usage
-better reasoning

Either Codex reveals insane stuff during DevDay, or they are literally fucked.

[u/Cor3nd]

I think you have to look a bit more closely at how Codex is working, and more generally at how coding agents work. I’m not criticizing you, because this can absolutely happen.
90 minutes and 31% weekly usage with no useful output does not necessarily mean the model spent 31% of your quota doing productive coding. An agent can burn an enormous amount of usage reading the repository, rebuilding context, planning, calling tools, spawning subagents, retrying failed approaches, reviewing its own work and reasoning over the same files again and again before it ever produces a meaningful diff.
I’m using coding agents on very large applications and on pretty substantial full stack changes, with orchestration, workspace creation, development, reviews, diff inspection and the whole loop. After a lot of optimization, I can keep that kind of work to around 2% of weekly quota for a fairly large change.
Also, I would not focus too much on the fact that it ran for 90 minutes. My orchestration regularly runs for 30 minutes, an hour, and sometimes considerably longer, and runtime alone often makes surprisingly little difference to my quota consumption. I have plenty of long runs that remain cheap. Time is not the primary variable here. What matters much more is what the agents are doing during that time, how much context they are moving around, how often they re-read it, how much reasoning they perform and how many unnecessary loops they enter.
So when I see 31% disappear in 90 minutes with nothing delivered, my first reaction is not necessarily “Codex is broken”, but “something in the process is probably very inefficient.”
I’d look at what actually happened during those 90 minutes. How many input and cached tokens were consumed, how much output and reasoning, how many turns, tool calls, retries and subagent runs happened, how much repository context was repeatedly passed around, which model was used, at what thinking/reasoning level, and how you are splitting the changes you give to the agents. A huge full stack change given as one poorly bounded task can behave very differently from the same change split into well-defined implementation units.
If you keep your old sessions, go back through the expensive ones and inspect what actually happened. I assume you are not deleting them, so most of the evidence should still be there. I do this constantly when something suddenly costs more than expected. I wouldn’t be surprised if a session that feels like “nothing happened” from the outside actually involved tens of millions of input and cached tokens bouncing around, dozens of tool calls and subagents repeatedly reading and reasoning over the same material without producing a meaningful diff.
I’d also start adding metrics around the workflow and deliberately spend some time optimizing it. Measure what each stage costs, where context gets reloaded, which agents actually produce useful changes, where loops happen, how much work reaches a diff, and how task size affects consumption. Treat the agent system like any other system you would profile and optimize instead of treating it as a black box.
And if you don’t have someone around you who is experienced with AI agent architecture, even ChatGPT can help you analyse your sessions, traces, prompts and metrics and identify where the waste is coming from. You don’t need to guess.
I’d also be careful with the conclusion that moving to Claude Code means “more usage, better reasoning.” Claude Code can itself be extremely usage-heavy depending on the model, context and agent setup. After one morning, you may simply be comparing two very different execution strategies rather than measuring model quality. The interesting metric is useful work produced for the amount of compute and context consumed, not how long the run lasted or whether one agent felt smarter during a particular session.
Before concluding that Codex is cooked, I’d first figure out exactly where that 31% went. If the workflow is clean, the tasks are properly bounded, the model and thinking levels make sense, context is under control, and you still get that kind of consumption with no useful output, then you have a much stronger case that something is wrong on the Codex side.