programing – Software Online Review

Cursor vs GitHub Copilot vs JetBrains AI Assistant: Best AI Coding Assistant in 2026

Posted on October 29, 2026 by Filip Keser

AI pair programming has split into two camps: standalone AI-native editors like Cursor, and AI layered onto the editor you already use, like GitHub Copilot or JetBrains AI Assistant. We already published a full standalone review of GitHub Copilot’s plans; this piece instead compares all three head-to-head so you can decide which fits your workflow, your IDE, and your budget in 2026.

At a Glance

Tool	Starting paid price	Free tier	Best for
Cursor	Pro, $20/month	Yes — Hobby plan, limited agent/chat usage	Developers who want an AI-first editor built around agentic, multi-file workflows
GitHub Copilot	Pro, $10/month	Yes — 2,000 inline suggestions/month, limited chat & agent use	Teams already standardized on GitHub who want AI woven into existing IDEs and GitHub.com
JetBrains AI Assistant	AI Pro, $20/month (JetBrains’ help docs also show a $10 price point for this tier — see note below)	Yes — AI Free, a small monthly credit allowance	Developers already living inside JetBrains IDEs (IntelliJ, PyCharm, WebStorm, Rider, etc.)

Cursor

Cursor (by Anysphere) is a standalone code editor forked from VS Code and rebuilt around AI from the ground up, rather than an extension bolted onto an existing IDE. Its core features are a codebase-aware Chat, inline Cmd+K edits, Tab-based multi-line autocomplete, and an Agent mode that can plan and execute multi-file changes, run commands, and iterate against test results with far less hand-holding than a basic autocomplete tool. Cursor also offers Cloud/background agents that work asynchronously and a Bugbot feature for automated pull-request review. It supports multiple underlying models (Anthropic, OpenAI, and Google model families among them) that you can switch between per task.

On pricing: Cursor’s published plan structure is Hobby (free, limited usage), Pro ($20/month), Pro+ ($60/month), and Ultra ($200/month) for individuals, with Teams plans starting around $40/user/month and custom Enterprise pricing. We’ll be straightforward about sourcing here: Cursor’s own pricing page did not render reliably through our research tooling during this session, so these figures are cross-checked against Cursor’s Wikipedia entry (which cites Cursor’s own site for the $20 Pro price) and independent, recently updated pricing trackers rather than a single live fetch. AI tool pricing changes often — confirm current numbers at cursor.com before buying.

GitHub Copilot

GitHub Copilot integrates into most major IDEs (VS Code, JetBrains IDEs, Visual Studio, Xcode, and more) plus a CLI, GitHub.com, and mobile. Per GitHub’s official plans page, the current lineup is Free, Pro ($10/month), Pro+ ($39/month), and Max ($100/month), each priced around a pool of “GitHub AI Credits” that cover chat and agent usage beyond unlimited inline suggestions (Free is capped at 2,000 inline suggestions/month). Business and Enterprise tiers add SAML SSO, usage metrics, IP indemnity, and org-wide user management, but GitHub’s plans page doesn’t publish their price or credit allotment — it routes that to a sales conversation. All paid tiers share the same model list and now support delegating work to third-party coding agents (Anthropic’s Claude and OpenAI’s Codex, in preview) from Pro+ and Max.

For a deeper breakdown of exactly which tier to pick as an individual developer, see our GitHub Copilot Review: Plans, AI Credits, and Which Tier a Developer Actually Needs in 2026.

JetBrains AI Assistant

JetBrains AI Assistant runs inside JetBrains’ own IDEs (IntelliJ IDEA, PyCharm, WebStorm, Rider, and the rest of the family) and is priced on a credit system rather than flat feature tiers. Per JetBrains’ official AI Assistant licensing documentation, the tiers are AI Trial (free, time-limited), AI Free (3 credits per 30 days, unavailable in Android Studio and the Community editions), AI Pro, AI Ultimate, and AI Enterprise (organizations only). One AI credit equals $1 USD, and roughly: 10 AI Chat code-generation requests, 40 editor code-generation requests, 25 code explanations, or 280 documentation requests per credit — though “expensive” models and agentic use burn through credits faster.

A transparency note: JetBrains’ own licensing page currently shows two different price/credit pairings for the same tiers — one set lists AI Pro at $10 for 10 credits and AI Ultimate at $30 for 35 credits, while another set on the same page lists AI Pro at $20 for 20 credits and AI Ultimate at $60 for 70 credits — without clarifying which is current. We’re flagging that discrepancy explicitly rather than picking one number and presenting it as settled; check JetBrains’ store page directly for the figure that applies to your account before purchasing.

