Short version: get Claude, it's the best balanced of the three. Codex is smart but burns through its limits in a couple of evenings. Cursor is just a reseller of other people's models, and its own Composer has fallen way behind.
I'm comparing things that cost the same - $20 a month: Claude Pro, ChatGPT Plus and Cursor Pro. This isn't a benchmark, it's what I got from shipping a product on them every day. Everything below is about August 2026; plans and limits change faster than articles get written.
So which one - Cursor, Codex or Claude Code?
Look at the feature list and all three are the same: they read the repo, edit files, run commands, speak MCP. The difference shows up on day three - when the tokens run out, when the agent fixes something completely different from what you asked, and when you catch yourself thinking about the tool instead of the product.
| Tool | What your $20 buys | Bottom line |
|---|---|---|
| Claude Code | Access to the vendor's own models, daily and weekly limits | The one I use every day |
| Codex | Access to the vendor's own models, a weekly budget | Second opinion, analysis, heavy investigations |
| Cursor | A pool of requests to other people's models plus its own Composer | Good IDE, weak agent for the money |
Now point by point, why it turned out that way.
Whose models are inside, and why it matters
Anthropic and OpenAI run their own infrastructure and their own networks - you're buying access from the people who trained the model. Cursor doesn't make models like that: it resells you Anthropic, OpenAI and Google at their API prices and puts an editor on top. No philosophy here, just a middleman's markup.
- Claude: Sonnet 5 for every day, Opus 5 when the task is genuinely hard, Haiku 4.5 for fast little things, Fable 5 as another top-tier option. You pick the model yourself, and that's the main way to not burn your budget.
- Codex: the OpenAI line-up, with simpler and cheaper options for small edits and "thinking" ones for the heavy stuff. Honestly - I sat on sol the whole time and barely switched, so I can't speak for the rest.
- Cursor: any external model through the API plus its own Composer. People say Composer is a fine-tuned open model from the Qwen family. That was never officially confirmed, but it behaves exactly like one.
The takeaway is simple: with the model owner you pay for tokens, with an aggregator you pay for tokens plus margin. For the same $20 you get noticeably less work done.
Tokens: this is where it all breaks
People argue about model quality online, but a working day always breaks on the same thing - tokens. And here the three behave completely differently.
Codex: weekly limits and a reset lottery
As of August 2026 the limits are weekly, and three hours of dense work can burn them. Then it gets weird: they reset them from time to time, off schedule. On one hand it's nice - by the evening you're back in the game. On the other, you can't lean on it: you burn the whole week on Monday and hope it comes back. No guarantees, so no discipline either. It broke my working day a couple of times, and that stings more than any benchmark.
Claude: day, week, month
Here the limits are spread across horizons: daily, weekly, monthly. Boring - and great. You can see up front how much you've got left today, so you don't start a heavy refactor an hour before everything runs out. Resets happen too, usually when a new model ships or after an outage, but they're a bonus, not a survival plan.
The second lever is picking the model. Sonnet handles routine just fine: edits, tests, small features, reading someone else's code. You turn on Opus where it's actually hard. That split saves more budget than any prompt gymnastics.
Cursor: same money, less work
Your $20 here is a pool of requests to other people's models at API prices, which is obviously more expensive than buying from the vendors. For the same money you get an order of magnitude less real work. Composer feels almost endless, but it's too weak to carry a serious task on its own.
The setup that works: use a strong model for the brief and the plan - what we're changing, where the boundaries are, how we check it. Give Composer the mechanical part: rename across the project, split a file, add tests from an existing pattern, sweep through repetitive spots. And read the diff yourself, always: Composer gives up before it says so, and it will happily hand you unfinished work as done.
Verdict on this one: Claude, no contest.
How they actually solve tasks
Codex
Sol is incredibly good at product analysis, complex investigations and plans. Give it something vague like "why is our signup funnel falling apart" and it'll lay out hypotheses better than plenty of human colleagues. It writes decent copy too.
There are exactly two downsides, and both are annoying. First, UI work: you get template-grade AI slop that's easier to rewrite than to fix. Second, it can drift off the question at some point and fix an adjacent area nobody asked it to touch - you lose control. The cure is a narrow brief: list the files and explicitly forbid everything else.
Claude
The main thing is that it does exactly what you asked for. Sonnet got a big upgrade in version 5: it closes about eighty percent of routine daily work, and I really liked that. I pull out Opus when the task is genuinely complex. Fable I never got the point of: I didn't see any strong difference from Opus, and I think most developers, like me, won't see one in everyday work either. Except in the price.
Cursor
I used it for about a year and suffered day after day. You trip over every little thing, you're constantly thinking about third-party model context, and in the end you're not thinking about the task but about how not to eat the whole budget in one day. That's where mistakes come from: you save exactly where you should have let the agent read three more files. I liked Composer itself, but in 2026 I wouldn't even consider it as an everyday model.
A brief that works everywhere
"Fix duplicate submission in the registration form. Only change the form files and its hook. Don't touch the public API or the styles. Add a regression test, run the form tests and list what you changed at the end."
Clients: terminal, IDE, desktop and cloud
The model is half the experience. The other half is where you talk to it.
Claude Code
It started in the terminal and the terminal is still where it's best: git, logs, tests, file search - all right there, no window switching. But calling it CLI-only isn't true any more: there's an IDE extension, a desktop app and browser access. The desktop app is handy when two or three sessions are running in parallel on different tasks - you see them as a list instead of a wall of terminal tabs.
Codex
Lives in the CLI, in an IDE extension and in the app. Nice thing: you can file a task from your phone and come back to the result later. What worked for me was using it not as hands but as a head - ask for the analysis and the plan in the app, then do the work somewhere else.
Cursor
The IDE itself is genuinely pleasant, and that's its strong side. It's a VS Code fork, so your habits and extensions move over in five minutes. Tab completion is still the best on the market: it guesses your next edit rather than your next word, neighbouring lines included. Inline editing of a selection and change checkpoints are done well too. If I were paying Cursor for the editor alone, I'd have no complaints. But the agent costs extra there, and more.
Cloud and async modes
All three now have a "file it and walk away" mode: the work doesn't run on your machine and the result comes back as a pull request. The upsides are obvious - your laptop is free, tasks run in parallel, and the brief turns into a ticket by itself.
- Plus: parallelism - two or three independent tasks move along while you're busy with your own.
- Plus: discipline - you can't shout "just make it good" into a cloud queue, you have to spell it out.
- Minus: the environment isn't yours. No internal services or secrets, and you have to teach the tests to run separately.
- Minus: no fast feedback. You find out the agent went the wrong way after twenty minutes, not twenty seconds.
- Minus: a nicely formatted PR is easy to take on trust. It needs a stricter look than a local diff, and the instinct runs the other way.
What I do: isolated work with decent tests goes to the cloud, and anything that touches the product I do locally.
Everything around it: features I barely use
All three have piled up a layer of extras: subagents, event hooks, rule and skill packs, scheduled tasks, artifacts and page generation, built-in web search. I'll be honest - I barely use any of it.
Exactly two things stuck: MCP, because it connects the agent to real project data, and a couple of project instruction files in the repo so I don't repeat myself in every prompt. Everything else I turned on, tried and turned off.
Fitting an agent into your work
The stronger the agent, the more it matters that its work doesn't stay in the chat history. The code goes to git, and the decision, the context and the status go nowhere. A week later nobody, you included, remembers why that field is named like that or what happened with the migration.
- Cut tasks to the budget. One pass, one task that fits inside the daily limit.
- Write the definition of done before you start. Not "make it nice" but "tests green, public API unchanged".
- Ask for a trace. The agent moves the task status, leaves a comment and links the PR.
- Keep the irreversible stuff yourself. Deploys, migrations, deleting data - by hand only.
If you want the agent to move statuses and write comments where the team actually sees them, connect Kelvia over MCP. It works with all three: the agent takes a task off the board, moves it through the statuses and puts the result back where the team is already working.
Verdict
Claude is great. Predictable limits, a sane model split and, most of all, it does what you asked instead of wandering off to fix a neighbouring module. For the same $20 that's the most honest amount of useful work.
But I keep the ChatGPT subscription just in case. First, new models and features land there first, and I'd rather poke at them myself than read summaries. Second, sol really is strong at product analysis: laying out hypotheses, working through scenarios, putting a plan together. And third - probably the main one - a second model looks at the project with different eyes and regularly finds what the first one has already taken for granted.
Cursor is the only one I dropped in the end. As an editor it's still good, and I get people who pay for the tab completion alone. But as a primary agent in 2026 I wouldn't buy it.
Caveats
This is personal experience, not a benchmark: a different stack, different tasks and a different briefing style may give you a different picture. Everything here is about August 2026 and the $20 plans; on higher tiers the limits work out differently.
What each tool can do right now is easiest to check in the docs: Cursor, Codex and Claude Code. Plans and limits change, so check the terms before you pay.
If a product page is next on your list, there's how to build a landing page with AI without the template look.
FAQ
What do I get if there's only room for one subscription?
Claude. Not because its models are objectively the smartest, but because the limits are legible: the smaller model handles routine, the bigger one stays free for the hard stuff. Your working day stops depending on a lottery.
Is Codex really smarter on complex tasks?
On analysis, investigation and planning - often yes. But the weekly limits go in a few evenings, and in code it likes to fix an adjacent area nobody asked it to touch.
Is Cursor worth buying in 2026?
As an editor, yes - the completion and inline edits are still a pleasure. As a primary agent for the same $20, no: you're paying a middleman for someone else's models.
What do you do if the limits run out mid-task?
Don't wait for a reset - move the state into the task: what's done, what's left, which files you touched. Then finish the routine part on a smaller model or by hand.
How do you safely give an agent access to a project?
Minimum permissions, no secrets in context, review the commands and the diff. The irreversible stuff - deploys, migrations, deleting data - keep for yourself.