Codex vs Claude Code Real-World Comparison: Efficiency and Quality Differences When Building Apps from the Same Prompt

AI coding agents are getting increasingly powerful, but how much do results actually differ when you hand the same task to different tools? Renowned AI automation blogger Nate Herk ran a highly instructive experiment: he gave Codex and Claude Code the exact same prompt, having each independently build a "production-ready Typeform alternative." The outputs differed dramatically, and so did the generation process—one took two and a half days and burned nearly $3,000, while the other finished in just five and a half hours for roughly $800.

Typeform is a Spanish SaaS company founded in 2012, known for its distinctive "one question at a time" conversational form experience that completely upended traditional form design. Compared to the "stacked" layouts of Google Forms or SurveyMonkey, Typeform dramatically improves completion rates through full-screen immersive interactions. The company's valuation once exceeded $900 million with annual revenue surpassing $100 million. Its commercial success and clear product boundaries make Typeform a common "target product" in AI coding agent tests—it's complex enough (involving form logic, conditional branching, data collection, sharing/publishing, and other complete workflows) without being so massive as to be unevaluable like an ERP system.

This article is based on a complete breakdown of this comparison experiment, analyzing the strengths of both major coding agents and the profound impact different prompt styles have on outcomes.

Experiment Setup: Same Prompt, Drastically Different Outputs

The experimental setup was highly rigorous: the author used the same custom slash command in both Codex and Claude Code, passing in an identical prompt. The core requirement was to build a "production-ready, originally-branded Typeform alternative," with three clearly defined phases handled by dedicated agents: research, build, and verification.

It's important to understand the tools here. Codex is OpenAI's coding agent product, built on their latest GPT-series models, running in a cloud sandbox environment with support for long-running autonomous execution of complex coding tasks. Claude Code is Anthropic's command-line coding agent that runs directly in the developer's local terminal, capable of reading/writing files, executing commands, and performing version control. The two represent the two mainstream architectural philosophies in current AI coding tools: Codex leans toward cloud-hosted automation, emphasizing security isolation and parallel execution capabilities; Claude Code leans toward local integrated collaboration, emphasizing seamless integration with developer workflows.

Slash commands are a standardized interaction method in modern AI coding tools, where users type commands like /task or /build to trigger predefined workflows. In this experiment, the author's slash command was essentially a "meta-prompt" that defined role assignments for multiple specialized agents: a research agent for competitive analysis and tech stack decisions, a build agent for actual coding, and a verification agent for testing and fixes. This multi-phase orchestration pattern derives from the "pipeline" concept in software engineering, and aligns with the increasingly popular "Agentic Workflow" paradigm—by decomposing complex tasks into multiple autonomous subtasks, each handled by a specialized AI role, overall output quality improves.

The prompt ended with one crucial requirement: "Don't stop at the prototype or first successful build stage—keep researching, building, testing, breaking, fixing, and retesting until the application is truly complete." The author's goal was clear—he wanted a finished product ready to ship the next day, not a demo.

Interestingly, the author later reflected that this prompt wasn't optimal. He believes that adding a dedicated "planning" phase between "research" and "build" to map out the entire workflow might have produced better results from both systems. This detail also foreshadows the subsequent win/loss analysis.

Feature options interface

Hands-On Experience Comparison of Both Products

Codex's Realform: Polished Design but Overwhelming

Codex's output was called Realform. From the landing page, the UI elements were quite solid—featuring a hero image, clear copy, and call-to-action buttons. An average person wouldn't immediately recognize it as AI-generated. The signup flow was well-executed too.

But once you entered the form editor, problems emerged. The author's immediate reaction was "a bit overwhelming"—the UI was packed with too many elements, with a supposedly clean question editing area stuffed full of variables and options. Worse, the author couldn't even figure out how to delete a single element—clicking delete wiped everything clean. Other bugs included broken image upload previews and mispositioned confirmation modals.

The author's assessment was razor-sharp: Codex thought very thoroughly about the "admin side"—what data you want to collect, how to organize it—but from the perspective of a user creating a form, the experience was actively discouraging. Moreover, it essentially only produced a demo workspace without implementing truly complete functionality, violating the prompt's core requirement.

Claude Code's Firmora: Rough Design but Functionally Solid

Claude Code's output was called Firmora. First impressions were actually worse—the landing page design was rough, and the author couldn't immediately tell what the product was for. But once you started actually using it, the experience flipped immediately.

"At least as a user, I clearly know what to do—I'm not staring at the interface in confusion," the author said. Firmora's workspace switching was smooth, and the form editor offered both "conversational" and "stacked" display modes, clearly closer to Typeform's interaction logic. Field types were rich (text, email, dropdown, image choice, rating, ranking, etc.), with support for progress bars, question numbers, keyboard hints, auto-save, partial response capture, and other practical features.

Issues discovered during testing

Firmora had bugs too: question numbers always showed as "1," returning from the design page was difficult, and some buttons were unclickable. But the key point was—it implemented a truly usable, complete workflow. The author successfully published a form, got a share link, and after filling it out could see real response data and submission sources on the results page. That's what a "production-ready product" should look like.

Cost and Efficiency: A Massive Resource Gap

The resource consumption comparison was staggering:

Dimension	Claude Code	Codex
API Cost	~$800	~$3,000
Output Tokens	~2 million	~11.5 million
Time	5.5 hours	~62 hours
Sub-agents	35	126
Tool Calls	Fewer	32,500
Browser Tests	102	391
Unit Tests	296	2,300+

By the numbers, Claude Code was roughly 11x faster and 6.6x cheaper.

In LLM billing systems, tokens are the fundamental unit of measurement. One English word typically corresponds to 1-2 tokens, while Chinese characters map to roughly 1-2 tokens each. When Codex output nearly 11.5 million tokens, that means it generated the equivalent of millions of words of code and text—roughly equivalent to the codebase of an entire medium-to-large enterprise application. At GPT-5 series pricing of approximately $15-60 per million output tokens, token consumption alone explains most of the cost difference. Notably, tool calls also consume tokens—Codex's 32,500 tool calls represent massive system interaction overhead, including file reads/writes, command execution, and browser operations, with each call requiring the context to be re-encoded as tokens fed into the model.

One interesting technical detail: the author started Claude Code with the Fable 5 model, but during the process some kind of safety check apparently triggered, ultimately falling back to Opus 4.8 as the primary orchestrator, which then dispatched Fable 5 agents to execute tasks. Fable 5 is a new-generation model launched by Anthropic in 2025, positioned as a flagship model with high creativity and reasoning capabilities. Opus 4.8 belongs to the highest-performance variant in the Claude 4 series, known for stable performance in complex multi-step tasks. The "safety check triggered fallback" phenomenon observed in the experiment reflects Anthropic's layered safety mechanism for deploying new models—when the system detects potentially risky behavior or anomalous patterns, it automatically downgrades tasks to more thoroughly safety-tested mature models. This "orchestrator-executor" hierarchical architecture is also the mainstream design in current multi-agent systems: one high-level model handles overall planning and task allocation, while multiple specialized models handle specific execution.

Codex used GPT-5.6 (highest performance tier) throughout. These model variable combinations are also a major reason why results are difficult to predict.

Resource consumption comparison

Judging the Winner: It Depends on How You Define "Win"

The author had Codex perform a cross-review of both anonymized results, and Codex also judged Claude Code's output as superior. But diving into individual dimensions reveals the outcome is actually more nuanced.

Dimensions Where Claude Code Won

Product judgment and scope management: Claude Code was clearer in "must do / defer" decisions, focusing on valuable differentiating features. Codex, by contrast, pursued up to 135 features including several costly operational characteristics, making the product bloated.
Development efficiency: Claude Code scored 9.8, Codex only 5.5.

Dimensions Where Codex Won

Architecture and execution: Codex built a system with higher operational maturity, including immutable revisions, offline recovery, migration safety, concurrency handling, and cloud boundaries. Immutable revisions mean every data change is saved as a new version rather than overwriting existing data—critical for audit, compliance, and data recovery scenarios. Offline recovery ensures users don't lose data when disconnected, with automatic syncing when back online. Migration safety guarantees that database schema changes won't cause data loss or service interruptions. While invisible to end users, these features determine a system's reliability under high concurrency, edge cases, and long-term operations for a SaaS product truly destined for production. In backend infrastructure that needs to scale, Codex was clearly superior.
Testing and reliability: Codex won by a clear margin, adding cross-browser testing, property testing, fault injection, and numerous other tests, even covering mobile—things Claude Code didn't achieve.

This also explains why Codex consumed so many resources—it was building a "correct" system while neglecting the more fundamental dimension of "usable."

Review results

Core Insight: Different AI Coding Tools Need Different Prompt Strategies

The most important takeaway from this experiment isn't actually "which is stronger," but that the two agents require fundamentally different prompt strategies.

The author's analogy is vivid: Claude Code (Fable) is like a "smart owl"—great at creativity, planning, and brainstorming, able to help you figure out which path to take. When prompting it, you just need to provide high-level goals + completion criteria, then let it run free without getting in its way.

Codex is more like an "obedient executor"—it does exactly what you tell it to do, diligently running tests to ensure task completion. But it lacks sufficient creativity to intuit the experience you actually want, so when using Codex you must be very specific: step one is this, step two is that, step three is the other thing. In this experiment, Codex clearly failed to understand the true intent of the prompt's ending—"build a complete production-ready product"—even though it worked extremely hard over an extended period, its output drifted from the target.

In other words, Codex's "failure" here was largely caused by prompt mismatch, not insufficient tool capability. The author noted that in his daily work, he uses Codex for about 80% of development and Claude Code for 20%, likes both tools, and flexibly switches between them for different scenarios.

Practical Advice for Developers

The author's optimal workflow combination is worth noting: Use Claude Code for heavy development and planning, use Codex for security reviews, finding bugs, and fixing bugs. Many people have used Claude Code's Codex plugin to run adversarial reviews, and it almost always catches edge cases that Claude Code's workflow missed.

Finally, the author reminds us: new models emerge constantly (5.6, Fable, Opus 4.8...), there are simply too many variables, and every invocation is like "pulling a slot machine"—you can never predict the outcome. Therefore, running these kinds of small experiments yourself is crucial. He also offers a balanced perspective: don't blindly follow advice from luminaries like Karpathy, because they're using tools for different purposes than you—just as a triple jumper shouldn't completely copy a high jumper's techniques. While there's common foundational ground, they're ultimately different sports.