Claude Code vs Cursor vs GitHub Copilot vs OpenAI Codex (2026): Which AI Coding Tool Should You Pay For?

Four changes affect what you’ll pay.

Cursor changed owners and pricing. Cursor confirmed its acquisition by SpaceX in August. In October, SpaceX’s AI business introduced The X Subscription, combining Grok, Grok Bot, Cursor, and X benefits. New customers can no longer buy Cursor’s old $20 Pro plan. Claude, GPT, and Gemini models are no longer included in any plan allowance; they’re billed at API list price from prepaid credit. Existing Cursor subscribers can keep their legacy plans.

GitHub Copilot moved to AI Credits. On June 1, GitHub replaced premium requests with GitHub AI Credits, where one credit equals $0.01 and metered interactions are priced using input, output, and cached tokens. Plan prices didn’t change, but what the price buys now depends on which models you use and how much agent work you run. GitHub also added a $100 Copilot Max plan.

Codex combines subscription allowances with optional credit-based usage. Codex is included in eligible ChatGPT plans, while API-key access is billed separately. The official Codex pricing documentation explains token-priced credits for additional usage. ChatGPT Pro now offers $100, $200, and $500 monthly tiers; OpenAI also updated the Work and Codex allowances on those tiers in late October.

Claude revised its higher-end plans. Anthropic now lists Max ($100) and Ultra ($200). Claude’s pricing page says Ultra has no five-hour limit for verified accounts, but retains a weekly allowance of 10x Pro usage. It also includes $200 a month in Claude Platform API credits—not credits for extra Claude Code subscription sessions.

Heavy agent usage changes the calculation: some plans pause at limits, while others permit paid overages.

These four tools started from opposite ends of the same problem.

Editor-first tools (GitHub Copilot and Cursor) began inside the code editor. You write code, and the AI suggests the next line, answers questions in a side panel, or edits the files you point it at. You stay in control of every keystroke, and the AI’s work arrives in small pieces you can read as it appears.

Agent-first tools (Claude Code and Codex) start with delegation. You describe a task, and the agent can examine the repository, plan a change, edit several files, and run tests. You may still need to approve commands or access requests during execution, then inspect the final diff before merging. Delegation does not mean giving up supervision.

EDITOR-FIRST                                AGENT-FIRST

You type code                               You describe a task.
   |                                           |
AI suggests next line or block              Agent reads the repository
   |                                           |
You accept, edit, or reject                  Agent plans the change
   |                                           |
You ask chat about a specific file          Agent edits several files
   |                                           |
AI edits that file on request               Agent runs tests and commands
   |                                           |
You commit                                  You review the diff, then commit

In November 2026, the line is blurry. Copilot now has a cloud agent, a CLI, and a desktop app. Cursor has an agent mode, cloud agents, and a CLI. Claude Code runs in the terminal, IDEs, a desktop app, and the browser. Codex works in the ChatGPT desktop app, a CLI, an IDE extension, and the cloud.

So the useful question is no longer "which category is it in?" but "what does the tool assume you’ll do by default?" Copilot and Cursor still open in an editor and assume you’re writing code. Claude Code and Codex assume you’ll hand off work and come back to review it. That default shapes the experience more than any feature list.

It also shapes cost. A completion is a small request. An agent session can send your repository’s context to the model dozens of times. GitHub’s own billing documentation notes that a long cloud agent session on a frontier model across multiple files will cost more than a quick chat question, because it does more work.

Workflow and features

Pricing and metering

Enterprise and data controls

A typical Claude Code session starts in a terminal at the root of your project. You describe what you want in plain language: fix a failing test, add an endpoint, refactor a module. Claude Code reads the relevant files, proposes a plan, makes edits across as many files as the task needs, and runs commands such as your test suite to check its work. Claude Code also runs in IDE extensions and a desktop app, and cloud sessions run on hosted infrastructure that can continue after you close your laptop. Its design assumes you’re delegating.

Control comes from permissions. Anthropic’s security documentation states that Claude Code only has the permissions you grant, and that you’re responsible for reviewing proposed code and commands before approving them. Administrators can enforce settings through managed policies, restrict commands, and sandbox shell commands. That makes it workable in regulated environments, but only if someone configures it.