How the Coding Experience Differs

All three tools can generate a working function from a comment, but the depth of “agentic” behavior differs. A simple prompt like “write a function that calculates a discounted price and rejects invalid input” produces similar completions across all three — the differentiator shows up on multi-file, multi-step tasks, where Cursor’s Agent and GitHub Copilot’s agent mode will edit several files and run tests autonomously, while JetBrains AI Assistant leans more on in-editor chat and targeted code generation inside the file you’re already in.

// Typical completion all three tools can produce from a single comment prompt
function getDiscountedPrice(price, discountPercent) {
  if (price <= 0 || discountPercent < 0 || discountPercent > 100) {
    throw new Error("Invalid input");
  }
  return price - (price * discountPercent) / 100;
}

Whichever assistant you use, treat its output as a draft, not a finished patch — our AI-Generated Code Security in 2026 guide covers the review checklist every team should run against AI-generated code before it merges.

Pricing Comparison

Tier level	Cursor	GitHub Copilot	JetBrains AI Assistant
Free	Hobby — limited agent/chat	Free — 2,000 inline suggestions/month	AI Free — 3 credits/30 days
Entry paid	Pro, ~$20/month	Pro, $10/month	AI Pro, ~$10–$20/month (see note above)
Mid paid	Pro+, ~$60/month	Pro+, $39/month	AI Ultimate, ~$30–$60/month (see note above)
Top individual	Ultra, ~$200/month	Max, $100/month	Not published beyond Ultimate
Team/Enterprise	Teams from ~$40/user/month; Enterprise custom	Business/Enterprise — priced via sales	AI Enterprise — organizations only, via sales

Pros and Cons

Cursor pros: deepest agentic, multi-file workflow; fast Tab completion; flexible model choice.
Cursor cons: another editor to adopt instead of your current one; usage-based costs beyond the included pool can add up.
GitHub Copilot pros: works inside the IDE you already use; tightest GitHub.com/PR integration; cheapest entry paid tier of the three.
GitHub Copilot cons: Business/Enterprise pricing isn’t public; credit-based usage requires some mental math.
JetBrains AI Assistant pros: native to JetBrains IDEs; bundled free with some JetBrains subscriptions (per its licensing page); granular credit-based billing.
JetBrains AI Assistant cons: locked to the JetBrains IDE family; JetBrains’ own pricing documentation currently contains conflicting price/credit figures.

Who Should Pick Which

Pick Cursor if you’re willing to switch editors for the most autonomous, agentic coding experience available today. Pick GitHub Copilot if your team is already on GitHub and you want AI assistance inside your current IDE without changing tools, at the lowest individual entry price of the three. Pick JetBrains AI Assistant if your team already lives in IntelliJ, PyCharm, WebStorm, Rider, or another JetBrains IDE and you’d rather not add a second AI subscription from a different vendor.

Bottom Line

There’s no single winner — the right choice follows your existing toolchain more than any one feature. GitHub Copilot is the safest, cheapest default if you’re GitHub-centric. JetBrains AI Assistant is the obvious choice if you’re already paying for JetBrains IDEs. Cursor is worth the editor switch if agentic, multi-file autonomy is the thing you actually need. Whichever you choose, verify current pricing directly with the vendor — all three companies update tiers and credit allowances more often than most review articles get updated.

FAQ

Can I use GitHub Copilot inside a JetBrains IDE?
Yes — GitHub’s plans page confirms IDE/editor support across major editors including JetBrains IDEs, so Copilot and JetBrains AI Assistant can technically coexist in the same editor.

Is Cursor based on VS Code?
Yes, Cursor is built as a fork of Visual Studio Code, which is why most VS Code extensions and keybindings carry over.

Does JetBrains AI Assistant work in the free Community editions?
Per JetBrains’ licensing documentation, AI Free is not available in Android Studio or in PyCharm/IntelliJ IDEA Community editions or trial licenses — you need a paid or All Products Pack-eligible JetBrains product.

Which tool is cheapest to start with?
GitHub Copilot Pro has the lowest published entry price of the three at $10/month, versus roughly $20/month for Cursor Pro and JetBrains AI Pro (subject to the pricing discrepancy noted above).

