Originally published at heycc.cn. This is a mirrored copy — the canonical version is kept up to date at the source.

Best AI Coding Assistant for VS Code in 2026: Extensions vs. Forks, Real Free Tiers, and the Local Option

Search for "best AI coding assistant for VS Code" and roughly half the recommendations you get back cannot be installed in VS Code at all. Cursor is not an extension. Windsurf — now renamed Devin Desktop — is not an extension either (its actual VS Code plugin has been abandoned for over a year, which we will prove with marketplace data below). Both are forks: separate applications built from the VS Code codebase that you download, install, and run instead of VS Code.

That distinction is not pedantry. It determines whether you keep your existing extensions, settings sync, remote-SSH workflows, and corporate device policies, or migrate to a different binary that your IT department has never approved. It also explains a small ecosystem of lookalike extensions in the VS Code Marketplace that exist purely to catch people typing "Cursor" into the extensions sidebar.

This piece sorts the 2026 field into three buckets: real extensions, forks masquerading as extensions in search results, and the local/offline path. Every fast-moving number here is checked against a primary source, captured on 2026-07-18. Given how much changed in June 2026 alone (Cursor acquired Continue, SpaceX agreed to acquire Cursor, Cognition renamed Windsurf), the capture date matters more than usual.

The taxonomy: what "runs in VS Code" actually means

Extensions install from the VS Code Marketplace (or Open VSX for forks and VSCodium), run inside the editor process you already have, and inherit everything about your setup: keybindings, themes, Remote-SSH, Dev Containers, settings sync, and whatever compliance tooling your employer bolted on.

Forks are separate products compiled from the open-source VS Code codebase. Cursor's own migration documentation is explicit that it is "based upon the VS Code codebase," a familiar shell around a different product. It provides a one-click importer (Cursor Settings → General → Account) that copies your VS Code extensions, themes, settings, and keybindings into the new app. The import exists precisely because a fork does not share your VS Code installation; it clones it once and then diverges.

Why do vendors fork instead of shipping extensions? Because the extension API constrains the UI surface. An extension gets panels, webviews, decorations, and (since 2024–2025) inline-edit APIs. A fork owns the whole window: it can rewrite the tab-completion engine, embed agent UI into the diff editor, and intercept every keystroke. Cursor's signature Tab completion model is the canonical example of something that could not be built as a marketplace extension with equivalent latency and UI integration.

The cost of a fork is everything else: you trust a second vendor's update pipeline, marketplace access differs (forks generally cannot legally use Microsoft's marketplace, so they rely on Open VSX, where some extensions are missing or lag), and enterprise allow-lists frequently do not include them.

Firsthand: measuring the confusion with the Marketplace API

The VS Code Marketplace has a public extensionquery API, which makes claims about publishers, versions, and install counts checkable rather than vibes. First, the legitimate anchor, Anthropic's Claude Code extension:

curl -s -X POST "https://marketplace.visualstudio.com/_apis/public/gallery/extensionquery" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json;api-version=3.0-preview.1" \
  -d '{"filters":[{"criteria":[{"filterType":7,"value":"anthropic.claude-code"}]}],"flags":914}'

The relevant fragment of the raw JSON response, captured 2026-07-18:

{
  "publisher": {
    "publisherName": "anthropic",
    "isDomainVerified": true,
    "domain": "https://anthropic.com"
  },
  "extensionName": "claude-code",
  "lastUpdated": "2026-07-18T01:27:37.49Z",
  "versions": [{ "version": "2.1.214" }],
  "statistics": [
    { "statisticName": "install", "value": 20885197.0 },
    { "statisticName": "averagerating", "value": 3.74119234085083 },
    { "statisticName": "ratingcount", "value": 738.0 }
  ]
}

A verified publisher (domain anthropic.com), a version pushed the same day the query ran, and 20.9M installs. That is what a first-party, actively shipped extension looks like in the API.

One methodological caveat you will not find in comparison listicles: the marketplace API serves these counters from mirrors, and identical queries run minutes apart on the capture day returned install counts of 20,902,218 and 20,885,197 for this same extension, a spread of about 0.08%. Treat any unit-precise install figure, here or anywhere, as a snapshot with mirror jitter, not an exact ledger.

Now the trap. Instead of asserting that searchers get burned, run the search query the extensions sidebar runs (a filterType: 10 text query for "cursor") and list what comes back:

1  zhang-renyang.vscode-cursor              verified: False   installs: 8,846
2  Cardinal90.multi-cursor-case-preserve    verified: False   installs: 511,898
3  meteorstudio.cursorcode                  verified: False   installs: 446,475
4  ktiays.aicursor                          verified: False   installs: 153,585