Claude Code runs Anthropic’s models only. On Anthropic’s API price list, Opus 5.5 costs $4 per million input tokens and $20 per million output; Sonnet 5.5 costs $2 and $10; Haiku 5.5 starts at $0.10 and $0.50 on the base tier. You can’t swap in GPT or Gemini.

Pricing

Claude Code isn’t sold separately. It’s included in every paid Claude plan, and your terminal work draws from the same usage pool as your chats.

• Pro costs $20 a month, or $17 a month billed annually.
• Max costs $100 a month and gives 5x Pro usage per five-hour window and per week.
• Ultra costs $200 a month, gives 10x Pro weekly usage, and has no five-hour limit for verified accounts.
• Max and Ultra include $100 and $200 in monthly Claude Platform API credits respectively, and have access to the Fable model under published usage conditions.

Important distinction: Claude Platform API credits can be used to build applications with the API, Claude Agent SDK, and related services. They do not pay for Claude Code subscription sessions or extra usage inside Claude apps. When a Claude Code subscription limit is reached, you can wait, upgrade, or buy eligible extra usage separately. Developers can also choose API-based Claude Code billing rather than a consumer subscription.

Strengths

Long, multi-step tasks are what it’s designed for. Ultra’s removal of the five-hour cap targets exactly the developer who runs agents for hours. Bundling Claude chat and Claude Code can be economical if you already use both; Claude Platform API credits are a separate benefit for developers building with the API.

Limitations

Anthropic doesn’t publish token figures for plan limits, so you can’t predict precisely when you’ll hit a cap. You’re locked to one model family. The free plan doesn’t include Claude Code. And there’s no inline autocomplete, so many developers still pair it with an editor-based tool.

Who should pay for it: developers who prefer Claude models and want to delegate multi-step work. Start on Pro and monitor real limits before committing to Max or Ultra.

Cursor is a code editor built around AI. You get Tab completions as you type, a chat panel, and an Agent that can make multi-file changes, all inside one application. Paid tiers add Cloud Agents that work in the background, Automations, a code-review bot called Bugbot, and Origin, Cursor’s new Git hosting product.

The big change is commercial, not technical. Cursor is now part of SpaceX, and new customers buy it through The X Subscription. Every paid tier includes a weekly pool of usage for Cursor’s own models (Grok 4.7, 4.6, 4.5 and Composer 2.5). That pool is shared with the Grok chat apps and Grok Bot, so heavy Grok use outside the editor reduces what’s left for coding.

Pricing

Source: Cursor Models & Pricing. Prices exclude tax.

Plus is narrower than its price suggests. It excludes Auto mode, Cloud Agents, Automations, Bugbot, Origin, third-party models, and your own API keys. Most developers comparing Cursor with the other three should treat Premium at $30 as the real entry point.

Third-party models bill from the first request at each provider’s list price. In Cursor, Claude Opus 5.5 costs the same $4 input and $20 output per million tokens as Anthropic charges directly. On Teams and Enterprise, eligible third-party requests also carry a Cursor Token Rate of $0.25 per million tokens, including when you bring your own key.

Legacy plans

If you subscribed before October 12, your plan keeps working. Cursor’s legacy plan page lists Pro at $20, Pro+ at $60, and Ultra at $200, with an included allowance for third-party models. Switching to The X Subscription is optional, but Cursor’s help center says the switch is permanent once made.

Strengths

The editor experience is polished, and Cursor’s own models get far more included usage per dollar than before. xAI says each new tier includes at least twice the coding usage with Grok models of the plan it replaces. Team seats are now cheaper than before ($30 versus $40).

Limitations

Cursor stood out for model choice, but its new pricing leans heavily toward Grok. Claude and GPT usage is tracked separately. The published usage multiples are relative to Plus, without a fixed public token allowance; enterprises should also account for the ownership change when reviewing the vendor.

Who benefits most: developers who want an AI-native editor and are happy using Grok and Composer as their main models, or legacy subscribers who can stay on their existing plan.

Copilot runs in familiar developer environments, including VS Code, Visual Studio, JetBrains IDEs, Xcode, Eclipse, and GitHub.com. You get inline completions and next-edit suggestions while typing, chat and an agent mode in the IDE, a CLI, a desktop app, and a cloud agent you can assign GitHub issues to. Copilot code review comments on pull requests.