Do any of these tools have a free tier?
Yes — all three do: Cursor’s Hobby plan, GitHub Copilot’s Free plan (2,000 inline suggestions/month), and JetBrains’ AI Free tier (3 credits/30 days).

Sources

Engineering

Unicode for Developers: Code Points, Grapheme Clusters, and Normalization Without the Bugs

Posted on October 28, 2026October 28, 2026 by Filip Keser

Most string bugs that reach production come from one wrong assumption: that one “character” equals one unit of storage. It does not. A single letter can be one code point or two, a single emoji can be eight UTF-16 units, and two strings that look identical can fail an equality check. This deep dive explains the three layers you need to keep straight (code units, code points, and grapheme clusters), how normalization fixes the equality problem, and which built-in tools handle all of it correctly.

At a Glance

Concept	What it means
Code unit	The storage unit of an encoding; JavaScript’s `length` counts UTF-16 code units
Code point	A single Unicode value such as U+00F1; may take one or two UTF-16 units
Grapheme cluster	What a user perceives as one character; may span several code points
Normalization	Converting text to a standard form (NFC, NFD, NFKC, NFKD) so equivalent strings compare equal
Governing specs	UAX #29 (text segmentation) and UAX #15 (normalization forms)
Built-in tools (JavaScript)	`String.prototype.normalize()` and `Intl.Segmenter`

Short Verdict

Store and transmit text as-is, normalize to NFC before comparing or indexing it, and use grapheme segmentation, not length or code point counts, whenever the result is shown to a person: truncation, cursor movement, character limits, and “reverse this string.” Use compatibility normalization (NFKC/NFKD) only for search and matching, never to rewrite what the user typed.

Layer 1 and 2: Code Units vs Code Points

Unicode assigns every character a code point, written like U+00F1. Encodings then store those code points as code units: UTF-8 uses 8-bit units, UTF-16 uses 16-bit units. JavaScript strings are UTF-16, so length counts 16-bit units, not characters. Code points above U+FFFF, which include most emoji, need two UTF-16 units each (a surrogate pair). Splitting a string in the middle of a surrogate pair produces broken text, which is why naive slice() truncation can corrupt emoji.

Layer 3: Grapheme Clusters

Unicode Standard Annex #29, the specification for text segmentation (its current revision covers Unicode 18.0.0), puts the core problem plainly: a single code point is often, but not always, the same as a basic unit of a writing system. What users see as one character is approximated by a grapheme cluster. A letter followed by a combining accent is one cluster made of two code points. A Hangul syllable can be one precomposed code point or a sequence of conjoining jamo. And per UAX #29, each emoji sequence in the recommended (RGI) emoji set is a single grapheme cluster, even when it is built from several emoji joined by zero-width joiners.

UAX #29 defines two kinds of clusters. Legacy grapheme clusters are a base character plus continuing marks. Extended grapheme clusters, the default, also absorb spacing combining marks such as many Indic vowel signs, and the annex recommends them over legacy clusters except where the legacy variant is specifically required. Two useful properties: cluster boundaries are the same whether text is in NFC or NFD, and clusters do not necessarily match what the font draws, since a ligature like “fi” may render as one glyph while still being two clusters.

In JavaScript, Intl.Segmenter implements this segmentation and is marked Baseline widely available on MDN, supported across browsers since April 2024. A family emoji built from three emoji and two zero-width joiners shows the gap between storage and perception:

const family = "\u{1F468}\u200D\u{1F469}\u200D\u{1F467}"; // man ZWJ woman ZWJ girl
console.log(family.length);            // 8 UTF-16 code units
console.log([...family].length);       // 5 code points

const seg = new Intl.Segmenter("en", { granularity: "grapheme" });
console.log([...seg.segment(family)].length); // 1 user-perceived character

The same API supports "word" and "sentence" granularity. That matters because, as UAX #29 notes, word boundaries are not restricted to whitespace and punctuation, and languages such as Chinese, Japanese, and Thai do not separate words with spaces at all, so split(" ") fails on them.

Normalization: Making Equal Strings Equal

The letter “ñ” can be stored as the single code point U+00F1 or as “n” (U+006E) followed by a combining tilde (U+0303). The two render identically, but a byte-for-byte comparison says they differ. Unicode calls them canonically equivalent: they represent the same abstract character and should look and behave the same. Normalization picks one standard representation so comparisons work.

