Skip to main content

08 - Codex vs Claude Code, Copilot, Cursor: an honest look

Codex against Claude Code, GitHub Copilot and Cursor: November 2026 prices, documented differences and a test on your own tasks to choose without fandom.

What do you think about this article?

08 - Codex vs Claude Code, Copilot, Cursor: an honest look
OpenAI Codexfedericocalo.dev

At a Glance

Codex against Claude Code, GitHub Copilot and Cursor: November 2026 prices, documented differences and a test on your own tasks to choose without fandom.

You are about to pay for a subscription to a coding agent and you have four names in front of you: Codex, Claude Code, GitHub Copilot, Cursor. There is no winner, and whoever proclaims one without telling you on which task they measured it is selling you something. The differences that hold up under verification, with the vendors' pages opened on 13 November 2026, are four: where the tool lives (terminal, editor, GitHub, cloud), which models you can use, how it makes you pay (windowed messages, credits, multiples of a base plan) and how much control it leaves you over permissions. The practical criterion: choose the tool that matches the place where you already work, with a predictable cost for your volume of use, and measure on your own code with three real tasks before committing to an annual subscription or to a team.

Eighth and last part of the OpenAI Codex series. I have not run benchmarks or tried the four tools on a task: I will not tell you which one writes better code, because I have not measured it. I give you facts declared by the vendors, dated, two scripts that do the arithmetic on them without calling any tool, and a method for you to measure. I am not affiliated with any of the four. This site writes about all four: the other guides are linked further down.

The overall picture: where they are alike, where they are not

CodexClaude CodeGitHub CopilotCursor
Where it is usedCLI, IDE extension, desktop app, web and cloud, SDK, GitHub ActionTerminal, IDE extensions, desktop app, webEditors and IDEs, CLI, github.com and the GitHub mobile appEditor with an agents window, CLI, cloud agents from the Premium plan
ModelsGPT-6 family (Astra, Sol, Terra, Luna); other providers with an endpoint compatible with the Responses APIClaude modelsModels from several vendors (Anthropic, OpenAI, Google, xAI, Microsoft and others); availability changes by plan and featureGrok models included; third-party models at API list price, billed separately
Instruction filesAGENTS.mdCLAUDE.md; reads AGENTS.md if CLAUDE.md is missing (from version 2.1.277).github/copilot-instructions.md, per-path .instructions.md files, AGENTS.md (on GitHub); alternatively CLAUDE.md or GEMINI.mdRules in .cursor/rules and AGENTS.md
Documented extensionsSkills, plugins, MCP, subagents, hooksSkills, plugins, MCP, subagents, hooksSkills, custom agents, MCP, hooksSkills, subagents, MCP, hooks
PermissionsSandbox (read-only, workspace-write, danger-full-access) plus approvals (part 3)Modes and permission rules per tool type; confirmation for commands and edits by defaultNot read in detailNot read in detail

Two rows of this table disprove what is usually said. First, the extensions: all four products document skills, MCP, hooks and delegated agents, so "the only one with hooks" or "the only one with subagents" is a sentence that no longer holds, and the details (events, file format) differ from product to product, so they are not compared by name. Second, the instruction file: all four read AGENTS.md. Claude Code reads it on its own when there is no CLAUDE.md (if both exist, by default it reads only CLAUDE.md, unless there is an import or the "Project instructions" setting), Copilot also accepts CLAUDE.md and GEMINI.md in the root, and Cursor lists AGENTS.md among the rule types. The practical consequence is to keep a single file as the source of truth and not to write four (part 4). The two "not read in detail" cells are a limit of mine: before comparing permissions row by row, read the documentation of the two vendors.

The declared prices, all together and with the caveats

Sources: the plan pages of the four vendors, read on 13 November 2026. US dollars per month, prices before taxes.