Copilot has a broad model menu. Its model-pricing documentation lists options from OpenAI, Anthropic, Google, xAI, Microsoft, and others. You can choose an eligible model or use Copilot Fusion, which can route a task through one or several models. Paid-plan Fusion model costs are discounted 30% through November 30, 2026. GitHub still charges for each model Fusion uses so multi-model tasks may consume more credits than single-model tasks despite the discount.

Pricing

Sources: individual billing, organization billing.

On paid plans, completions and next-edit suggestions are unlimited and do not count against AI credits. If you mostly use autocomplete, Pro can cost just $10 a month. The flex allotment can change: base credits are fixed, but GitHub can adjust the extra allowance. For long-term budgeting, do not assume the flex portion will remain the same.

Credits reset at midnight UTC on the first of each month and don’t carry over.

How the meter works: a worked example

Credits are calculated from each model’s token rates. Claude Sonnet 5.5 in Copilot costs $2 per million input tokens and $10 per million output tokens. Suppose an agent task sends 2 million uncached input tokens and receives 200,000 output tokens. These are round numbers for illustration, not a typical session.

• Input: 2 × $2 = $4.00
• Output: 0.2 × $10 = $2.00
• Total: $6.00, or 600 AI credits

On Pro, that task uses 40% of the monthly 1,500 credits; caching could lower the cost. To illustrate overages, suppose each hypothetical task consumed $6 in Copilot credits. Using a $10 Pro subscription with $15 of included monthly credit value gives:

Illustrative arithmetic only. These are not typical task counts or observed usage. If additional spending is disabled, tasks stop consuming paid credits after the allowance is exhausted; the bill does not automatically rise.

Strengths

An affordable $10 entry plan with unlimited, unmetered completions and native GitHub integration. Business and Enterprise add organization policies, content exclusion, and conditional IP indemnification for qualifying unmodified suggestions when the duplicate detection filter is set to Block.

Limitations

Agent-heavy work on frontier models can burn through credits quickly at lower tiers. On Business and Enterprise, extra paid usage is enabled by default once the pooled credits are gone; administrators must turn off the policy to cap spend. Copilot code review consumes both AI credits and GitHub Actions minutes. GitHub paused new sign-ups in April and began reopening individual plans in June; its docs still note a pause on self-serve Business sign-ups for organizations on GitHub Free and Team plans, so check availability.

Who should subscribe: almost anyone who writes code in a supported IDE, as a baseline tool. Teams on GitHub should evaluate Business before anything else.

Codex is OpenAI’s coding agent, and it’s part of ChatGPT rather than a separate subscription. You can run it in the ChatGPT desktop app, on the web, on mobile, in the Codex CLI, through an IDE extension, and in Codex Cloud, where tasks run in a cloud environment while you do something else. It can review pull requests on GitHub when you tag @Codex, and it integrates with Slack and Linear.

The working model is delegation. You give Codex a task, it works in a sandbox with the permissions you’ve configured, and it returns changes for review. Repository instructions live in an AGENTS.md file, and the docs recommend keeping that file lean because everything in it is sent with each message.

Codex runs OpenAI models only. Eligible ChatGPT tiers currently expose GPT-6 Luna, GPT-6.1 Sol, and other supported models, including GPT-6 Astra on qualifying plans and settings. Model availability depends on plan, surface, and rollout; API-key users can select models available to their API account.

Pricing

According to OpenAI’s Codex pricing page:

Usage limits depend on the model and task. OpenAI’s own estimates for Plus range from 15 to 160 local messages per five hours on GPT-6.1 Sol, and 350 to 3,000 on GPT-6 Luna. Pro plans currently have no five-hour limit, though weekly limits may still apply. ChatGPT Work and Codex share the same allowance, so heavy use of one reduces the other.

When you hit a limit, eligible Plus and Pro users can buy ChatGPT credits instead of upgrading. OpenAI’s credit rate card lists GPT-6.1 Sol at 50 credits per million input tokens and 250 per million output tokens at standard speed. These are credits, not US dollars. Fast mode draws included usage 2.5 times faster; actual dollars spent depend on how credits are purchased.