Not one of the top ten results for "cursor" comes from a domain-verified publisher, and three of the top four are AI-branded lookalikes trading on Cursor's name (the #2 result is an innocent multi-cursor text utility). The largest of the lookalikes, meteorstudio.cursorcode, display name "CursorCode(Cursor for VSCode)," has accumulated ~446,000 installs with a 2.64-star rating from an unverified publisher with no affiliation to Anysphere, Cursor's maker. And a direct query on its ID adds the sharpest detail: its latest version is v0.2.1, last updated 2023-05-06. The trap extension is itself more than three years abandoned. Nearly half a million people installed a dead lookalike because the real product cannot exist in the marketplace. Cursor is the editor itself. If you take one operational rule from this article: check isDomainVerified on the publisher before installing anything with an AI brand name in it.

The real extensions, ranked by what you can verify

GitHub Copilot: the incumbent, and the only meaningful free chat tier

Marketplace stats at capture: 74.2M installs, 4.08 rating from 1,054 ratings, more than triple any competitor. Copilot Free is the most concrete free tier in the field, and the official plans page publishes actual numbers: 2,000 code completions per month and 50 chat requests (Copilot Edits included), with access to models including Haiku 4.5 and GPT-5 mini, no credit card required. Paid tiers as listed on the same page: Pro at $10/user/month, Pro+ at $39, and Max at $100.

One documentation shift worth knowing before you compare plans anywhere else: GitHub's docs now denominate paid allowances in "GitHub AI Credits" rather than the older "premium requests" vocabulary. Pro is described as unlimited completions plus a monthly AI-credit allowance, while Free is limited access through auto model selection only. Vendors renaming their metering units mid-year is exactly why any free-tier comparison without a capture date is fiction within a quarter.

Copilot's structural advantage is not the model menu; it is that completions, chat, Edits, and the cloud agent live behind one subscription your GitHub org may already pay for, inside the first-party extension Microsoft co-develops with the editor itself.

Claude Code for VS Code: the agent extension, with no free tier

The extension shown in the API capture above wraps the Claude Code agent in a native VS Code panel. The prerequisites in the official docs are unambiguous: you need a paid Claude subscription (Pro, Max, Team, or Enterprise) or a Claude Console (pay-per-use API billing) account. Notably, no API key is required for the extension to authenticate. There is no free tier. If a comparison article tells you otherwise, it is describing a product that does not exist.

Architecturally, the extension bundles its own private copy of the Claude Code CLI to power the chat panel. Installing the extension does not give you a claude command in your terminal; that still requires the standalone CLI install. The docs also state the extension installs in VS Code forks (they name Devin Desktop and Kiro) via the Open VSX registry, with the CLI in the integrated terminal as the documented fallback for editors that cannot run it, a tidy illustration of how the extension/fork split plays out in practice.

Four documented capabilities separate it from chat-panel competitors:

1. Plan mode as a document. Plans open as full Markdown documents that accept inline comments before anything executes: review-then-run rather than approve-a-bullet-list.
2. Checkpoints with independent rewind. Each checkpoint offers "Fork conversation from here," "Rewind code to here," or both. Conversation state and file state are separately restorable.
3. Usage attribution. /usage (extension v2.1.174+) breaks plan-limit consumption down per skill, subagent, plugin, and MCP server, the only mainstream assistant that itemizes what inside your setup is eating your quota.
4. A minimal, gated IDE bridge. The extension runs a built-in loopback MCP server exposing exactly two model-visible tools: mcp__ide__getDiagnostics (read linter/compiler diagnostics) and mcp__ide__executeCode (run code in a Jupyter kernel), the latter hard-gated behind a mandatory Execute/Cancel prompt. Two tools with one execution gate is a deliberately small attack surface compared to agent extensions that expose broad tool suites by default.

The 3.74 average rating (738 ratings) is worth an honest note: power users rate agent tools harshly when limits bite, and plan-limit complaints dominate low reviews across every vendor this year.

Cline: the open-source agent, and the strongest local story

Cline (marketplace ID saoudrizwan.claude-dev, a historical artifact of its origin as "Claude Dev") is the field's open-source counterweight: ~4.69M marketplace installs, 4.09 rating, v4.0.9 shipped 2026-07-16, and a GitHub repo at 64,761 stars, Apache-2.0, with pushes as recent as the capture date. The project's site claims 8.0M+ installs across all platforms (marketplace plus Open VSX plus JetBrains; treat the aggregate as vendor-reported).