TierCodex (ChatGPT)Claude (Claude Code in the paid plans)GitHub CopilotCursor
FreeFree $0 (quick tasks; Luna in the desktop app)Free $0, without Claude CodeFree $0 (2,000 completions per month, CLI)Free $0 (limited use)
EntryGo $8; Plus $20Pro $20 per month, $17 with annual payment ($200 upfront)Pro $10 ($15 in total credits)Plus $8 (Grok models only); Premium $30
Heavy usePro from $100 ($100, $200 or $500)Max $100 (5x Pro); Ultra $200 (10x Pro per week)Pro+ $39 ($70 in credits); Max $100 ($200)Super $100 (15x Plus); Ultra $200 (50x Plus)
TeamBusiness $20 per user with annual billing, $25 monthlyTeam standard $20 annual, $25 monthly; Premium $100 annual, $125 monthlyNot read (plans for organizations)Teams from $30 per user

Three caveats matter more than the table. The first: the usage units are not comparable. Codex measures in local messages every five hours and in credits per million tokens (part 5); Copilot in "GitHub AI Credits", where one credit is worth one cent of a dollar (Pro: 10 dollars base plus 5 of flexible quota; Pro+: 39 plus 31; Max: 100 plus 100, with the note that flexible quotas may change); Cursor in multiples of Plus usage, with an allocation that renews every week; Claude in multiples of Pro usage, per five hours and per week (on Ultra there is no five-hour limit, for verified accounts). That four products have a 100-dollar tier does not say they offer the same amount of work.

The second: quotas do not pay for everything. The Cursor page says that third-party models are not in the subscription price and are paid separately at the API list price; the Copilot one lists delegation to third-party agents (among them Claude and Codex, in preview) among the features included in Pro+ and Max, while the Pro plan card, on the same page, reports access to third-party agents: two points that do not coincide, to be clarified at the time of purchase. The third: pages change and sometimes surprise. The Cursor one I read mixes editor features and features of a social network in the same table, and sells the subscription through another company; this is the literal reading I report, not a judgment, and before deciding it must be reopened.

The following script computes, for each vendor, the only ratio its page allows, with the data from the table. For Copilot it is the value of credits per dollar paid, for Cursor the dollars per Plus unit, for Claude the dollars per Pro unit. It uses exact fractions and makes clear, in its last line, that a ranking across vendors cannot be computed. It calls no tool and no network: it is data copied from the pages and arithmetic.

# Prices and usage units, as the vendors' pages declared them on 13 November 2026.
# Each vendor measures usage with a different unit: the script computes, for each one, the only
# ratio its page allows, and refuses to rank them.
from fractions import Fraction as F

# Copilot: total monthly credits in dollars (1 credit = $0.01), plan price
copilot = {"Pro": (10, 15), "Pro+": (39, 70), "Max": (100, 200)}
# Cursor: price, usage multiple relative to Plus
cursor = {"Plus": (8, 1), "Premium": (30, 4), "Super": (100, 15), "Ultra": (200, 50)}
# Claude: monthly price, multiple of Pro usage
claude = {"Pro": (20, 1), "Max": (100, 5), "Ultra": (200, 10)}

def line(name, value, unit):
    print(f"  {name:8s} {float(value):6.2f} {unit}")

print("Copilot: value of the included credits per subscription dollar")
for plan, (price, credits_usd) in copilot.items():
    line(plan, F(credits_usd, price), "$ of credits per $ paid")
print("Cursor: dollars per Plus usage unit")
for plan, (price, multiple) in cursor.items():
    line(plan, F(price, multiple), "$ per Plus unit")
print("Claude: monthly dollars per Pro usage unit")
for plan, (price, multiple) in claude.items():
    line(plan, F(price, multiple), "$ per Pro unit")
print("Claude Pro, year versus month:", 20 * 12 - 200, "$ saved out of", 20 * 12)
print("Codex: the page gives messages every five hours and credits per token, no multiple of a base plan")
print("Ranking across vendors: not computable, the units are not the same thing")

# Output:
# Copilot: value of the included credits per subscription dollar
#   Pro        1.50 $ of credits per $ paid
#   Pro+       1.79 $ of credits per $ paid
#   Max        2.00 $ of credits per $ paid
# Cursor: dollars per Plus usage unit
#   Plus       8.00 $ per Plus unit
#   Premium    7.50 $ per Plus unit
#   Super      6.67 $ per Plus unit
#   Ultra      4.00 $ per Plus unit
# Claude: monthly dollars per Pro usage unit
#   Pro       20.00 $ per Pro unit
#   Max       20.00 $ per Pro unit
#   Ultra     20.00 $ per Pro unit
# Claude Pro, year versus month: 40 $ saved out of 240
# Codex: the page gives messages every five hours and credits per token, no multiple of a base plan
# Ranking across vendors: not computable, the units are not the same thing

