IDEs & Platforms: The Definitive Guide to AI Coding Tools

Tech Stack → Playbook. Last reviewed July 2026.

Every tool in this section will write code for you. The differences that matter are structural: where the agent lives (terminal, editor, cloud), who controls the model, how the pricing meter runs, and what happens when the agent is wrong. This guide covers the six platforms that define the market, plus the tier below them, then tells you which one to buy depending on who you are. No tool here is paying for placement. Where a verdict is unflattering, it stays.

Two framing notes before the dossiers. First, sticker prices in this market are entry fees, not totals — nearly every tool now meters actual model usage underneath a subscription, and the gap between "$20/month" and what a heavy agent user actually pays can be 3–10x. We flag the meter in every pricing section. Second, the tools are converging: every editor is growing an agent, every agent is growing an editor surface, and open protocols (MCP for tools, ACP for agent-editor plumbing) are dissolving the walls between them. The differences below are real today; check the dates before assuming they hold.

1. Claude Code (Anthropic)

What it is. Claude Code is Anthropic's agentic coding tool, and it made an unfashionable bet that turned out to be the right one: the primary interface is a terminal, not an editor. You run it in a shell, point it at a repository, and it reads files, edits them, runs tests, executes git commands, and iterates until the task is done or it hits a wall. Since launch it has grown outward from the CLI into a full surface area — a desktop app for macOS and Windows, a web version at claude.ai/code, VS Code and JetBrains extensions, a GitHub Action and GitHub App for CI-triggered runs, and the Claude Agent SDK for embedding the same harness in your own software. But the terminal remains the center of gravity, and that is the point.

Why terminal-native matters. An editor-based assistant sees what the editor sees: open buffers, an index, a chat panel. A terminal-based agent sees what a developer sees: the whole filesystem, the build system, the test runner, the linter, git history, environment variables, every CLI tool you have installed. It doesn't need a plugin to run your migrations or grep your logs — it just runs them. This is why agentic workflows matured fastest here. The terminal is the lowest common denominator of software work, which makes it the highest common denominator for an agent. The trade-off is equally real: there is no cursor to watch, no diff view unless you ask for one, and the learning curve is "learn to delegate and review" rather than "keep autocompleting."

Standout capabilities. Three extension primitives do the heavy lifting. MCP (Model Context Protocol, which Anthropic originated and the rest of the industry adopted) connects the agent to external systems — databases, browsers, issue trackers, deployment APIs. Skills are folder-based instruction packs (a SKILL.md plus helper scripts) that load on demand, so domain knowledge doesn't burn context permanently. Hooks run deterministic code around tool calls and lifecycle events — the enforcement layer, where you block dangerous commands or auto-format on save regardless of what the model feels like doing. On top of those sit subagents (isolated context windows for delegated sub-tasks), agent teams (parallel Claude instances coordinating on separate subtasks), and plugins that bundle all of the above into one installable unit. CLAUDE.md files give it persistent per-project and per-user memory.

Workflow reality. At its best, Claude Code is the closest thing on this list to handing work to a competent colleague: you describe the outcome, it plans, executes across many files, runs the tests, and reports back. Long-horizon multi-file work is its strongest suit and the reason many teams route their hardest tasks here even when they use a cheaper tool for the routine ones. It also composes with everything else — because it's a CLI, it slots into CI pipelines, cron jobs, and shell scripts the way editor plugins can't, and the GitHub Action turns "fix this issue" into something you trigger from a label. The failure modes are the flip side of autonomy: it can be expensive in tokens on exploratory work, it will occasionally over-engineer beyond the ask, and reviewing a 400-line diff you didn't watch being written is a genuinely different skill from reviewing your own work. Session limits on subscription plans are rolling windows, so a heavy afternoon can lock you out until the window resets — Max-tier users hit this less, but it's a real planning constraint on Pro. And Anthropic's own models are the only engine — there is no model marketplace. If Claude has a bad day on your codebase, there's no dropdown to switch.

