Claude Code, Codex, and Cursor: Three Approaches to AI Coding

I want to compare Claude Code, Codex, and Cursor by their product philosophies, not just which model scores higher. My own approach changed as I moved from Cursor to Claude Code and then to Codex. The question is which workflows these tools are trying to support and where they may be going.

I am not trying to make everyone switch tools. This is my interpretation from using them, and it comes with a relevant connection: I helped build T3 Code, an agentic coding app that integrates with Codex. Product features and model comparisons here reflect the time of the video.

Claude Code began with a simple idea: as models became smarter, they could work directly in a developer's terminal instead of requiring code to be copied into a chat and pasted back. Cursor had already brought chat into the editor, but a terminal tool could fit into the tools developers already used.

The terminal imposes compromises. Images are awkward to paste and inspect, and selection, spacing, and rendering can be tricky. Claude Code's full-screen mode changes how the interface is rendered; I prefer it because the old flicker bothered me, though the approach has trade-offs.

The adoption story was compelling: install the CLI, authenticate, and keep using your existing editor and Git workflow. The agent could live in another terminal tab. Over time, users wanted more: automated Git operations, pull-request awareness, MCP connections, remote control, and parallel work.

Claude Code added extensibility such as hooks, although I found rough edges when building experiments around them. One experiment limited my access to sites such as Twitter whenever my agent finished, pushing me to return and give it another task.

For me, Opus 4.5 was a turning point. The model was capable enough that giving it terminal access to search a repository, run commands, and use MCP felt much more useful. I trusted its code more, so I felt less need to watch every change in an editor.

I often run these tools with permission prompts bypassed because of that increased trust. That is my personal workflow, not a guarantee that an agent will avoid harmful commands: the permission level and environment should be chosen for the task and its risks.

My controversial interpretation is that Claude Code also serves as a showcase for Anthropic's models. Its animations and features make agent activity feel exciting. I am inferring product priorities from the interface and my experience, not presenting evidence of the team's private design decisions.

In a demo I ask it to spin up subagents to audit example projects. The interface shows token counts, status updates, animations, and individual agents. That visibility feels productive, and parallel agents can indeed do useful work, but an active-looking screen alone does not establish the value of the result.

More agents can consume substantially more tokens. I see Claude Code as relatively willing to spend compute on parallel work, though actual cost depends on the task and plan. My concerns about integration restrictions and vendor lock-in are my reading of the incentives, not verified explanations of Anthropic's motives.

I also found the animations distracting and associated them with past performance problems. Still, this engaging experience helped draw me into agentic coding. People who like it are not wrong; its ability to make the work feel lively is part of its appeal.

I give Codex a similar request to audit the projects. The terminal display is much quieter: a timer, a working indicator, and little visible activity from the subprocesses. This is an illustration of the interface, not a controlled benchmark of how well either tool completes the task.

For me, the feature releases reinforce the contrast. Claude Code's radio command is playful; Codex's option to let computer use continue while a Mac is locked is less visually dramatic but useful in my setup. I prefer features that address practical friction, even when they do not make an impressive demo.

Another example is a shortcut that sends a screenshot of what I am viewing to Codex as context. I like giving agents visual context. On my dedicated Mac mini, computer use also lets Codex inspect changes itself, which in my experience improves the chances that a completed task actually works.

The Codex app's task display is similarly restrained. In contrast, when I update and open Claude's desktop app, I run into an awkward sign-in, a misleading failure message, missing CLI threads, and trouble adding a project. Those are problems I experienced in that session, not proof that nobody at Anthropic uses the app.

The difference I see extends to how each product uses compute. I characterize Anthropic as more willing to use additional tokens and subagents, while I see OpenAI putting emphasis on efficiency and verification. These are broad impressions, not a controlled comparison or a statement of either company's internal strategy.

I point to a benchmark where the GPT-5.5 result I saw used fewer tokens than some alternatives while scoring better. Such comparisons depend on the benchmark, model configuration, and date; they do not prove one approach is always more efficient. Running the changed application and inspecting it can be another way to verify a result.

Verification depends on the environment. I tried to configure Claude Code's cloud environment and gave up; when an agent cannot run the project, checking its work becomes harder. In my experience Codex has emphasized working with an existing local setup, including remote control of a machine, though cloud setup remains an option whose details can change.

Cursor's cloud approach is the third option. I use its browser interface and value its cloud agents because they can run a graphical Linux environment, launch the app, and use computer interaction to inspect changes. In the example, the agent runs the browser version of T3 Code to test its work.

That is useful when I am on my phone without a remote machine ready, or when multiple tasks need computer use at once. A local computer can be unavailable, disconnected, or occupied. A cloud environment still has to be configured for the project; its availability alone does not guarantee a correct result.

I also like the team workflow: someone can mention a Cursor bot in Slack about a product issue and receive a video of a proposed fix in the thread. My shorthand is that Codex prioritizes today's local workflow, Claude Code emphasizes what more capable models might do, and Cursor invests in delegating work to cloud environments.

I care whether the people making a tool actually use and test the experience customers receive. I argue that OpenAI and Cursor have strong internal use, and I am less confident about the Claude desktop experience. I also speculate about differences between internal and public models and configurations; I cannot substantiate those claims here.

One example behind my concern is a Claude desktop response that treated a system reminder about malware as a possible prompt injection while reviewing my personal site. I found the response strange, but it does not establish why it happened or what internal configuration a company uses.

Integration is another practical distinction. T3 Code, which Julius and I built, uses the Codex app server from the open-source Codex CLI. I appreciate having that component available for other interfaces, even though I would also like the Codex app itself to be open source.

When we tried adding Cursor to T3 Code, its CLI and agent protocol integration lagged the models available elsewhere: the list was hardcoded and missing newer options. We worked with the team and the issue was addressed; Cursor also released an agents SDK. My judgment is that the vendors have placed different priorities on third-party integration.

Finally, model quality affects how the whole product feels. In my own testing I preferred the progression of OpenAI's models and felt later Opus versions regressed for the work I do. That is a subjective assessment, not a general finding that one model family improved or worsened for everyone.

I care less about a single prompt comparison than about the direction of the team, the problems it solves, and whether the workflow will remain reliable. If you mostly use a sidebar in an editor, try some of the newer agent interfaces and desktop apps to see whether they fit your work.

My personal recommendations reflect those preferences: Claude Code can be engaging and motivating; Codex suits my preference for a quieter interface and existing engineering workflows; and Cursor's cloud agents are compelling for team delegation. These are starting points for evaluation, not labels for the ability of their users.

I briefly dismiss Antigravity and suggest that people already using Pi may not need this comparison. Ultimately, try the tools yourself and let each one shape the workflow a little. I liked Codex more when I stopped expecting it to behave exactly like Claude Code.