Cline's positioning is "The Open Coding Agent": one Apache-2.0 agent runtime usable in your editor, terminal, or embedded in your own products. Its pricing model is bring-your-own-key: the extension is free; you pay whichever model provider you configure. The supported list spans Anthropic, OpenAI, Google, AWS Bedrock, Azure, GCP Vertex, DeepSeek, xAI, Mistral, Cerebras, OpenRouter, any OpenAI-compatible endpoint — and, critically for the local section below, Ollama and LM Studio.

BYOK cuts both ways. There is no subsidized tier: an agent loop against a frontier model on your own API key can cost more per day than a $10 Copilot subscription costs per month. Cline is the choice when you want provider freedom, auditable open-source behavior, or local models, not when you want the cheapest metered bundle.

Continue: open code, dead company

Continue deserves a special-status warning rather than a recommendation. In mid-June 2026, Cursor acquired Continue in what coverage characterized as an acqui-hire of co-founder Nate Sesti (secondary reports place the announcement between June 16 and June 18; no dated primary announcement post exists to pin it down, which is itself telling). Continue users were given a July 15, 2026 deadline to export their data before deletion (less than a month out), and recurring billing was disabled. The continue.dev homepage now literally titles itself "Continue (acquired by Cursor)," with FAQ sections addressing what happens to the open source, user data, and subscriptions.

Two nuances that secondary reporting got wrong, checked against the GitHub API: the continuedev/continue repository is not archived ("archived": false), showed a push on 2026-07-17, retains its Apache-2.0 license, and sits at 34,952 stars, despite multiple outlets describing it as read-only. The code remains public and forkable. But the marketplace listing tells the operational story: last updated to v2.1.0 on 2026-06-19, within days of the acquisition announcement, and nothing since, across ~3.68M installs (3.31 rating).

Classification: community-risk software. Fine for hobbyists comfortable building from source and pinning versions; wrong for anyone who needs a vendor to exist next quarter. Every pre-June-2026 article recommending "Continue + Ollama" as the local path is now stale.

Windsurf Plugin: the cautionary tail

The "Windsurf Plugin (formerly Codeium)" extension still shows 3.9M installs, but the marketplace API records v1.49.2 as last updated 2025-06-16, over thirteen months stale as of this writing (and, a small irony given the rule above, the Codeium publisher account itself carries isDomainVerified: false). Cognition renamed the Windsurf editor to Devin Desktop on June 2, 2026 (windsurf.com/pricing now returns a 308 permanent redirect to devin.ai/pricing — observable with a single curl -I). The official FAQ commits that the full IDE lives on, that the Cascade agent is replaced by Devin Local (which the FAQ claims delivers up to 30% better token efficiency, subagent support, and sandboxing; a vendor claim, not an independent benchmark), that existing plans continue unchanged, and, pointedly, that the JetBrains plugin will continue working. The VS Code plugin receives no equivalent commitment anywhere in the FAQ. Thirteen months of silence plus a conspicuous omission in the vendor's own continuity FAQ is as close to a deprecation notice as you get without one. Do not adopt it in 2026.

The forks: Cursor and Devin Desktop

Cursor (Hobby free / Pro $20 / Teams $40 per user/month per its pricing page, with on-demand usage billed in arrears after included model usage) remains the most popular fork. Two things belong in any honest 2026 assessment. First, its free tier publishes no numbers: the pricing page commits only to "no credit card required" plus limited Agent requests and limited Tab completions. Any article quoting a specific free request count for Cursor is inventing one. Second, corporate risk: on June 16, 2026, SpaceX agreed to acquire Anysphere for $60 billion in an all-stock deal, days after SpaceX's Nasdaq IPO, expected to close in Q3 2026 pending regulatory approval, as reported by CNBC and TechCrunch, which also put Cursor at roughly $4B annualized revenue (a reported figure; there is no public filing to verify it against). Whatever you think of the strategic logic, teams standardizing on Cursor are now standardizing on a product whose owner, roadmap, and data-governance posture are mid-transition. Its treatment of Continue (a data-deletion deadline less than a month after the acquisition) is the available precedent for how it handles acquired products' users.

Devin Desktop (ex-Windsurf) is Cognition's fork, now positioned around the Devin Local agent. If you are on it, your plan carries over per the FAQ. If you are choosing fresh in 2026, you are choosing a product one rename into an identity transition. Wait for the dust, or have a reason.

The practical takeaway for the searcher this article is titled for: if you want Cursor or Devin Desktop, you download an installer from their websites. Nothing you find under those names in the VS Code extensions sidebar is the real product, as the search-query capture above demonstrated.

Free tiers, with dates attached

All rows checked against the linked primary source on the capture date.

The only free tier with published, quotable numbers is Copilot's. The only path to a genuinely $0, unmetered assistant is the next section.

The local/offline path: Cline + Ollama