The result reads only within each family of numbers. On the Cursor side the price per unit falls from 8 to 4 dollars as you move up a plan, because the multiples grow more than the price; on the Claude side it stays fixed at 20 dollars, so moving up a plan buys more usage at the same unit cost and not a discount; on the Copilot side the flexible part of the credits is the item that the vendor declares variable. They are three different structures, and comparing "1.5" with "7.5" with "20" is meaningless: the unit changes. For Codex there is no ratio computable from the page alone, because the messages per window are estimated ranges and not a multiple of a base plan. The only reason a plan is worth it, in each family, is that you saturate the included quota.

Where each has a structural advantage

  • Codex: many surfaces with a single agent, explicit permissions (sandbox and approvals), a CLI under the Apache-2.0 license, an alternative model provider with a compatible endpoint. Downside: the cloud requires ChatGPT sign-in, not an API key alone.
  • Claude Code: included in the Pro, Max, Ultra and Team plans, with rule-based permissions that you version in the repository and hooks with your own scripts (I wrote about it here). Downside: no free plan with Claude Code and a single model vendor.
  • GitHub Copilot: the closest to where the code lives (editor, CLI, github.com), with an agent that turns a task into a pull request and models from several vendors. Downside: credit-based consumption, and delegation to third-party agents tied to the plan.
  • Cursor: the editor built around agents, with a CLI and cloud agents from Premium upward. Downside: third-party models paid separately, entry plan limited to Grok models.

The four items are not ranked: they are four answers to the question "where do you already work?". Whoever lives in the terminal and has a ChatGPT subscription starts from Codex, whoever already has Claude from Claude Code, whoever works on GitHub from Copilot, whoever wants the center of gravity in the editor from Cursor. The cost of switching is lower than it seems because, as seen, the instruction file is shareable. I have written in the past about Cursor, Copilot and the workflow with Claude Code: those guides describe the state at the time they were written, and for prices what you read above applies.

The test that is worth more than this article

An honest comparison is written by no blog: you do it yourself, in an afternoon per tool.

  1. Choose three tasks already solved in your repository: a small one (adding a test), a medium one (a fix touching three files), an ambiguous one (finding the cause of a malfunction).
  2. For each one write a prompt with goal, context, constraints and a criterion of "done" (part 2) and use the same text in all the tools.
  3. Start from the commit before the solution, with the same cautious permission setting.
  4. Note the time to green test, the corrections you had to ask for, the diff lines discarded and the quota consumed.
  5. Repeat the trial after a month: models change and the results with them.

The order of the steps is not arbitrary: tasks are chosen before the prompt, because the criterion of "done" must be a test that already exists, and the numbers are noted during the trial, not after. To keep the numbers in order I wrote a script that summarizes a CSV file in one row per tool, with the medians. The prove.csv file below contains invented numbers, only to show the format: they are not measurements of any tool, and the tools are called A and B on purpose. The script warns if the tools do not have the same number of tasks, because a median over different sets cannot be compared.

tool,task,minutes_to_green_test,corrections_requested,diff_lines_discarded,quota_used_percent
A,small,6,0,0,1
A,medium,25,2,14,4
A,ambiguous,70,5,40,12
B,small,9,1,3,1
B,medium,22,1,6,3
B,ambiguous,95,4,22,9

Each row is a trial: the tool, the task and the four numbers to note while you work, which are the criteria of the test described above. The script that follows groups the rows by tool and computes the medians with statistics.median.

# Summarizes the trials run on YOUR tasks: one row per tool.
# The prove.csv file below contains INVENTED numbers to show the format:
# they are not measurements of any tool.
import csv
from statistics import median

COLUMNS = {"minutes_to_green_test": "minutes", "corrections_requested": "corrections",
           "diff_lines_discarded": "lines_discarded", "quota_used_percent": "quota_%"}

with open("prove.csv", newline="", encoding="utf-8") as f:
    rows = list(csv.DictReader(f))