Form	What it does	Use it for
NFC	Canonical decomposition, then canonical composition (composed form)	The default for storage keys, comparison, and most text processing
NFD	Canonical decomposition (decomposed form)	Processing that wants base letters and marks separated, such as accent stripping
NFKC	Compatibility decomposition, then canonical composition	Search and matching, where “ﬀ” should match “ff”
NFKD	Compatibility decomposition	Search indexing that also wants marks separated

const a = "\u00F1";        // precomposed
const b = "\u006E\u0303";  // n + combining tilde
console.log(a === b);                                   // false
console.log(a.normalize("NFC") === b.normalize("NFC")); // true

const lig = "\uFB00";      // the "ff" ligature
console.log(lig.normalize("NFKC"));                     // "ff"

Compatibility equivalence is weaker than canonical equivalence: all canonically equivalent sequences are also compatible, but not the other way round. Compatible sequences should be treated alike in some applications but not necessarily all. MDN’s guidance captures the trade-off well: compatibility normalization suits search, because a user can find the ligature by typing “f”, but may not suit display, because it changes how the text looks. That is why you should normalize a copy for matching rather than overwrite what the user entered.

Common Bugs and Their Fixes

Character limits that reject valid input. A 20-character username limit enforced with length counts emoji as several characters. Count grapheme clusters for user-facing limits, and enforce a separate byte limit for storage.
Truncation that breaks emoji or accents. Cut at grapheme boundaries, not at a fixed code unit index.
Duplicate accounts or failed lookups. “Amélie” typed on two keyboards can produce two different code point sequences. Normalize to NFC before using text as a key.
String reversal that mangles text. Reverse the array of grapheme segments, not the code units.
Word counts that fail in some languages. Use word segmentation instead of splitting on spaces.

Bottom Line

Keep three layers in mind: code units for storage limits, code points for encoding logic, and grapheme clusters for anything a person sees. Normalize to NFC before comparing, reserve NFKC/NFKD for search, and lean on the platform: normalize() and Intl.Segmenter already implement the Unicode rules so you do not have to.

Frequently Asked Questions

Why is an emoji’s length more than 1 in JavaScript? length counts UTF-16 code units; emoji above U+FFFF take two units each, and joined sequences add zero-width joiners.
Which normalization form should I store? NFC is the usual choice for storage and comparison; it is also the default for normalize().
When should I use NFKC? For search and matching, not for display or for rewriting user input.
How do I count characters the way users see them? Use grapheme segmentation, such as Intl.Segmenter with granularity: "grapheme".

Sources

Engineering

CRDTs Explained: How Conflict-Free Replicated Data Types Keep Distributed Data in Sync

Posted on October 28, 2026 by Filip Keser

Collaborative editors, offline-first mobile apps, and multi-region databases all face the same problem: two copies of the same data get changed at the same time, and they have to end up identical without anyone losing work. Conflict-free replicated data types, or CRDTs, are the best-studied answer. This explainer covers what they guarantee, the two ways they are built, the classic examples, and the libraries most developers reach for today.

At a Glance

Concept	Summary
What a CRDT is	A replicated data type whose copies can be updated independently and always merge to the same state
Guarantee	Strong eventual consistency: replicas that received the same updates are in the same state
Two designs	State-based (CvRDT): ship and merge whole states; operation-based (CmRDT): ship commuting operations
Formalized in	Shapiro, Preguiça, Baquero, Zawirski, “Conflict-free Replicated Data Types” (SSS 2011)
Popular libraries	Automerge (JavaScript/Rust) and Yjs (JavaScript)
Best for	Collaboration, offline-first apps, and multi-replica systems that must accept writes anywhere

Short Verdict

Reach for CRDTs when every replica must accept writes without waiting for the others, such as a document edited offline or a counter updated in several regions. You trade some storage overhead and a constrained set of data types for the ability to merge automatically, with no conflict-resolution code and no rollbacks. If your data needs strict invariants that span many records, such as “this account balance must never go negative,” a CRDT alone is the wrong tool.

The Guarantee: Strong Eventual Consistency

Plain eventual consistency only promises that replicas will agree at some point after updates stop arriving, and usually needs some way to arbitrate conflicts or roll back. The 2011 paper by Marc Shapiro, Nuno Preguiça, Carlos Baquero, and Marek Zawirski formalized a stronger property, strong eventual consistency (SEC): any two replicas that have delivered the same set of updates are in equivalent states, at all times. Because convergence is built into the data type, no rollback or arbitration step is needed. The paper also shows that replicas of a CRDT converge in a self-stabilizing way despite any number of failures.