Pricing. Bundled with Claude subscriptions: Pro at $20/month (entry-level usage, roughly 5-hour rolling session limits), Max 5x at $100/month, Max 20x at $200/month ⚑ unverified. Teams need a Premium seat, around $100–125/seat/month with a five-seat minimum ⚑ unverified. Alternatively, pay-as-you-go via API credits at model token rates — viable for light use, expensive for heavy agentic sessions. Not available on the free tier.

Who it's for. Developers who already live in a terminal, teams doing serious multi-file refactoring and long-running autonomous tasks, and anyone building agents on top (the Agent SDK is the same harness as the product). Not the pick for people who want inline completions as they type — that is explicitly not what this is.

---

2. Cursor

What it is. Cursor is a VS Code fork rebuilt around AI, and it is the tool that made "AI-first editor" a category. Because it forked VS Code rather than extending it, your extensions, keybindings, and themes mostly carry over — the switching cost is an afternoon. What you gain is an editor where the AI is not a panel but the architecture: codebase-wide indexing, an agent that edits across files, and the fastest tab-completion in the business.

Standout capabilities. Three layers. Tab is the completion engine — it predicts multi-line edits, jumps your cursor to the next likely change, and is widely regarded as the best autocomplete anyone has shipped; for many users it alone justifies the subscription. Composer began as the multi-file editing surface and has evolved into Cursor's in-house model line, tuned for fast agentic edits — Cursor now splits usage between its first-party models (Composer, Auto) and third-party frontier models (Claude, GPT, Gemini) that you select per task ⚑ unverified. Agent mode runs multi-step autonomous tasks — terminal commands, file creation, iterative fixes — inside the editor, and background agents push longer tasks off your screen entirely. Underneath it all, Cursor indexes your repository with embeddings, so "how does auth work in this codebase" gets a real answer.

Workflow reality. Cursor's genius is that it meets developers where they are: you keep typing, and the AI escalates from completion to edit to agent as you let it. The friction is the meter. Cursor's pricing has changed repeatedly — from request counts to compute credits to usage pools — and each change produced a cohort of users surprised by mid-month exhaustion. Frontier-model agent sessions burn credits fast; the in-house models are cheaper but not always what you want on hard problems. The other honest criticism: as a fork, Cursor trails upstream VS Code releases, and some extension edge cases break. Neither has stopped it becoming the default editor at a large share of startups.

Pricing. Hobby free (limited agent requests and completions). Pro $20/month with roughly $20 of included agent usage; Pro+ $60/month at 3x; Ultra $200/month at 20x plus priority access. Teams $40/user/month, with a Premium seat at $120/user/month (5x usage) added in June 2026; team usage now splits into separate pools for first-party and third-party models ⚑ unverified. Overage is usage-based on top.

Who it's for. The default recommendation for a working developer who wants maximum AI leverage without changing how they work. Especially strong for people who value completions and interactive editing over fire-and-forget autonomy. Budget-sensitive heavy users should read the usage terms twice — the sticker price is not the ceiling.

---

3. GitHub Copilot

What it is. The incumbent. Copilot invented the category in 2021 as an autocomplete product, and its evolution since is the story of the whole market in miniature: completions (2021), chat (2023), multi-model choice (2024), agent mode in the editor (GA March 2026, VS Code and JetBrains), and the Coding Agent — a cloud-hosted asynchronous worker you assign a GitHub Issue to, which branches the repo, writes the code, runs CI, and opens a pull request ⚑ unverified.

Standout capabilities. Distribution and integration, more than any single feature. Copilot is inside VS Code, JetBrains, Visual Studio, Neovim, Xcode, the github.com web UI, and the GitHub mobile app. The Coding Agent's tight loop with GitHub primitives — Issues in, PRs out, CI status checked mid-task, MCP connections to Confluence, Figma, and internal knowledge bases — is something no competitor can replicate without owning the platform. Model choice now spans OpenAI, Anthropic, and Google models from one subscription. Code review by Copilot on PRs is quietly one of its most-used features. For enterprises, the compliance story (IP indemnity, policy controls, audit) is the real product.