print("tool       tasks  " + "  ".join(f"{e:>15s}" for e in COLUMNS.values()))
for tool in sorted({r["tool"] for r in rows}):
    its = [r for r in rows if r["tool"] == tool]
    medians = [median(float(r[c]) for r in its) for c in COLUMNS]
    print(f"{tool:9s}  {len(its):5d}  " + "  ".join(f"{m:15.1f}" for m in medians))

if len({sum(1 for r in rows if r["tool"] == s) for s in {r["tool"] for r in rows}}) > 1:
    print("WARNING: the tools do not have the same number of tasks")
print("With three tasks the median is the middle value: look at the single tasks too.")

# Output:
# tool       tasks          minutes      corrections  lines_discarded          quota_%
# A              3             25.0              2.0             14.0              4.0
# B              3             22.0              1.0              6.0              3.0
# With three tasks the median is the middle value: look at the single tasks too.

With three tasks per tool the median is the middle value: look at the single tasks too, and tell the ambiguous task apart from the other two. A table of twelve rows (three tasks for four tools) on your code is worth more to you than a generic ranking, and shows you what really weighs, including how well the instruction file describes your project (part 4).

The most common mistakes in choosing

  • Choosing by someone else's benchmark: it measures tasks that are not yours.
  • Comparing list prices without your volume: the 100-dollar plan pays off only if you saturate it.
  • Taking an annual subscription before the test: the saving (Claude Pro: 40 dollars out of 240 a year, according to the script) vanishes if you change tool in March.
  • Thinking it is an exclusive choice: you can use one tool in the editor and another from the terminal, with a single instruction file.

The common thread is the hidden cost: each of these mistakes shifts the decision from your code to a number that sits elsewhere. Avoiding them costs an afternoon per tool.

What you can do now

With this part the series is closed. You can say what Codex is and where it runs, install it and launch a first task, choose how far to trust the agent with sandbox and approvals, give it stable rules with AGENTS.md and config.toml, choose model and reasoning knowing what they cost, put it in CI without handing it the key, decide what to delegate to cloud, subagents, skills and MCP, and compare it with the other three on tasks of your own. The eight articles, in the order in which it is worth reading them:

  1. OpenAI Codex today: what it is and what it costs
  2. Codex CLI: install and first task, step by step
  3. Codex sandbox and approvals: how far to trust the agent
  4. Codex AGENTS.md and config.toml: give it stable rules
  5. Codex: which model and how much reasoning to pick
  6. Codex exec and SDK: the agent in CI, safely
  7. Codex: cloud, subagents, skills and MCP to delegate
  8. This article: the comparison with Claude Code, Copilot and Cursor.

The order follows the dependency among the topics: permissions come before rules, rules before automation, automation before delegation, and the comparison last because only then do you have the elements to measure. If you start from zero, the first three parts are enough to work with caution; the others you read when the problem calls for them. Prices and model names are the part that ages first: reopen the pages cited in the sources before every purchase decision.

Frequently asked questions

Which is best among Codex, Claude Code, Copilot and Cursor?

None in absolute terms: it depends on the task, on where you work and on your volume of use. The reliable method is to try the same three real tasks, with the same prompt, on each tool and compare time, corrections requested and quota consumed.

Are the prices of the four tools comparable?

Only in part: the usage units differ (messages every five hours, credits, multiples of a base plan). That four products have a 100-dollar tier per month does not mean they offer the same amount of work.

What is not demonstrated here

No claim of quality: I have not compared the four tools on a task. I have not read in detail the permissions of Copilot and Cursor nor the Copilot plans for organizations, and I have not verified the real quotas of any plan. The rows on extensions say that the pages exist, not that the features are equivalent. The data of the two scripts are copied from the vendors' pages, and price pages change constantly: the reading is from 13 November 2026 and must be redone before a purchase decision.

Sources

The pages were downloaded in full and read at the passages cited. The two scripts were run with Python 3.14 (python3 -I), twice each, with identical output; the first was confirmed with a second floating-point calculation.

← Part 7: cloud, subagents, skills and MCP Back to part 1: the product map →

Commenti

Caricamento commenti...

Sign in to comment

New articles and tools on Telegram too

The Telegram channel flags the site's new articles and tools.

Did you like this article?

Explore other content on the blog or discover my projects