Two Ways to Build a CRDT

	State-based (CvRDT)	Operation-based (CmRDT)
What replicas send	Their full state	Individual update operations
Mathematical requirement	States form a join semilattice; merge computes the least upper bound; updates only move the state upward	Concurrent operations must commute
Network requirement	Very little: states can arrive late, twice, or out of order	Operations must be delivered in causal order
Trade-off	Simple delivery, but sending whole states can be heavy	Small messages, but needs a reliable causal delivery layer

The paper proves both designs give strong eventual consistency and that each can emulate the other, so the choice is an engineering trade-off about bandwidth and delivery guarantees rather than about correctness.

Classic Examples

Increment-only counter. Each replica keeps a vector with one slot per replica and only increments its own slot. Merging takes the per-slot maximum, and the counter’s value is the sum. This is what most later writing calls a G-Counter.
Increment/decrement counter. Two increment-only counters, one for increments and one for decrements; the value is the difference. Commonly called a PN-Counter.
Add-only set. Sets merge by union, so adds can never conflict. Commonly called a G-Set.
Add/remove set with tombstones. The paper’s U-Set pairs an add set with a remove set and assumes each element is added only once; the familiar 2P-Set works the same way, and the trade-off is that a removed element cannot come back.
Directed graph. The paper’s op-based graph tags vertices and arcs with unique IDs; if one replica removes a vertex while another adds an arc to it, the removal wins.

Libraries You Can Use Today

Automerge is a library of CRDT data structures for collaborative apps. Each user keeps a local copy that can be edited offline and saved to disk, and changes merge automatically when devices reconnect. It is written in Rust, compiles to WebAssembly for browsers, runs on Node.js, exposes a C API for platforms without a JavaScript engine, and is network-agnostic: it can sync over WebSockets, peer-to-peer WebRTC, or even a file passed by email. The companion automerge-repo library provides ready-made networking and storage.

Yjs exposes CRDTs as shared types, similar to familiar maps and arrays, that many users can edit at once and that emit change events. It also makes no assumptions about the network: as long as every update eventually arrives, in any order, documents converge. It offers network adapters for WebSocket, WebRTC, and Hyper, persistence providers, and bindings for editors including ProseMirror, Tiptap, Monaco, Quill, and CodeMirror.

Pros

Writes never wait on other replicas, which makes offline editing and multi-region writes straightforward. Merges are automatic and deterministic, so there is no conflict-resolution code to write or test. Convergence is a mathematical property of the type, not a hope about timing, and it holds even when messages are delayed, duplicated, or reordered (for state-based designs).

Cons

Metadata such as per-replica vectors and tombstones grows over time and needs compaction or garbage collection. The automatic merge result is consistent but not always what a user intended, so applications still need to design sensible semantics. And CRDTs cannot enforce global invariants on their own, such as uniqueness across records or a minimum balance, which still require coordination.

Bottom Line

CRDTs turn “merge conflicts” into a property of the data type rather than a problem for application code. They are the right default for collaborative and offline-first features, and libraries like Automerge and Yjs make them practical without implementing the math yourself. Pair them with coordination only where you truly need global invariants.

Frequently Asked Questions

What does CRDT stand for? Conflict-free replicated data type.
What is strong eventual consistency? A guarantee that any replicas which have received the same updates are in the same state, with no rollbacks needed.
State-based or operation-based? State-based tolerates unreliable delivery but sends more data; operation-based sends small messages but requires causal delivery. Both converge.
Do I need a server? No. Libraries like Automerge and Yjs work peer-to-peer or through a server, because convergence does not depend on a central authority.

Sources

Engineering, software

GitHub Copilot Review: Plans, AI Credits, and Which Tier a Developer Actually Needs in 2026

Posted on October 28, 2026 by Filip Keser

Get GitHub Copilot: Visit the official GitHub Copilot plans page →

At a Glance

Spec	Value
Free plan	Yes — 2,000 inline suggestions/month, limited chat and agent use
Starting paid price	Pro, $10/month
Individual tiers	Free, Pro ($10), Pro+ ($39), Max ($100) per month
Business / Enterprise	Not priced on the plans page — contact sales
Usage unit	GitHub AI Credits (1 credit = $0.01)
Best for	Developers already on GitHub who want AI completions, chat, and an agent that opens pull requests

Short Verdict

