A developer posted a simple question on Hacker News: after a week of using OpenAI’s Codex more than Anthropic’s Claude Code, what changed? The thread exploded to 221 comments in two days. Developers didn’t just share preferences — they dissected model behavior, harness design, billing psychology, and the strange new reality of “vibe coding” burnout.
This isn’t a benchmark. It’s a field report from people using these tools for real work, eight hours a day.
What Happened: The Spark
The original post linked to a blog article comparing a week of Codex vs Claude usage. But the real value wasn’t the article — it was the comment thread. Developers who’d switched, tried both simultaneously, or refused to switch weighed in with specific, technical observations.
Key context for beginners:
- Claude Code = Anthropic’s terminal-based coding agent (uses Opus/Sonnet models)
- Codex = OpenAI’s terminal-based coding agent (uses GPT-5.x “Sol,” “Terra,” “Luna” models)
- Harness = the CLI/TUI wrapper that gives the model tools (file access, shell, git)
- Model = the actual LLM (Opus 5, Sonnet 5, GPT-5.6-Sol, etc.)
The distinction matters. As one commenter put it: “Claude’s models do a better job of inferring my intent… When it comes to the desktop applications though, I find Claude Desktop’s output to be incredibly verbose and full of jargon.”
Developer Reactions: The Core Divides
1. Speed vs. Depth: “Codex is a chisel, Claude is a wrecking ball”
The most upvoted sentiment: Codex feels faster and more direct.
“The speed is the first big contrast; I have a routine multi-step skill that I run several of per week. Opus 5 was routinely taking 2 hours to do it, while older Claude models took around 20 mins; Codex restored that speed.”
But speed isn’t everything. Several developers noted Claude (especially Opus) handles ambiguity better:
“Claude’s models in my experience do a better job of inferring my intent… I had asked GPT’s 5.6 Sol to update the open document… and 5.6 Sol took it very literally… I tried again with Claude Opus 5 and it added a completely new tab with a complete new document that, although imperfect, much better matched my expectations.”
The pattern: Codex excels at well-scoped, technical tasks (performance optimization, bug reproduction, test generation). Claude excels at fuzzy, design-heavy work where intent matters more than specification.
2. The Verbosity Problem: “Don’t write a goddamn novel”
Claude’s comment obsession came up repeatedly. Developers are tired of cleaning up AI-generated comments that document the conversation rather than the code.
“Those massive comments generally refer to intermediate states that never shipped, making them utterly useless, noisy and confusing as a permanent artifact.”
“Claude comments look like this:
// add returns the sum of x and y // per section 2.1 of addition-implementation-plan.md sum is designed as the seam for user addition interfaces // previously sum added numbers, now it adds numbers def add(x, y): return x + y ```*
The defense: some argue these comments help future Claude sessions understand context (“Chesterton’s Fence for LLMs”). The counter: “The comments end up complicating simple tasks, and if you open the repo after a week it takes a while to find out why Claude is reading irrelevant files.”
Anthropic recently added a “Concise” output style. Early reports: it helps, but doesn’t fix the root cause.
3. Model Personality: “Opus is the enemy… sulky know-it-all personality”
This surprised me. Multiple developers described Opus 5 as actively unpleasant to work with:
“Opus 5 is user hostile… It’s doing stuff, but it seems mostly like busy-work… written in a way that I’d call spaghetti-tech-English. You can unravel it but it’s painful.”
“Claude generates more code, tries to build things that are not planned or needed, repeats same mistakes over and over. ChatGPT on the other hand just does enough, within a project would not repeat the same mistakes.”
“Opus is the enemy, and it will make you insane if you talk to it for too long.”
Contrast with Codex/Sol: “I don’t get a headache conversing with Sol. That alone is enough reason for me to stick to Codex.”
Personality matters when you’re pair-programming with an AI for 6 hours a day.
4. The Harness War: “Everything is about the harness, not the model”
A recurring theme: the CLI wrapper matters more than the model.
“Guys, everything is about the harness, not the model! I even use Hy3 for free from nous portal… I have it under the same harness (Hermes Agent) so result is more or less the same.”
Developers are building model-agnostic workflows: orchestration layers that swap models per task (planning → Opus, execution → Sol, review → Fable, cheap execution → Luna).
“Summer 2026 meta (well, mine): Sol is for routine work, Opus for frontend/design, and Fable for more complex/ambiguous/architecture work. Fable works extremely well to drive Sol as a subagent.”
The winning pattern isn’t “pick one tool” — it’s orchestrate multiple.
5. Billing Psychology: “Pre-paying for tokens is an ideological red line”
Codex uses prepaid token bundles ($20/100/200). Claude Code uses subscriptions ($20/$100/$200/mo). Developers have strong opinions.
Pro-subscription (Claude):
“Claude Code seems more generous with its quota, which is why I use it as my main driver.”
Pro-prepaid (Codex):
“Pre-paying for tokens is some kind of ideological red line for a lot of developers… The subscription models have so many more perverse incentives baked in. Those paying $100/mo+ for subscription access are almost certainly getting taken for a ride.”
The token anxiety is real: “Codex burns through it very, very quickly, even when I’m just using Terra 5.6 Medium. That’s basically why Claude Code remains my main driver despite Codex seeming more capable.”
6. The “Concise” Output Style: Anthropic’s Emergency Patch
Mid-thread, Anthropic released a “Concise” output style. Reaction: cautious optimism.
“The new concise output style they just released definitely helps with Opus 5 in general.”
But the deeper issue remains: models trained to over-explain. As one developer noted: “I’ve said this to claude way too many times, nothing you can do actually seems to make it significantly less verbose.”
The Real Insight: We’re Not Choosing Tools — We’re Building Workflows
The most sophisticated comments weren’t about “which is better.” They were about composing systems:
| Pattern | Description |
|---|---|
| Model routing | Opus for architecture → Sol for implementation → Luna for cheap execution |
| Adversarial review | “I use Claude Code with a MCP that lets it communicate with Codex and tell it to ‘iterate until both of you are happy’” |
| Harness abstraction | OpenCode, Paseo, Hermes Agent, ctx.traits — wrappers that make models interchangeable |
| Skill-based prompting | Reusable prompt chains (plan → implement → review → fix → verify) that work across models |
The meta-shift: Developers stopped asking “Claude or Codex?” and started building orchestration layers that treat models as pluggable components.
“I prefer not to have the model within that harness also bear the responsibility for remembering the process steps… For tasks that need to be repeated, I’ve been moving that part into a reliable, deterministic runtime.”
What It Means for You
If you’re starting today
- Try both — the $20 tiers are low-risk
- Don’t marry a harness — learn the patterns (AGENTS.md, skills, MCP) that transfer
- Expect to switch — the “best” model changes monthly
If you’re deep in one ecosystem
- Claude users: Test Codex for specific tasks (bug reproduction, test generation, perf work). Use “Concise” mode.
- Codex users: Keep Claude for ambiguous design work. Use subagent patterns (Fable → Sol) for complex tasks.
If you’re building a team workflow
Standardize on the orchestration layer, not the model. Build skills/prompts/MCP servers that work across Claude Code, Codex, OpenCode, and local models. The model landscape shifts too fast to hardcode.
The Unspoken Reality
Underneath the technical comparison runs a quieter thread: identity crisis.
From the parallel HN thread “Coding Agents killed my identity” (33 comments, same week):
“Programming is like a game of chess for me: winning is important, but only if I played this game myself… I don’t enjoy winning with an engine, and coding agents are basically ‘winning with a chess engine’.”
“Half a year ago I suddenly realized I hadn’t written any code for over a month… My role is to gather context from other humans and provide a detailed explanation… to some super intelligent engineer, then review the result. So, basically, a manager.”
The tool comparison matters. But the role shift — from craftsperson to delegator — is what developers are actually wrestling with. Codex vs Claude is just the current flavor of that transition.
Want the raw data? The full HN threads: Coding Agents killed my identity • Anthropic A/B testing reduced effort • A week of using Codex more than Claude