For codebases that cannot leave the machine — defense, healthcare, unreleased products, air-gapped networks — the 2026 answer is Cline + Ollama. A year ago the standard advice was "Continue or Cline"; Continue's vendor no longer exists as an independent company, so Cline (actively shipped 2026-07-16, 250+ contributors) is now the defensible default.

The setup itself is short. Install Ollama from ollama.com, pull a code-tuned model (qwen3-coder and similar coding models are common picks; Cline's docs point you at model catalogs rather than prescribing one), and confirm the local server is answering before touching the editor:

ollama pull qwen3-coder
curl http://localhost:11434/api/tags

The curl should return a JSON object whose models array lists every model you have pulled; a connection-refused error means the Ollama server is not running yet. Then in Cline's settings: provider Ollama, base URL http://localhost:11434 (the default documented in Cline's Ollama guide), select the pulled model. Every request now terminates at localhost; nothing crosses the network boundary.

The parts most tutorials omit, all three straight from Cline's own documentation:

• Hardware is the real constraint. Cline's published tiers: 16–32 GB RAM for small/quantized models, 32–64 GB for mid-size coding models, 64 GB+ for larger models with bigger context windows. On an 8–16 GB laptop, local agentic coding will disappoint. That is a hardware fact, not a Cline flaw.
• Enable "Use Compact Prompt" (Cline Settings → Features). Cline's system prompt is engineered for frontier-model context windows; local models need the compact variant or you burn most of your context before your code enters the picture.
• Work in short, focused tasks and start new ones as context grows. The docs say this explicitly, and it matters far more locally, where context and long-horizon reasoning are the scarcest resources.

Set expectations honestly: a local 14–32B model is a competent pair for edits, tests, boilerplate, and explanations. It is not a frontier agent, and no amount of configuration makes it one. The trade is capability for absolute data custody. For regulated code, that trade is frequently correct and often the only permitted option.

Picking your lane: four situations, four answers

One meta-lesson from June 2026's consolidation wave, in which Continue was absorbed with a data-deletion deadline under a month out, Cursor went pending acquisition by SpaceX, and Windsurf was renamed under Cognition: your assistant's vendor is now a bigger risk variable than its model quality. Model gaps close in months; a shuttered product deletes your data on a deadline. Weight vendor durability accordingly. It is a large part of why the two survivors on the "safe default" list are a Microsoft-backed incumbent and an Apache-2.0 community project you could fork.

Where every number came from

Method, not vibes: all marketplace figures (installs, ratings, versions, publisher verification, last-updated timestamps) were captured live on 2026-07-18 via the public extensionquery API, both direct ID queries (filterType: 7) and the "cursor" search query (filterType: 10) excerpted above. Because the API serves counters from mirrors, identical queries minutes apart differed by up to ~0.1%; unit-level install figures should be read as snapshots. Repository status for continuedev/continue and cline/cline came from the GitHub REST API the same day. Copilot free-tier quotas and pricing are from GitHub's plans page, and the AI-credits terminology from GitHub's docs. Claude Code prerequisites, CLI bundling, checkpoints, /usage, and the two-tool IDE MCP server are from the official Claude Code docs. Cline's hardware tiers, Compact Prompt, and short-task guidance are from docs.cline.bot; the Ollama install/verify commands are standard Ollama usage shown without captured output. The windsurf.com/pricing → devin.ai/pricing 308 redirect was observed directly via curl -I. Three things could not be verified against a primary source and are flagged as such in the text: the exact date of the Continue acquisition announcement (secondary coverage spans June 16–18; treated as mid-June), Cursor's ~$4B annualized revenue (reported by CNBC/TechCrunch, no public filing), and Devin Local's "up to 30% better token efficiency" (a vendor claim from the Windsurf FAQ, not a benchmark).

Sources

• VS Code Marketplace — Claude Code for VS Code (anthropic.claude-code)
• VS Code Marketplace — Cline (saoudrizwan.claude-dev)
• GitHub Copilot plans and pricing (official)
• GitHub Docs — Copilot plans and AI Credits
• Claude Code for VS Code — official documentation
• Cline documentation — Running models locally with Ollama
• cline/cline repository (GitHub)
• continuedev/continue repository (GitHub)
• Continue homepage — acquisition FAQ
• Windsurf / Devin Desktop continuity FAQ
• Devin pricing (redirect target of windsurf.com/pricing)
• Cursor pricing (official)
• Cursor docs — Migrate from VS Code
• CNBC — SpaceX to acquire the AI coding startup Cursor for $60 billion
• TechCrunch — SpaceX to acquire Cursor for $60B in stock
• The New Stack — Cursor quietly acquires Continue