Strengths

If you already pay $20 for ChatGPT Plus, you already have Codex. Access across desktop, CLI, IDE, and cloud from one subscription is convenient, and Pro’s lack of a five-hour cap suits long sessions.

Limitations

Dollar prices for ChatGPT credit packs vary by plan, which makes overage costs harder to estimate than Copilot’s. Plan names, limits, and multipliers have changed several times this year. API-key usage loses cloud features entirely. And you’re limited to OpenAI’s models.

Who should choose it: ChatGPT subscribers and developers who want one agent across desktop, terminal, and cloud. Teams standardizing on ChatGPT Business should check their seat entitlements and shared usage caps rather than assuming unlimited coding activity.

To make the differences concrete, here’s how a developer might approach the same task with each tool. This is an illustrative workflow, not a benchmark. We did not run these tasks and make no claims about speed, quality, or token use.

The scenario: a small business sells cookies online through a Next.js store with Stripe already connected. The owner wants digital gift cards. A customer picks a value and pays; the recipient gets a code by email; the code works at checkout; the same code can’t be redeemed twice; and the change includes basic automated tests.

With Claude Code, the developer can open a terminal in the project and write a full brief: "Add gift cards. Customers choose $25, $50, or $100, pay through our existing Stripe checkout, and the recipient receives a unique code by email. Codes apply at checkout and can only be redeemed once. Add tests for issuing, redeeming, and double-redemption." Claude Code reads the checkout code, proposes a plan (data model, API routes, email template, checkout changes, tests), and asks for approval before running commands. The developer reviews the plan, approves, then reads the diff and runs the tests. Remaining manual work: Stripe webhook configuration in the dashboard, email provider credentials, and a hard look at the redemption logic under concurrent requests.

With Cursor, the developer stays in the editor. They might ask the Agent for the same feature, then step through each changed file in the diff view, using Tab completions to adjust code by hand. A more hands-on approach is to build it in pieces: ask chat to design the schema, write the redemption function with completions, then ask the Agent to generate tests. If the team wants Claude for this task on a new plan, that usage bills from prepaid credit. Remaining manual work is the same as above.

With GitHub Copilot, the developer can open an issue on GitHub and, on an eligible plan, assign it to the Copilot cloud agent to propose changes in a pull request. Or they can work in VS Code with agent mode. Either way, the review happens where the team already reviews code: in a pull request, with Copilot code review able to comment. Remaining manual work: the same configuration steps, plus confirming the agent’s tests cover double redemption.

With Codex, the developer might start a cloud task in the ChatGPT app with the same brief, let it run while they handle something else, then pull the branch and review locally. Or run it in the CLI against the local repository with approvals on. An AGENTS.md file describing the project’s test command and conventions saves repeating that context. Remaining manual work: as above.

The lesson across all four: an AI assistant may draft much of the implementation, but a developer still has to configure payment services, protect secrets, check the money-handling logic, and verify tests—including concurrent redemptions. For a payments feature, that review is essential.

No vendor publishes a reliable token count for a "typical" developer, and the plans measure limits differently. A useful starting point is the fixed subscription charge, followed by a clear account of what triggers extra cost or a service pause. The examples below are pricing illustrations, not usage measurements or hands-on benchmarks.

Scenario 1: Weekend hobbyist (5 to 8 hours a week)

For occasional coding, Copilot Pro at $10 is an inexpensive option with a clearly published credit allowance. Cursor Plus is listed at $8 but only includes its own supported models. If you already pay for ChatGPT Plus or Claude Pro, try the included coding agent before purchasing another subscription.

Scenario 2: Full-time solo developer (about 40 hours a week)

Claude and ChatGPT subscriptions provide an allowance that is not usually expressed as a simple public token balance. Copilot publishes the dollar-equivalent value of included AI Credits. Cursor offers a weekly shared pool for its own models and bills third-party models separately. Start on the lowest adequate tier and check usage for two weeks before upgrading; a fixed-price plan is predictable only if you disable or avoid paid overages.

Scenario 3: Ten-person development team

Claude Enterprise usually needs at least 20 seats, so in this ten-person example, Claude Team is used instead. Team gives you a shared API credit pool with a $500 monthly cap, but these credits don’t cover Claude Code subscription usage. Copilot Enterprise also requires GitHub Enterprise Cloud, which adds another cost not included here.

