Desktop & Local IDEs

Learning Objectives

• Distinguish between AI-native IDEs and AI-augmented traditional editors
• Compare Cursor, VS Code, Windsurf, JetBrains AI, and others on key capabilities
• Select the appropriate IDE based on workflow, team size, and AI integration depth

Two Models for AI in the IDE

The code editor market has split into two distinct approaches to AI integration:

AI-native IDEs: Built from scratch with AI as the primary interface, not an afterthought. Cursor, Windsurf, Google Antigravity, and AWS Kiro fall here. The entire editor is designed around AI interaction — the keyboard shortcuts, the UI, the file navigation.

AI-augmented editors: Established editors that have added AI layers — either natively or through extensions. VS Code (with GitHub Copilot), JetBrains IDEs (with JetBrains AI), and Zed (with Zed AI) fall here. The foundation is unchanged; AI capabilities are woven in.

Neither approach is categorically better. AI-native editors give you maximum AI capability; AI-augmented editors let you stay in the tool your muscle memory knows.

Cursor — The AI-Native Leader

Cursor is built on the VS Code codebase (same extension compatibility, same keyboard shortcuts) but rebuilt from scratch with AI as the primary interface. With over 1 million users, 360,000+ paying customers, and $2 billion+ in annualized revenue (at a $29.3 billion valuation), it's the fastest-growing developer tool in the AI era. Over 60% of revenue comes from enterprise customers — 90%+ of Salesforce developers now use Cursor, and NVIDIA and Stripe are also customers.

Ownership update (April 2026): Cursor is made by Anysphere (CEO Michael Truell), which remains the current owner. On April 21, 2026, SpaceX announced a deal that gives it the option to acquire Cursor for $60 billion by year-end 2026, with a $10 billion fallback payment for joint development work if the acquisition does not close. The strategic rationale: pair Cursor's product and customer base with Colossus, SpaceX/xAI's training supercomputer, to train next-generation coding models. Microsoft reportedly looked at buying Cursor earlier in 2026 before SpaceX secured the option.

Core Capabilities

Cursor Tab: Multi-line autocomplete that predicts entire code blocks and diffs — not just single token completion. Cursor watches your recent edits and predicts what you'll change next. Pressing Tab applies the prediction; pressing Escape dismisses it. Developers report this feels qualitatively different from token-level autocomplete.

Cmd+K (Inline Edit): Select any code block, press Cmd+K, and describe the change you want. "Extract this into a function," "Add error handling," "Refactor to use the new API." The change is shown as a diff before you accept it.

Chat with @-mentions: Cursor's chat interface lets you reference specific files, functions, documentation URLs, or web pages with @. Rather than copying and pasting code into the chat, you reference it by name — and Cursor includes the full context automatically.

Codebase Q&A: Ask questions about your entire codebase — "where is the authentication middleware?" "how does the payment webhook handler work?" Cursor indexes your repo and provides answers with file references.

Agent Mode: Multi-file implementation from a single natural language task. Cursor reads relevant files, makes changes across multiple files simultaneously, runs terminal commands, and iterates until the task is complete.

Recent Additions (2026)

• Composer 1.5: Cursor's proprietary agentic model, purpose-built for multi-file coding tasks within the Cursor environment
• Bugbot: Automatically detects and fixes issues in pull requests — runs on every PR and suggests fixes before human review
• Automations: Cloud-based agents that run tasks asynchronously, even when your IDE is closed
• JetBrains integration: Via the Agent Client Protocol (ACP), Cursor's agent capabilities are now available in IntelliJ, PyCharm, and other JetBrains IDEs

Model Selection

Cursor lets users choose which model powers each feature — Claude Opus 4.7, GPT-5.5, Gemini 3.1 Pro, or Cursor's own Composer 1.5 model. This flexibility is unusual and practical: use the best model for each task type.

VS Code + GitHub Copilot — The Universal Standard

Visual Studio Code is the world's most used code editor, with approximately 75% market share among developers. Its AI story comes primarily from GitHub Copilot — but also from a rich ecosystem of AI extensions.

GitHub Copilot in VS Code

Copilot Chat: Full conversational AI in a sidebar panel. Ask questions about code, request explanations, ask for refactoring. Access via the chat icon or Ctrl/Cmd+Shift+I.

Copilot Edits: Multi-file editing from a single instruction. Select files to edit, describe the change, and Copilot applies changes across all selected files with a diff review interface.

Inline Completions: The original Copilot feature — as you type, ghost text shows the predicted continuation. Accepting with Tab; ignoring by continuing to type.

Copilot Workspace (most advanced): Takes a GitHub issue and plans and implements the entire solution. Reads the issue, creates a plan, edits files to implement, and produces a PR-ready result for human review.

AI Extension Ecosystem

VS Code's extension marketplace includes dozens of AI coding tools beyond Copilot:

• Continue.dev: Open-source; supports 100+ models including local Ollama models; highly configurable; free
• Codeium: Free alternative to Copilot; solid autocomplete; chat feature
• Tabnine: Privacy-focused; can run entirely locally with on-premise models

The VS Code advantage: breadth of choice. If you need a specific AI workflow, there's likely an extension for it.

Windsurf — Deep Codebase Understanding (Now Under Cognition AI)

Windsurf was originally built by Codeium as an AI-native IDE focused on the "flows" concept. In mid-2025, Windsurf became the subject of a high-profile acquisition battle: OpenAI bid $3 billion, but Microsoft blocked the deal. Google DeepMind licensed the technology and hired the CEO ($2.4 billion package). Ultimately, Cognition AI (makers of Devin) acquired the product, brand, and IP for approximately $250 million.

