Choose Codex, Claude Code or Cursor by the workflow you need to finish: a reviewed repository change, a small edit beside your cursor, or a repeatable automated run. Then compare the bill for that workflow. This comparison uses official documentation checked on 13 November 2026; the recommendations are an editorial assessment, with a suggested trial rather than new benchmark results. Start with the [ready-to-use task](#task-brief) and [blank run log](#worksheet) if you want to compare your own results.

## Which should you try first? {#choose}

- **Codex:** start here if you already have an eligible ChatGPT plan and want to try a repository task through its terminal, editor or cloud workflow. Measure the allowance you actually have before buying another subscription.
- **Claude Code:** start here if your work centers on Claude and you want a command-driven coding loop, with the option to review it in an IDE or the Claude app. Confirm which account is paying for the session.
- **Cursor:** start here if the editor itself is the part you want to change: navigating code, reviewing diffs and steering an Agent in one place. Check the cost of the particular model you intend to use.

These are starting choices based on the documented interfaces and billing routes below. All three can participate in repository work; the deciding question is which combination helps you accept a correct change with less supervision.

The choices can overlap. OpenAI documents [Codex in Cursor](https://learn.chatgpt.com/docs/codex/ide), and Anthropic offers a [Claude Code extension for Cursor](https://code.claude.com/docs/en/overview). You can keep Cursor as the editor and choose a different agent. Installing an extension does not merge the providers' subscriptions or usage meters.

## Capabilities: compare the working loop {#capabilities}

| Capability | Codex | Claude Code | Cursor |
| --- | --- | --- | --- |
| Read a repository, edit files and run tools | CLI and editor workflows | Terminal and IDE workflows | Agent in the editor and CLI |
| Review changes beside the code | IDE extension | IDE extension | Built into the editor |
| Work outside the editor | CLI, desktop and cloud surfaces | Terminal, desktop and browser surfaces | CLI and Cloud Agents |
| Script a run | `codex exec` | `claude -p` | `agent -p` |
| Remote work | Reusable Codex Cloud environments | Cloud sessions | Cloud Agents; check plan access |

Sources: [Codex CLI](https://learn.chatgpt.com/docs/codex/cli), [Codex IDE](https://learn.chatgpt.com/docs/codex/ide), [Codex Cloud](https://learn.chatgpt.com/docs/cloud), [Claude Code overview](https://code.claude.com/docs/en/overview), [Claude automation](https://code.claude.com/docs/en/headless), [Cursor Agent](https://cursor.com/docs/agent/overview) and [Cursor CLI](https://cursor.com/docs/cli/overview).

A feature being present is only the first check. For a refactor, inspect whether the agent found every caller and preserved the public behavior. For a failing test, check the reproduction and the final assertions. For automation, test the credentials, permissions, exit status and output format in the environment where the job will run. A successful local session does not establish that a CI runner has the same tools or access.

### Choose a task before choosing a winner

| Your task | A useful first trial | What to inspect |
| --- | --- | --- |
| Fix one reproducible bug | The agent already included in your current plan | Correct reproduction, minimal diff and relevant regression |
| Make frequent small edits while reading code | Cursor's editor loop or an agent extension in your existing IDE | Navigation effort, unwanted changes and time spent reviewing |
| Change several files across a repository | Codex or Claude Code; include Cursor Agent if you prefer its editor | Missed callers, test coverage and manual repairs |
| Run a scripted review or maintenance job | A CLI workflow from any of the three | Repeatability, bounded spending and a useful failure result |
| Delegate work to a remote environment | One cloud task with the project's real checks | Dependency setup, service access and how you review the returned change |

This table suggests an evaluation order. It does not claim that one product produces better code on every repository. Record the selected model and settings as well as the product: changing the model can change the result and the bill.

## Subscription prices and the extra bill {#cost}

The following is a snapshot of individual monthly web prices in USD, before applicable tax. Annual discounts, business contracts, account eligibility and legacy plans need their own comparison. These prices are not API token rates or a promise of a particular number of coding tasks.

| Product | Monthly subscription snapshot | What to budget separately |
| --- | --- | --- |
| Codex via ChatGPT | Free $0 and Go $8 have limited desktop access, subject to rollout. Plus $20; Pro $100, $200 or $500 | Additional credits or API-key usage; see [OpenAI pricing](https://learn.chatgpt.com/docs/pricing) |
| Claude Code via Claude | Pro $20; Max $100; Ultra $200 | Usage beyond the plan and the separately tracked platform/API balance; see [Claude pricing](https://claude.com/pricing) |
| Cursor, current plans | Free; Plus $8; Premium $30; Super $100; Ultra $200 | Plus has no third-party models; Premium and above bill them separately. See [Cursor pricing](https://cursor.com/pricing) |

### Read the allowance that applies to your account

For Codex, ChatGPT Work shares usage with Codex. API-key authentication follows API billing and has a different cloud-feature scope. Use the account dashboard or CLI `/status` for remaining capacity. [OpenAI's pricing documentation](https://learn.chatgpt.com/docs/pricing) explains the distinction.

For Claude, paid-plan activity shares usage across Claude and Claude Code. Max and Ultra also advertise $100 and $200 in monthly platform API credits respectively; check their conditions and balance separately from your coding allowance. [Claude's plans](https://claude.com/pricing) describe the included benefits. In Claude Code, `/usage` shows plan usage or token consumption; its session dollar estimate is not a subscription invoice. See the [cost documentation](https://code.claude.com/docs/en/costs).

For current Cursor plans, the weekly pool is shared with Grok. Third-party model usage on Premium and above comes from prepaid credit, outside that included pool. Existing legacy Cursor plans retain different monthly pools and on-demand billing. Start with the plan shown in your account; the [models and pricing documentation](https://cursor.com/docs/models-and-pricing) distinguishes these arrangements.

Consequently, "$20 versus $30" is an incomplete comparison. Write down the intended model, the allowance it consumes and the rule after that allowance ends. A larger subscription is useful when it removes a limit that actually interrupts your work; it does not by itself prove a lower cost per accepted change.

## Compare the cost of accepted work {#budget}

Use one accounting period and count all paid attempts, including failures:

**Cost per accepted task = (subscription share + extra usage charges + review and repair time at your chosen hourly rate) / accepted tasks.**

For an illustrative month, assume $20 of subscription cost, $10 of extra usage and 50 minutes of review at $30/hour. That is $55 across 20 accepted tasks, or **$2.75 per accepted task**. These are invented worksheet inputs, not measured performance or a provider quote. Include review time spent on rejected attempts in the total.

If you would retain a subscription for other work, calculate two views: the full allocated cost and the additional cash required for coding. Label them. A workflow that uses an existing allowance can have low additional cash cost while still consuming capacity you value.

For exact API workloads, use the [API pricing worksheet](/analysis/ai-api-pricing/). Its token calculator does not estimate the task allowance in a subscription. Our [Codex limits guide](/analysis/codex-usage-limits/) and [Claude plans guide](/analysis/claude-plans-and-limits/) cover the account checks in more detail.

## A ready-to-use task for all three tools {#task-brief}

Use a small practice project with Python 3. Save these two files in the same folder and retain their starting revision. The fixture was checked locally on 13 November 2026; the tables below are blank for your own agent runs.

**`tags.py` — the starting implementation:**

```python
def normalize_tags(tags):
    return [tag.lower() for tag in tags]
```

**Task:** accept a list of strings, trim whitespace at both ends, lowercase each tag, remove empty tags and duplicates, and preserve first-appearance order. Leave the input list unchanged. For `[' Rust ', 'python', 'RUST', '', ' Python ']`, return `['rust', 'python']`.

**`check_tags.py` — keep this checker unchanged:**

```python
from tags import normalize_tags

cases = [
    ([" Rust ", "python", "RUST", "", " Python "], ["rust", "python"]),
    (["b", "a", "B"], ["b", "a"]),
    ([" ", "\t"], []),
    ([], []),
]
for values, expected in cases:
    original = values.copy()
    actual = normalize_tags(values)
    assert actual == expected, (actual, expected)
    assert values == original, "input changed"
    assert normalize_tags(actual) == actual, "not idempotent"
print("4 cases passed; input unchanged")
```

Run `python3 check_tags.py` in that folder; substitute your installed Python 3 command if it has another name. The starting implementation fails. Ask each tool:

```text
Fix normalize_tags in tags.py to meet the stated requirements.
Change only tags.py; keep check_tags.py unchanged.
Use only the Python standard library.
Run python3 check_tags.py and report the result and changed files.
```

Accept a run after the checker succeeds, the diff changes only `tags.py`, and you understand the result on another input. A passing checker covers these cases and invariants; review the implementation too. Start the next tool from the original two files, with the same instructions and environment. The [Codex first-run guide](/codex/#install) and [Cursor first-run guide](/cursor/#install) show how to reach that starting point in each product. Use the [Claude Code guide](/claude-code/) for its account and billing checks.

## Record attempts, spending and review time {#worksheet}

Copy these tables into your notes. Before the first run, record the starting revision, operating system, Python version, product surface, selected model and reasoning setting, sign-in method, plan, usage balance and spending cap. Use the same task language for all tools. If the selected models differ, describe the result as a workflow comparison.

Add a row for every attempt, including rejected changes. Elapsed time is the run's wall-clock duration; review minutes are human time reading, checking and repairing its output. Record one-time setup separately.

| Run | Product / model | Accepted? | Elapsed min | Review min | Extra USD |
| --- | --- | --- | --- | --- | --- |
| C-1 | Codex / … | … | … | … | … |
| A-1 | Claude Code / … | … | … | … | … |
| U-1 | Cursor / … | … | … | … | … |

After the same accounting period, sum each product's attempts. Enter the subscription share once in the summary, and include review of rejected attempts in total human time. Extra USD means usage charged outside the subscription share.

| Product | Subscription share USD | Extra usage USD | Review min, all attempts | Accepted tasks |
| --- | --- | --- | --- | --- |
| Codex | … | … | … | … |
| Claude Code | … | … | … | … |
| Cursor | … | … | … | … |

For an hourly review value **H**, calculate **(subscription share + extra usage + review minutes × H / 60) / accepted tasks**. A product with zero accepted tasks has no cost-per-accepted-task result. Mark unavailable usage charges as unknown; an estimate missing those charges is incomplete. Keep allowance units alongside money when the account reports only a remaining allowance, and avoid counting the same charge in both subscription and extra usage.

This small exercise helps check setup and accounting. Add the real bug, feature and refactor from your own project before drawing a broader conclusion about which tool to keep.

## A fair trial on your repository {#trial}

1. Pick three bounded tasks: one bug, one small feature and one refactor. Freeze the starting revision, instructions and acceptance checks.
2. Give each agent a fresh equivalent workspace. Use the same available tools and inputs; record the model, settings, plan and sign-in method. If the models differ, describe the result as a workflow comparison.
3. Include every attempt. Record allowance or money spent, elapsed time, accepted results, manual repairs and regressions introduced.
4. Review the diff and run the same checks. Keep a failed task in the record, even if a later attempt succeeds.
5. Prefer the workflow that meets your acceptance criteria at an acceptable total cost. Repeat on larger work before committing to an expensive plan.

## Experience, updates and the next step {#next}

[Alex's account of using GPT-5.6 inside Claude Code](/analysis/claude-code-gpt-5-6-suspension/) documents a particular experience. It is useful context for account and integration choices; it does not provide a controlled ranking of these three products.

Start with one task and the allowance you already have. For setup instructions and dated developments, visit the [Codex](/codex/), [Claude Code](/claude-code/) and [Cursor](/cursor/) reference pages. Recheck the linked official terms when changing plans, models or billing routes.