What makes team bills grow:

• Copilot Business and Enterprise allow paid usage beyond the pool by default. One developer running long agent sessions can draw down credits other people would have used, and then the organization pays per credit.
• Cursor Teams charge third-party models at list price plus a $0.25-per-million-token Cursor Token Rate for eligible requests. For 2.2 million chargeable tokens, that fee alone would be $0.55; exemptions and token categories can affect the real bill.
• Claude and ChatGPT seats that run out of allowance either wait or buy credits, depending on admin settings.

The economics of agents versus completions

Inline completions are usually lightweight, and Copilot does not charge paid users’ AI Credits for them. Agents can consume much more because they repeatedly read files, use tools, and send context to models. Even chat-only users can incur metered usage, so the subscription price should be treated as a baseline rather than a guarantee. Before buying ten seats, run a short, permission-controlled pilot with a few representative users and compare the usage dashboards.

When these tools use hosted AI models, relevant code and context may be transmitted to a provider. What differs is how much is shared, retention, training, access controls, and contractual protection.

Sources: Claude Code data usage, Claude pricing, Cursor privacy and data governance, Cursor data use, GitHub Copilot personal-plan training controls, OpenAI data controls, Codex pricing and plan features.

A few points deserve emphasis.

Personal plans on company repositories create governance gaps. GitHub’s policy permits training on eligible individual-plan interactions unless a user opts out, including Copilot Max; OpenAI’s personal-plan controls also govern Codex tasks, and Claude consumer plans have their own setting. A company policy is not effective if staff bypass its managed workspace. Verify account enforcement, data controls, and repository permissions before rollout.

Cursor’s privacy protections depend on how you set it up and which model you use. Privacy Mode, according to the documentation, blocks training on customer code, and Cloud Agents only keep encrypted repository copies temporarily to do their work. Most models don’t keep your data, but some require provider-side retention. BYOK and residency settings can also change the rules, so always check the details for each model and feature before making claims about privacy for your organization.

Agents can do much more than generate code. With shell access, an agent is able to run commands, install packages, and read files beyond the current task. Before rolling out agents, set clear rules for what commands are allowed and enable sandboxing. Always treat anything in repository files, issues, or web pages as potentially untrusted input, since agents may follow those instructions.

When you use third-party models, your code might be shared with more organizations. For example, in Cursor and Copilot, picking Claude or Gemini means your code is sent to those providers and to the main tool vendor. Always review each vendor’s subprocessor list so you know exactly who might handle your data.

IP indemnity isn’t a simple yes-or-no question. GitHub offers protections for Copilot Business and Enterprise, but these only apply if you meet certain conditions. Anthropic and OpenAI also include conditional indemnification in their terms for specific customers or outputs. Whether those protections cover your coding workflow, modified output, or third-party components depends on the contract and its exclusions. Make sure your legal team reviews the actual terms, not just the marketing summaries.

Checklist before approving an AI coding tool

1. Which plan tier will developers actually use, and can you block personal accounts on company devices?
2. Is training on your code off by default for that tier, and can admins enforce it?
3. What is the retention period, and is zero retention available?
4. Which features store code server-side (cloud agents, indexing)?
5. Which model providers will receive code, and are they on the vendor’s subprocessor list?
6. Can admins restrict agent commands, network access, and MCP servers?
7. Do SSO, SCIM, and audit logs come with the tier you’re buying?
8. Is paid overage on by default, and who can change it?
9. What do the contract terms say about IP indemnity and data processing?
10. For Cursor specifically, has your vendor review accounted for the change of ownership?

Often, yes. The most common pairing makes sense because the tools do different jobs.

GitHub Copilot + Claude Code is a useful pairing to evaluate. Copilot Pro at $10 handles completions, which aren’t metered. Claude Code handles delegated tasks from the terminal. Total: $30 a month. The only overlap is chat, and you can ignore one of them.

GitHub Copilot + Codex works the same way, and costs nothing extra beyond Copilot if you already pay for ChatGPT Plus.