Workflow reality. Copilot is the safe choice, and it performs like one. Completions are good but no longer the best; agent mode works but arrived later and feels less polished than Cursor's or Claude Code's equivalents; the Coding Agent is genuinely useful for well-scoped issues — dependency bumps, test coverage, mechanical refactors filed as Issues — and genuinely frustrating for anything ambiguous, where it burns credits producing a PR you close. The pattern among heavy users is telling: Copilot handles the routine layer, and a second tool handles the hard layer. The June 1, 2026 billing change — from "premium requests" to GitHub AI Credits metered per token at listed API rates — made costs more transparent and, for heavy agent users, higher ⚑ unverified. Where Copilot wins is everywhere the decision isn't made by the developer: procurement already trusts GitHub, security already reviewed it, and it's a checkbox on an existing Microsoft agreement.

Pricing. Free tier (limited completions and chat). Pro $10/month, Pro+ $39/month, Max $100/month for individuals. Business $19/seat/month; Enterprise $39/seat/month — but Enterprise requires GitHub Enterprise Cloud at ~$21/user, so the real number is ~$60/seat/month. Since June 2026, model usage draws from per-token AI Credits with usage-based overage; Business and Enterprise get 2x promotional credits through August 2026 ⚑ unverified.

Who it's for. Enterprises, full stop — it is the only tool here that a 5,000-developer organization can adopt without a fight. Also the right floor for individual developers on a budget: $10/month buys more capability than anything else at that price. Power users tend to outgrow it and add a second tool on top.

---

4. Windsurf

What it is. Windsurf (formerly Codeium) was the challenger that briefly looked like it might take the crown — an AI-native editor whose Cascade agent introduced "flows," the idea that the agent maintains a live, continuously updated awareness of your actions instead of waiting for a prompt. Then came the most chaotic ownership saga in dev tools: an OpenAI acquisition that collapsed, Google licensing the core technology and hiring away the founding team, and Cognition — the company behind the autonomous agent Devin — acquiring what remained ⚑ unverified. Windsurf is now effectively the desktop surface of the Devin ecosystem.

Standout capabilities. Cascade was the headline: full-codebase awareness, multi-file edits, terminal execution, and the flows concept — the agent watches what you do and picks up context implicitly, so you correct a function and it understands the correction applies elsewhere. Cognition has been folding its own technology in: the SWE model line (fast, in-house agent models) and Codemaps (a structural map of your codebase the agent navigates) came across from the Devin side. The roadmap tells the real story: Cascade reaches end-of-life July 1, 2026, replaced by Devin Local as the default agent ⚑ unverified. The editor persists; the brain is being swapped.

Workflow reality. Day to day, Windsurf remains a pleasant, capable Cursor alternative — cleaner UX by many accounts, historically more generous free tier, agent quality a half-step behind the frontier. The in-house SWE models are the underrated asset: they're fast and cheap enough that routine agent work doesn't feel metered the way frontier-model sessions do, which is exactly the economics Cognition needs if Devin-style autonomy is going to run all day. The honest question is continuity. The founding team is at Google. The product's signature system is being retired in favor of the new owner's agent. For an individual developer that churn is invisible until it isn't; for a team standardizing on a tool for years, it is the primary risk factor. Buying Windsurf in 2026 is really a bet on Cognition's thesis that the IDE and the autonomous agent (Devin) converge into one product.

Pricing. Repriced March 19, 2026, replacing credits with daily and weekly quotas: Free ($0, limited daily quota), Pro $20/month, Max $200/month, Teams $40/user/month, Enterprise custom. Pre-March Pro subscribers grandfathered at $15/month ⚑ unverified.

Who it's for. Developers who want the AI-first-editor experience with a friendlier meter than Cursor, and teams already invested in Devin who want the local surface to match. Cautious teams should watch the Cascade-to-Devin-Local transition land before standardizing.

---

5. JetBrains AI