GitHub Copilot’s free tier is a genuine trial of the product, with 2,000 inline suggestions a month and limited chat. For anyone coding most days, Pro at $10 a month is the sensible starting point: it removes the suggestion cap and adds code review and the cloud agent that turns assigned issues into pull requests. Pro+ and Max mostly buy a bigger monthly pool of AI credits plus the ability to hand tasks to third-party coding agents, so they only make sense if you regularly run out of credits on Pro. The big change to understand in 2026 is that usage is now measured in dollar-denominated AI credits rather than a simple request count.

What GitHub Copilot Is

GitHub Copilot is GitHub’s AI coding assistant. It suggests code inline as you type, answers questions in a chat panel, runs an agent mode that can make multi-file changes, works from the command line through the Copilot CLI, and on paid plans can act as a cloud agent: you assign it an issue on GitHub and it works in the background and opens a pull request for you to review.

Pricing Breakdown

Plan	Price/month	Base credits	Flex allotment	Total monthly credit value	Inline suggestions
Free	$0	Limited chat and agent usage			2,000/month
Pro	$10	$10	$5	$15	Unlimited
Pro+	$39	$39	$31	$70	Unlimited
Max	$100	$100	$100	$200	Unlimited
Business / Enterprise	Contact sales; not priced on the plans page

GitHub now meters chat, agent, and other advanced features in GitHub AI Credits, with one credit worth $0.01. Each paid plan comes with base credits equal to its price plus a flex allotment on top, so Pro effectively includes $15 of monthly usage, Pro+ $70, and Max $200. The plans page we checked did not list annual pricing for any tier.

Features by Tier

The Free plan already includes the Copilot CLI, agent mode, MCP server support, and custom instructions, but not code review, the cloud agent, or app modernization. Pro adds Copilot code review on pull requests, the cloud agent, app modernization for Java and .NET projects, and support for repository instruction files. Pro+ and Max add delegation to third-party coding agents, such as Anthropic’s Claude and OpenAI Codex, which GitHub labels as a preview; beyond that, the two differ mainly in credit volume. Enterprise-grade security, IP indemnity, SAML SSO, usage metrics, and user management are not part of any individual plan and require Business or Enterprise. One caution: the plans page lists the same set of AI models across every tier but its FAQ says Free users get entry-level models, so check which models you can actually select before relying on a specific one.

Pros

The free tier is usable for evaluation and light coding without a credit card. Pro is inexpensive at $10 a month and includes the features that change day-to-day work: unlimited completions, PR code review, and a cloud agent that works directly inside GitHub issues and pull requests. Copilot sits inside the platform where many teams already host code, so there is no separate tool to connect. The credit system makes heavy usage possible on higher tiers without hard request caps.

Cons

Dollar-denominated credits are harder to predict than a flat request count, because how fast you spend them depends on which features and models you use. Business and Enterprise pricing is not published on the plans page, which makes team budgeting harder without a sales conversation. Third-party agent delegation is still a preview and is only on the two most expensive individual plans. The model-availability wording on the plans page is inconsistent, as noted above.

Who It’s a Good Fit For

Individual developers and freelancers who host their code on GitHub and want completions, chat, and an agent that can pick up issues and open pull requests. Pro covers most of them. Pro+ or Max fit developers who lean heavily on agents and regularly exhaust Pro’s $15 of monthly credit value.

Who Should Look Elsewhere

Teams that need SSO, usage metrics, or IP indemnity need Business or Enterprise and should get a quote before committing. Developers whose code lives outside GitHub lose the cloud agent and PR review integration, which are much of the paid plans’ value, so an editor-based AI assistant may fit better.

Bottom Line

Start on Free to see whether inline suggestions fit how you code, then move to Pro at $10 a month if you code regularly; it is the best value tier and includes the cloud agent and code review. Only step up to Pro+ or Max once Pro’s credit pool is clearly the bottleneck. Teams should treat Business and Enterprise as a sales conversation, since the plans page does not publish their prices.

Frequently Asked Questions

Is GitHub Copilot free? There is a free plan with 2,000 inline suggestions a month and limited chat and agent usage.
How much is Copilot Pro? $10 a month, which includes $15 of monthly AI credit value ($10 base plus a $5 flex allotment).
What is a GitHub AI Credit? The unit GitHub uses to meter advanced features; one credit equals $0.01.
How much do Business and Enterprise cost? The plans page does not list prices for them; GitHub directs teams to contact sales.