Cursor + Claude Code made more sense when Cursor’s $20 Pro plan included Claude usage. On new plans, Claude inside Cursor uses separately purchased credits. Depending on your task volume, a standalone Claude Code subscription plus Cursor’s included Grok and Composer models could be easier to budget, but compare the total rather than assuming one combination always costs less. Legacy Pro subscribers have less reason to change anything.

Cursor + Codex follows the same logic: Cursor for editing with its own models, Codex for delegated tasks through ChatGPT.

When is one tool enough? If you rarely delegate whole tasks, Copilot or Cursor alone covers you. If you mostly delegate and rarely write code by hand, one agent tool is enough. Paying for two agent tools (Claude Code and Codex) mostly makes sense if you want to compare models on your own codebase, and even then a month of overlap is usually enough to decide.

Devin Desktop (formerly Windsurf). Cognition renamed Windsurf to Devin Desktop on June 2, 2026, repositioning the editor as a command center for managing multiple coding agents. If you’re searching for Windsurf, this is where it went.

Grok Build. xAI’s terminal coding agent, listed on xAI’s site. It’s a separate product from Cursor but sold by the same company, and The X Subscription’s free tier includes daily access to Grok Build. Worth a look if you already pay for The X Subscription.

Gemini CLI and Antigravity CLI. Google ended consumer sign-in access to Gemini Code Assist extensions and Gemini CLI on June 18, 2026, and points individual users toward Antigravity. Gemini CLI itself continues to receive releases and remains relevant for supported enterprise and API-key use. Check the authentication method, rather than assuming the CLI has disappeared.

Cline. An open-source coding agent for VS Code with human approval at each step. The extension is free; you bring your own API key and pay the model provider directly. It gives you the most control over model choice and cost, at the price of more setup and no flat-rate ceiling.

These are editorial judgments based on the verified features and prices above.

Best for beginners: GitHub Copilot Pro ($10). Inline suggestions are easy to inspect, and completions are unmetered on paid plans. Start on Free if you do not need the paid allowance.

Best for everyday coding assistance: GitHub Copilot. For most developers, unmetered completions plus a clear dollar-denominated allowance is the best value per month. Cursor is the alternative if you prefer an AI-native editor and are comfortable with Grok as the default model.

Best for agent-heavy development: Claude Code or Codex. Both prioritize delegation and offer higher tiers without a five-hour limit under stated conditions; weekly limits can remain. Compare real usage on a $20 plan before committing $100 or more.

Best for GitHub-centric teams: GitHub Copilot Business ($19/user). It is a competitively priced baseline with native GitHub workflows and conditional IP protections, but compare actual agent usage and your enterprise requirements. Turn off default paid overage until you understand usage. Teams standardized on Claude or ChatGPT should look at Claude Team or ChatGPT Business instead, since those seats include chat as well.

Best for enterprises: the tool that passes your technical and contractual assessment. An existing vendor agreement is useful, but not decisive. Compare SSO/SCIM, audit logging, managed agent permissions, data retention, subprocessors, usage controls, indemnity, and where code is executed before standardizing.

Best low-cost choice: GitHub Copilot Pro ($10) for a conventional IDE workflow, or Cursor Plus ($8) if Cursor’s included models and feature limits are enough. Copilot Free is also worth trying before paying.

Best if you already have an eligible subscription: use what you pay for. ChatGPT Plus includes Codex. Claude Pro includes Claude Code. The X Subscription includes Cursor. Upgrade only when you regularly hit limits.

Is Claude Code free in 2026?

No. Claude’s Free plan doesn’t include Claude Code. The cheapest way to get it is Claude Pro at $20 a month, or $17 a month billed annually. Max ($100) and Ultra ($200) give more usage. Team and Enterprise plans also include it. Developers who prefer paying per use can run Claude Code with API billing through a Console account instead of a subscription, paying Anthropic’s standard token rates.

Does Codex cost extra if I already pay for ChatGPT?

No. Codex is included with ChatGPT Free, Go, Plus, Pro, Business, Edu, and Enterprise plans, with different limits on each. Plus at $20 includes Codex on the web, in the CLI, in the IDE extension, and on iOS, plus cloud code review. You only pay more if you buy ChatGPT credits after reaching your limits, or if you choose to run Codex with an API key, which bills separately at OpenAI’s API rates.

What happened to Cursor’s $20 Pro plan?