What it is. JetBrains' answer to the question its 15 million users kept asking: do I have to leave IntelliJ, PyCharm, or GoLand to get serious AI help? The offering is two-headed: AI Assistant (completions, chat, refactoring, test generation, in-editor everything) and Junie, the autonomous coding agent that plans and executes multi-step tasks inside the IDE. Both ride on the thing JetBrains has spent two decades building — the deepest static analysis and refactoring engine in the industry.

Standout capabilities. Integration with real IDE intelligence is the differentiator. When Junie renames a symbol or moves a class, it can lean on JetBrains' semantic understanding of the code rather than string matching — the IDE knows every usage, every override, every implication. AI features surface inside existing workflows: commit message generation, runtime error explanation, test scaffolding in the test runner, refactoring suggestions in the inspection system. JetBrains also co-developed the Agent Client Protocol (ACP) with Zed in January 2026, an open standard that lets external agents — including Claude Code — run inside JetBrains IDEs as first-class citizens ⚑ unverified. That is a notably un-territorial move: if you won't use our agent, bring your own.

Workflow reality. For JetBrains loyalists — and Java, Kotlin, and Python shops are full of them — this is the path of least resistance, and it's better than its reputation. The agent gap is real, though: Junie is competent on scoped tasks but trails Claude Code and Cursor's agent on long-horizon autonomy, and it shipped later. The sorest point is the credit system. Credits meter real per-token cost, and heavy Junie use can drain AI Pro's monthly allocation in about a week ⚑ unverified — the community forums are not shy about this. Budget as if the sticker price is the entry fee, not the total.

Pricing. AI Free (bundled trickle of credits). AI Pro $10/month individual, $20/month business. AI Ultimate $30/month individual, $60/month business, with a larger credit pool. Enterprise custom. Credits are denominated at $1 each and meter actual model usage ⚑ unverified. Note the All Products Pack does not make heavy AI usage free — credits are the real meter.

Who it's for. Existing JetBrains users, obviously — if IntelliJ or PyCharm is non-negotiable, this plus a terminal agent via ACP is a strong setup. Enterprises with JetBrains site licenses get the easiest procurement story after Copilot. Nobody should switch to JetBrains for the AI alone.

---

6. Zed

What it is. Zed is the performance-first newcomer: a from-scratch editor written in Rust by the team behind Atom, GPU-rendered, with input latency low enough that reviewers keep reaching for "instant." It spent its early life as the fast editor with no ecosystem; in 2025–2026 it turned into something more interesting — an AI-native editor that decided not to fight the agent war, but to host it.

Standout capabilities. Speed first: the whole editor runs at 120fps, and its agentic editing applies multi-file AI changes without the UI ever hitching — a small thing that compounds over a workday. Zeta2, its open-weight edit-prediction model, handles completions. But the strategic move is the Agent Client Protocol (ACP), co-developed with JetBrains and launched January 2026: an open, Apache-licensed standard for plugging any agent into any editor. In practice this means Claude Code, Codex CLI, Gemini CLI, and OpenCode run inside Zed with full UI integration — you get the best terminal agents with an editor around them, instead of whichever agent your editor vendor built ⚑ unverified. Zed also supports parallel agents and BYOK for Anthropic, OpenAI, and Google keys with no usage cap on the free tier.

Workflow reality. Zed's honest position: the best agent-hosting editor, not the best agent. Its native AI is fine; its completions are good; but the reason to run it is the combination of raw speed and the ability to bring Claude Code or your CLI agent of choice into a first-class graphical harness. The costs are ecosystem costs — the extension library is a fraction of VS Code's, some language tooling is thinner, and Windows support arrived late and is younger than the macOS/Linux builds. If your workflow depends on a niche VS Code extension, check before you leap.

Pricing. The cheapest serious option on this list. Personal: free forever, 2,000 edit predictions/month, unlimited BYOK usage. Pro: $10/month, unlimited predictions plus hosted models billed at API list price +10%. Business: $30/seat with governance controls, no seat minimum ⚑ unverified.

Who it's for. Developers who feel editor latency and resent it; Claude Code users who want a graphical shell around their agent without paying for a second AI subscription; open-source-leaning engineers who like that the editor and the ACP standard are open. Not yet for teams dependent on deep VS Code ecosystem tooling.