Under Cognition, Windsurf continues to operate as a standalone product. Its Cascade agent is designed for deep understanding of large, complex codebases — where Cursor is optimized for developer-AI interaction, Windsurf is optimized for AI that understands your entire project deeply enough to work more autonomously.

Cascade can initiate multi-file changes without being explicitly asked when it understands the intent from context. At the time of acquisition, Windsurf had $82 million ARR and 350+ enterprise customers. It was ranked #1 in LogRocket Power Rankings (February 2026).

JetBrains AI — Enterprise Professional IDEs

JetBrains makes the professional IDEs of choice for many enterprise engineering teams:

• IntelliJ IDEA — Java and Kotlin; the industry standard for JVM development
• PyCharm — Python; strongest Python-specific tooling
• WebStorm — JavaScript/TypeScript; deep JS ecosystem support
• GoLand — Go; purpose-built for the Go language
• Rider — .NET/C#; the top .NET IDE outside Visual Studio

JetBrains AI Assistant is integrated across all of these:

• Inline completion that understands JetBrains' language-specific parsing (not just token prediction)
• Next Edit Suggestions (GA): Predicts where you'll edit next and pre-fills the change
• Recap: Activity summaries that describe what you accomplished in a session
• Insights: Proactive code understanding — flags potential issues before you ask
• Chat with codebase context (Claude Sonnet 4.6 available in chat)
• Refactoring suggestions integrated with IntelliJ's powerful refactoring engine
• Claude Agent integration via Anthropic Agent SDK — full agentic coding within JetBrains IDEs
• JetBrains Console for team-level AI management and BYOK (Bring Your Own Key) support

The enterprise differentiator: JetBrains offers an on-premise AI deployment option where the AI model runs on your infrastructure — required for some regulated industries.

Zed — Performance-First + AI

Zed is written in Rust — the choice reflects a philosophy: the editor should be instantaneously responsive, regardless of file size or codebase scale.

Real-time collaborative editing: Zed's built-in collaboration feature enables multiple developers to edit the same file simultaneously, with each person's cursor and changes visible in real time — like Google Docs for code.

Zed AI: Chat and inline AI capabilities with model selection (Opus 4.5/4.6, Sonnet 4.5/4.6). In January 2026, Zed announced the Agent Client Protocol (ACP) — an open protocol enabling external agents (like Cursor) to integrate with any IDE. Zed now supports subagents (spawn_agent), merge conflict resolution via agent, and strong MCP support.

For performance-focused developers and teams that want native collaboration without a third-party plugin, Zed is a distinctive option.

Google Antigravity — Agent-First IDE

Google Antigravity (announced November 2025 alongside Gemini 3) is a VS Code fork rebuilt as an agent-first IDE. Its standout feature is Manager View: dispatch 5+ agents simultaneously to work on different parts of your codebase in parallel.

Key capabilities:

• Artifacts: Task lists, plans, screenshots, and browser recordings that agents create as they work
• Multi-model support: Gemini 3.1 Pro, Flash, Claude Opus/Sonnet 4.6, GPT-OSS-120 billion
• Free for individuals (public preview) — no subscription required
• Web app generation and UI mockup workflows

For teams in the Google ecosystem who want multi-agent parallelism built into their IDE, Antigravity is a compelling option.

AWS Kiro — Spec-Driven Development

AWS Kiro is Amazon's entry into the AI-native IDE space — an agentic IDE and CLI built on Code OSS (VS Code base).

What makes Kiro distinctive:

• Spec-driven development: Uses EARS notation (Easy Approach to Requirements Syntax) to generate structured specifications before writing code — requirements first, code second
• Agent hooks: Automated triggers that fire on file events (save, create, delete) — agents can respond to code changes in real time
• Native MCP support: First-class MCP integration for connecting to external services
• Steering files: Persistent project knowledge files (similar to AGENTS.md) that guide the agent's behavior
• GovCloud available (February 2026) — making it suitable for government and regulated enterprise environments
• Supports Python, Java, JavaScript, TypeScript, C#, Go, Rust, and more

For enterprise teams on AWS, especially those requiring GovCloud compliance, Kiro provides an integrated path from requirements to implementation.

Choosing Your IDE

The practical decision framework:

• If you're flexible and want maximum AI capability: Cursor
• If you have existing VS Code muscle memory and extensions: VS Code + GitHub Copilot
• If you work in large enterprise codebases and want proactive AI: Windsurf
• If your team standardizes on JetBrains for language tooling: JetBrains AI
• If performance and real-time collaboration are the priority: Zed
• If you want multi-agent parallelism and free access: Google Antigravity
• If you need spec-driven development or AWS GovCloud: AWS Kiro

Key Takeaways

• AI-native IDEs (Cursor, Windsurf, Antigravity, Kiro) are rebuilt around AI interaction; AI-augmented editors (VS Code, JetBrains, Zed) add AI to proven foundations — both are valid depending on your flexibility and existing workflow investment
• Cursor leads on AI capability ($2 billion+ ARR, 360K+ paying customers) with Composer 1.5, Bugbot, and Automations; VS Code leads on ecosystem breadth with Copilot Agent Mode and CLI agent now GA
• The IDE landscape is consolidating: Windsurf was acquired by Cognition AI, while new entrants Google Antigravity (free, multi-agent) and AWS Kiro (spec-driven, GovCloud) expand options
• Multi-file agentic coding — where AI makes changes across many files from a single instruction — is now available in all major AI IDEs; the frontier is moving toward multi-agent parallelism (Antigravity's Manager View, Cursor's Automations)