It’s no longer sold to new customers. Since October 12, 2026, new Cursor customers buy through The X Subscription, where the closest equivalent is Premium at $30 a month. Unlike the old Pro plan, Premium doesn’t include an allowance for Claude, GPT, or Gemini; those models bill at API list price from prepaid credit. If you already had Pro, you can keep it at $20, and switching is optional.

Can I use Claude models inside Cursor or GitHub Copilot?

Yes, in both, with conditions. In Cursor, Claude models are available on Premium and higher plans at Anthropic’s list price, paid from prepaid credit; they aren’t available on Free or Plus. Legacy Cursor plans include an allowance for third-party models. In Copilot, Claude models appear in the model picker on paid plans and draw from your monthly AI credits at per-token rates. Copilot Free and Student use auto model selection only.

Which AI coding assistant is cheapest for heavy agent usage?

It depends on whether you value a fixed bill or a known allowance. Claude Ultra ($200) and eligible ChatGPT Pro tiers currently remove the five-hour limit but may still impose weekly caps, with additional usage purchased separately when supported. Copilot Max publishes a $200 credit allowance for $100, with extra charges only if budget settings permit. Cursor can be economical for its included Grok and Composer pool, but without an independently measured workload there is no defensible universal "cheapest" option.

Do Claude Code, Cursor, Copilot, or Codex train on my source code?

Exactly how your code is protected depends on both the product and your contract. By default, Claude Team/Enterprise, Copilot Business/Enterprise, and ChatGPT Business or higher plans don’t use business content for model training. Cursor uses Privacy Mode to keep your code private, though some cloud sessions and models might keep data longer. For individual plans, it’s important to check your opt-out settings: GitHub includes Free, Pro, Pro+, and Max in its training policy, while personal ChatGPT/Codex and Claude accounts have their own privacy controls. Always double-check the settings for your account to be sure.

Can I use GitHub Copilot and Claude Code together?

Yes, and it’s a sensible combination. Copilot handles inline completions in your editor, which aren’t metered on paid plans, while Claude Code handles larger tasks you delegate from the terminal. Copilot Pro plus Claude Pro costs $30 a month. Keep in mind they bill separately, and Copilot’s agent features also draw on its credits, so decide which tool handles agent work to avoid paying twice for the same thing.

Which AI coding tool is best for beginners?

GitHub Copilot, starting with the Free plan and moving to Pro at $10. It suggests code as you type, which keeps you reading and understanding each line rather than reviewing large changes you didn’t write. Agent tools like Claude Code and Codex can be useful for learning too, but they can produce multi-file changes a beginner may not be able to check. Use agents for explanation and small tasks until you’re comfortable reviewing their work.

Anthropic / Claude Code

• Claude plans and pricing.
• What is the Max plan? (Max and Ultra)
• Claude Code data usage
• Claude Code security
• Claude Code hosted cloud sessions
• Claude Platform API credits: what they do and do not cover
• Anthropic commercial terms and legal center

Cursor

• Cursor Models & Pricing
• Legacy Cursor plans
• Cursor is now part of SpaceX
• Introducing The X Subscription (xAI)
• Cursor privacy and data governance
• Cursor data use overview
• TechCrunch: SpaceX officially closes its Cursor acquisition

GitHub Copilot

• Usage-based billing for individuals
• Usage-based billing for organizations and enterprises
• Copilot seats and billing cycles
• Models and pricing for GitHub Copilot
• Copilot Fusion: model routing and 30% discount through November 30, 2026
• Flex allotments and the Max plan (GitHub Blog)
• Copilot individual plan sign-ups are reopening
• Establishing trust in using GitHub Copilot (IP indemnity)
• GitHub Copilot training settings for personal plans
• GitHub announcement about training on personal-plan interaction data

OpenAI Codex

• Codex and ChatGPT Work pricing
• Using Codex with your ChatGPT plan
• ChatGPT data controls
• OpenAI service terms
• About ChatGPT Pro plans
• OpenAI official ChatGPT Pro tier changes

Alternatives

• Windsurf is now Devin Desktop (Cognition)
• Grok Build (xAI)
• Google: Gemini Code Assist individual account transition
• Gemini CLI active release notes
• Cline