---

7. Honorable mentions

Aider — the original open-source CLI agent, and still the purest expression of the form: free, BYOK, git-native (every AI change is a clean commit, so git revert is your undo button), with a repo-map system that gives the model architectural context cheaply. The catch in 2026 is momentum: release velocity has visibly slowed ⚑ unverified, while open-source rivals like OpenCode ship weekly. Still excellent; no longer obviously the future.

Cline — the open-source agent that lives inside VS Code as an extension. BYOK, transparent (you watch every step and approve every action via its Plan/Act modes), and free for individuals; a Teams tier runs $20/user/month with the first 10 seats free ⚑ unverified. The pick for developers who want agentic coding with full auditability and zero markup on model costs — you pay your API bill and nothing else. Typical real-world spend lands around $25–70/month in tokens for a working developer ⚑ unverified.

Replit Agent — the "idea to deployed app" machine. Agent 3 plans, builds, tests, and deploys full-stack applications on Replit's own cloud, which means database, auth, and hosting are one integrated surface rather than a scavenger hunt. Effort-based pricing scales with task complexity: the Core plan at $20/month includes ~$25 of credits, and serious builders climb to Pro at $95/month with ~$100 of credits ⚑ unverified — a single ambitious build can eat a Core month. Strongest for prototypes and internal tools; teams routinely graduate off it once an app becomes a real product.

The app-gen tier: v0, Bolt, Lovable — one rung further from the IDE: describe an app, get an app. v0 (Vercel) generates the best React/Next.js interfaces of the three, with Figma-to-code support, but produces frontends only — no backend, database, or auth. Team plans run $30/user/month ⚑ unverified. Bolt.new (StackBlitz) is the most technical: full-stack in a browser IDE where you can actually edit the code, Pro at $25/month ⚑ unverified. Lovable is the most accessible and the breakout commercial story of the category — built-in Supabase backend, one-click deploy, GitHub export, Pro $25/month, Business $50/month ⚑ unverified. The shared honest caveat: all three excel at the first 80% of an MVP and get progressively worse at the last 20%, and the code they generate becomes your problem the day you export it.

---

Best AI coding setup, by persona

Solo developer / indie hacker → Cursor Pro, with Claude Code for the heavy lifts. Cursor's $20 tier delivers the most day-to-day leverage per dollar: best-in-class completions plus a capable agent in one editor. When a task is genuinely large — a migration, a refactor across 30 files — a Claude Pro subscription ($20) adds a terminal agent built for exactly that. Total: $40/month for a setup that covers both interactive and delegated work. If you can only pick one, pick by temperament: typists take Cursor, delegators take Claude Code.

Enterprise team → GitHub Copilot Business/Enterprise as the floor, Claude Code Premium seats for the platform team. Copilot wins the enterprise not on capability but on everything surrounding it: procurement, indemnity, policy controls, and presence inside tools your developers already use. That is worth more at 1,000 seats than a smarter agent. But blanket-license economics also mean your most leveraged engineers are underserved — give the platform/infra team, who do the riskiest multi-repo work, Claude Code seats on top. Two tools, honestly scoped, beats one tool oversold.

Open-source purist → Zed + Cline (or Aider), BYOK. Every layer inspectable: Zed is open source, Cline and Aider are open source, ACP is an open protocol, and your API keys go straight to the model provider with no middleman markup. You give up hosted convenience and some polish; you gain auditability, zero lock-in, and a cost structure where you pay exactly what the tokens cost. The weak link is that the best models themselves are not open — a fully open stack (local models via Ollama behind Aider) is possible and meaningfully worse on hard tasks. Most purists compromise at the model layer and nowhere else.

Non-coder building apps → Lovable first; Bolt.new if you're willing to learn; Replit to go further. Lovable has the gentlest on-ramp to a working, deployed, database-backed app — for a founder validating an idea, it is the fastest path from description to something users can click. Bolt.new suits the "technical-adjacent" builder who wants to see and edit the code. Replit Agent is where you land when the app needs to keep growing and you want an environment that scales with you. The honest ceiling for all three: when the app becomes a business, you will need a developer, and the generated codebase will be their first complaint.

