Codex over Claude: The harness, not the model, won the week

Ruby developer Lucian Ghinda spent a week using OpenAI Codex instead of his usual Claude Code and came away with a conclusion that cuts against the model-supremacy narrative dominating AI discourse: the harness matters more than the model. His field notes, which hit 142 points on Hacker News within 20 hours, document six practical differences between the two tools. None of them are about raw code-generation quality. All of them are about how the agent is pointed at a repository, a git history, and a developer’s accumulated habits.

The timing is telling. Mid-August 2026 is a moment when the coding-agent market has fractured into a dozen credible options, and the HN thread attached to Ghinda’s post reads like a battlefield report from a war nobody is winning outright. Commenters are cycling through Codex, Claude Code, Prime Agent, Grok 4.6, Gemini 3.7, and a handful of open-source harnesses, often running several in parallel. One commenter, jmaker, describes ending up with “a factory” of models routed across subagents. The takeaway from Ghinda’s week, and from the thread it spawned, is that the industry has moved past the question of which model is smartest and into the harder question of how to build reliable scaffolding around models that are all roughly competent.

Ghinda’s most consequential observation is about skills portability. He kept Claude and Codex on equal footing with the same plugins, but over months Claude accumulated skills he created from past sessions that he never ported over. His fix: point Codex at the Claude skills folder and ask it to translate them. This treats skills as repo assets rather than per-tool settings, which means switching agents stops being a fresh start. The deeper implication is that procedural memory, the accumulated know-how of how you like code written, is becoming a portable asset that outlives any single vendor’s tool. Developers who invest in a canonical skills folder are building something that survives model churn, and in a market where model rankings shift quarterly, that is a meaningful hedge.

The second lesson is about pressure moments. Ghinda admits that when debugging something urgent, he still opened Claude, not because it was better but because it was familiar. This is a genuinely useful admission. It reframes the “which agent is best” question as a portfolio problem: pick a primary agent for steady feature work, keep a familiar one for emergencies. The strategic move is deciding which assistant owns which kind of moment, not swearing loyalty to a single vendor.

The most alarming anecdote in the post is the git one. Codex set up a branch that targeted another branch that targeted main, and when asked to rebase, it rebased against main, dragging in an unrelated stream of commits and opening a pull request with 4,000+ additions. Ghinda’s fix was three git commands that catch the problem before a PR ever opens: git log --oneline --graph --all to view topology, git diff --stat origin/main...HEAD for the three-dot diff, and git log origin/main..HEAD to list every commit that would land on main. A merged 4,000-line PR costs an afternoon of untangling; three commands cost seconds. This is the kind of harness-safety problem that will define the next phase of agent adoption, because the failure mode is not a model being dumb. It is a model being confidently wrong about repository state.

Ghinda also flags a temperament difference that cuts both ways. Claude feels like a colleague guessing what you want and doing it, while Codex feels like a companion that does what you tell it and stops at the first sign it might be done. Claude’s eagerness produces abstractions, type aliases, and Sorbet signatures nobody asked for. Codex produces fewer comments and more contained solutions, but it sits back and waits when genuinely unsure. The practical takeaway: loosen prompts for the eager tool, tighten them for the contained one. The harness, the prompt file, the session structure, does most of the steering.

The HN thread adds texture to this picture. One commenter, ibramGaunt, reports their token usage on Claude models dropped 83% over the last month, citing cyclic loops and context-compaction failures. Another, roamerz, dropped their Claude Max plan after burning through a limit in 10 minutes and subscribed to Codex’s $200 plan instead. jmaker describes Claude’s subagent orchestration as producing “quite some disagreement between the subagents and orchestrator,” with Claude routing subtasks to Haiku and Sonnet only to later disagree with them and redo the work, burning extra tokens.

There is also a pricing subplot worth watching. Commenter mediaman flags that Grok 4.6’s cache-read costs are $0.50 per million tokens, or 25% of uncached reads, versus the industry standard 90% discount. For agentic work, where the vast bulk of token consumption is cached input reads, that pricing structure erases the headline savings. Meanwhile, lifty reports that Codex plans quietly reduced token allotments around a week ago, with users finishing weekly quotas in a single day on the same projects that previously never hit the cap. Token economics are becoming the real battleground for agent adoption, and the pricing structures are shifting faster than the models.

The political undercurrent in the thread is also hard to ignore. A commenter references a recent discovery that Grok Build was uploading entire repositories to servers in the background, including .env secrets that had been excluded, via a gist from cereblab. That incident has put Grok on the no-fly list for many developers and companies, and it has become a recurring objection in every Grok recommendation. The response from timr, that it was a bug and immediately corrected, does not fully answer the trust question. When your code leaves your machine, the harness’s data-handling behavior is a feature, not an afterthought.

Ghinda’s settled workflow is the quietest and most important part of the post: code research, design change, review change, implement, verify. There is no “start coding immediately” in that sequence. The research and design phases come first, review happens before implementation, and verification is its own explicit step. This is the harness in miniature, and it is the single biggest lever any developer can pull regardless of which tool they run. Forcing an agent to research and propose before writing code prevents most of the “wrong but confident” edits. Making verify a named step keeps it from declaring victory the instant the diff exists.

The honest bottom line from Ghinda’s week is that the difference between Codex and Claude is temperament more than capability. Both are usable; they are just not driven the same way. The practical advice is to keep skills in one place, split work into focused sessions, protect git with preview commands, and run the research-verify cycle no matter which tool is in front of you. None of that investment goes to waste when the next coding agent launches, because it all lives in the harness, not in the vendor.

What this means for the industry is that the coding-agent market has matured past the model benchmark era. The frontier labs are still shipping new models, but the differentiation is shifting to harness design: session management, git safety, skills portability, auth flows, and token pricing. Developers are no longer asking which model is smartest. They are asking which harness is safest to trust with a repository and a deadline. That is a much harder question to answer with a benchmark, and it is the one that will decide which tools survive the next year.