Data scientist → Copilot Pro or Cursor in the editor; Claude Code for pipeline and refactor work; keep the notebook loop human. Exploratory analysis is a poor fit for fire-and-forget agents — the value is in you seeing each intermediate result — so what you want in the notebook is fast completion and inline chat, which Copilot at $10 or Cursor at $20 both deliver (JetBrains AI if you live in DataSpell/PyCharm). Where agents earn their keep is everything around the notebook: turning exploration code into pipelines, writing tests, refactoring the utils module nobody owns, and wiring the data checks you keep meaning to add. That is terminal-agent work; Claude Code does it best, and its MCP support means the agent can query your warehouse directly instead of guessing at your schema.

A note on picking at all. The strongest pattern across every persona is that the winners run two tools, scoped honestly: one interactive (editor-resident, completion-and-chat) and one delegated (agent, terminal or cloud). The tools are cheap relative to the time they touch; the expensive mistake is forcing one tool to be both and resenting it for the half it does badly.

---

The workflow shift: completions → chat → agents

The tools above are snapshots of a market mid-transformation, and the transformation has had three distinct phases, each changing not just the tooling but the job.

Completions (2021–2023) kept the developer fully in the loop. Copilot's original bet was that the smallest useful unit of AI help was the next few lines, offered inline, accepted or rejected in milliseconds. The developer remained the author; the AI was a very good guess at what the author would type next. Nothing about the job changed except its speed.

Chat (2023–2024) moved the unit of work from lines to answers. You described a problem, got back an explanation or a block of code, and pasted it in. This was the first real cognitive shift — the developer became an integrator of generated material — and it introduced the first real failure mode at scale: code that looked right, compiled, and was subtly wrong, written by something with no access to your actual codebase.

Agents (2025–) changed the unit of work to outcomes. You describe a result; the agent reads the codebase, plans, edits multiple files, runs the tests, reads the failures, and fixes them, looping until done. This is the phase every tool in this guide is racing to win, and it changes the job in a way the first two phases did not: the developer's primary output shifts from writing code to specifying and reviewing it. The scarce skills become decomposition (framing tasks an agent can actually complete), specification (saying precisely what "done" means), and review (auditing work you didn't watch happen). Engineers who were fast typists lose an advantage; engineers who were good tech leads gain one. It is not a coincidence that the best agent users describe their workflow in management language — delegation, scoping, verification.

The honest failure modes are worth stating plainly, because vendor marketing won't.

Context limits. Agents hold a finite window of your codebase in mind, and on large repositories they work from a partial map. The result is locally correct, globally wrong changes: a fix that's perfect in the file it touched and breaks an invariant maintained three directories away. Bigger context windows and smarter retrieval shrink this problem; nothing has eliminated it.

Hallucinated APIs. Models still invent methods that don't exist, import packages that were never published, and confidently call your internal functions with the wrong signature. Agentic loops catch much of this — the code runs, fails, gets fixed — but "the tests pass" is a weaker guarantee than it sounds when the agent also wrote the tests.

Review burden. This is the quiet one. An agent produces in ten minutes a diff that takes forty to review properly, and the temptation to skim grows with every diff that turned out fine. Teams that adopted agents fastest are now discovering that their bottleneck moved from writing to reviewing — and that unreviewed AI code is technical debt with excellent posture. The uncomfortable arithmetic: if agents make code 5x cheaper to produce and reviews stay honest, review capacity, not generation capacity, sets your velocity.

None of this argues against the shift; it argues for going in with eyes open. Completions made you faster at your old job. Agents give you a new job. The developers doing best in 2026 are not the ones using AI most — they're the ones who noticed the job changed and re-skilled for the new one.

---

Prices and plan structures verified against vendor pages and current reporting as of July 2026; this market reprices frequently — treat every number marked ⚑ unverified as due for a check at publish time.