Three AI-powered IDEs, all forked from VS Code, all promising to change how you write code. Cursor has the momentum and a $29 billion valuation. Windsurf has survived an ownership rollercoaster and now ships its own frontier models. Kiro, the newest entrant from Amazon, bets that the real problem isn’t writing code faster but thinking about requirements first.
Each takes a fundamentally different approach to the same question: how should AI fit into a developer’s workflow? After digging through official documentation, GitHub repos, pricing pages, changelogs, Reddit threads, Hacker News discussions, and real user switching stories, here’s what actually matters when choosing between them.
Current as of April 2026. Pricing, features, and model availability verified against official documentation from cursor.com, windsurf.com, and kiro.dev.
Quick Comparison: Cursor vs Windsurf vs Kiro at a Glance
Before the deep dive, here’s the high-level picture. This table covers the fundamentals that most developers ask about first.
| Feature | Cursor | Windsurf | Kiro |
|---|---|---|---|
| Developer | Anysphere (San Francisco) | Cognition AI (acquired from Codeium) | Amazon / AWS |
| Based on | VS Code fork | VS Code / Code OSS fork | Code OSS fork |
| Launch | March 2023 | November 2024 | July 2025 (preview), November 2025 (GA) |
| Core approach | Conversational AI + multi-file agent | Agentic Cascade + persistent memory | Spec-driven: requirements, design, then code |
| Free tier | Limited agent requests + completions | Daily/weekly refreshing credits | 50 credits/month |
| Pro price | $20/month | $20/month | $20/month |
| Top tier | Ultra $200/month | Max $200/month | Power $200/month |
| AI models | Claude, GPT, Gemini, Grok (multi-provider) | SWE-1.5/1.6 (proprietary), Claude, GPT, Gemini | Claude only (via Bedrock) |
| BYOK (bring your own key) | Yes (OpenAI, Anthropic, Google, Azure) | Limited (Claude 4 Sonnet/Opus only) | No |
| MCP support | Yes (5,000+ servers) | Yes (marketplace + manual config) | Yes |
| Extension registry | Open VSX | Open VSX | Open VSX |
| Open source | No (GitHub repo is issue tracker only) | No (editor plugins are open source) | No (GitHub repo is issue tracker only) |
| Platforms | macOS, Windows, Linux | macOS, Windows, Linux | macOS, Windows, Linux |
| Compliance | SOC 2 Type II | SOC 2 Type II, FedRAMP, HIPAA | SOC 2 (via AWS) |
| GitHub stars | 32,600+ | N/A (editor not on GitHub) | 4,500+ issues on feedback repo |
| Valuation / backing | $29.3 billion (Series D, Nov 2025) | Part of Cognition AI ($10.2B) | Amazon (internal product) |
All three cost $20/month at the Pro tier. The differentiation isn’t price. It’s philosophy.
Cursor: The Multi-File Refactoring Powerhouse
Cursor was first to market in March 2023, built by four MIT students at Anysphere. It graduated from OpenAI’s accelerator and has since raised over $3 billion across multiple rounds, reaching a $29.3 billion valuation in November 2025. The company crossed $2 billion in annualized revenue by February 2026.
The growth numbers are staggering, but what drives them is a genuinely useful product. Cursor’s strength is making multi-file edits feel natural.
What Makes Cursor Different
Composer and Agent Mode are the headline features. Composer lets you describe a change that spans multiple files, and Cursor plans and executes edits across all of them in one shot. Agent mode takes this further by autonomously creating, editing, and deleting files based on your instructions. Professional developers on Reddit consistently call Composer “transformative” for refactoring sessions that touch 15+ files.
Background Agents (introduced in version 0.50, mid-2025) run tasks independently while you continue working. Cloud Agents take this even further by spinning up sandboxes to build, test, and demo features end-to-end.
Cursor 3.0 (April 2026) introduced the Agents Window: a full-screen tiled workspace where you can run multiple agents in parallel across different repos and branches. The /worktree command creates isolated git worktrees for each agent, and /best-of-n runs the same prompt across multiple models simultaneously so you can pick the best result.
Codebase indexing is where Cursor earns its reputation for context awareness. It builds semantic embeddings of your entire codebase and lets you reference specific files, folders, symbols, or documentation with @-mentions. This granular context control is something power users cite as a key reason they stay on Cursor.
BugBot ($40/user/month, separate from IDE pricing) reviews GitHub PRs automatically and learns from your team’s feedback patterns over time.
Models and Flexibility
Cursor supports the widest range of AI models: GPT-4o, GPT-4.5, GPT-5.4, Claude 3.5 Sonnet, Claude Opus 4.6, Gemini 3 Pro, and Grok Code. You can also bring your own API keys for OpenAI, Anthropic, Google, and Azure OpenAI. This model flexibility is a significant advantage for teams that want to experiment or have specific model preferences.
That flexibility comes with trade-offs, though.
Where Cursor Falls Short
The June 2025 pricing change from 500 fixed “fast” requests per month to usage-based credits was controversial. The effective number of requests dropped to roughly 225 for the same $20, and the company’s CEO publicly apologized after backlash. Rate limits (1 request per minute, 30 per hour) hit frequently during heavy Composer sessions.
Large codebases (100K+ files) can cause lag and indexing issues. The editor is VS Code only, with no JetBrains or Neovim support (though ACP integration for JetBrains was announced in March 2026). Microsoft-proprietary extensions like C# Dev Kit, Remote SSH, Pylance, and Live Share aren’t available since Cursor uses the Open VSX registry instead of the VS Code Marketplace.
Download Cursor: cursor.com/downloads (macOS, Windows, Linux)
GitHub (issue tracker): github.com/cursor/cursor (32.6K stars)
Windsurf: The Agentic IDE That Survived a Corporate Storm
Windsurf has the most turbulent backstory of the three. Originally built by Codeium (itself a rebrand of Exafunction), the Windsurf editor launched in November 2024 as “the first agentic IDE.” What followed was a corporate soap opera: OpenAI agreed to acquire Windsurf for $3 billion in May 2025, Microsoft blocked the deal over IP rights in July 2025, Google hired the CEO and co-founder in a $2.4 billion talent deal, and Cognition AI (makers of the Devin autonomous coding agent) picked up the remaining product, brand, and team for roughly $250 million.
That ownership chaos is worth knowing because it shapes the biggest risk with Windsurf today: roadmap uncertainty. The original founders are gone. The new owner (Cognition) also has Devin, and how these two products merge or coexist is still unclear.
What Makes Windsurf Different
Cascade is Windsurf’s core AI experience, accessed via Cmd+L. It operates in two modes: Write mode (creates and modifies code, runs terminal commands, installs packages) and Chat mode (Q&A without changes). Cascade can execute up to 20 tool calls per prompt, plans before acting, and generates Todo lists for complex tasks.
Supercomplete goes beyond traditional autocomplete. Instead of predicting the next line of code, it predicts your next editing action. It reads 30 to 90 seconds of your recent edit history, cursor movement, and surrounding context. If you renamed userId to accountId twice, Supercomplete pre-stages the next occurrence. It parses a lightweight AST to understand downstream effects of your edits.
Memories give Cascade persistent context across sessions. After about 48 hours of use, Cascade learns your architecture patterns and coding preferences. Unlike Cursor’s per-session context, Windsurf’s memories persist locally and are retrieved automatically in future sessions. One developer on dev.to noted that Windsurf automatically used an existing custom date-time picker from their project, while Cursor suggested installing a new npm package for the same task.
Rules (stored in .windsurf/rules/) are version-controlled, shareable configuration files that give the agent persistent project context. Similar to Cursor’s .cursorrules, but with activation modes: always-on, manual, or context-triggered via YAML frontmatter.
Proprietary Models: SWE-1.5 and SWE-1.6
The most interesting technical development post-acquisition is Windsurf’s in-house model family. SWE-1.5 is described as “near Claude 4.5-level, 13x faster than Sonnet 4.5.” SWE-1.6 is the latest frontier model. These proprietary models cost 0 credits to use, which gives Windsurf a unique cost advantage: the best value per dollar comes from using the in-house models rather than Claude or GPT.
Third-party model support includes Claude Opus 4.6, Claude Sonnet 4.6, GPT-5.4, Gemini 3.1 Pro, and others. BYOK is limited to Claude 4 Sonnet and Opus variants only.
The model variety is strong, but other aspects of the experience have rough edges.
Where Windsurf Falls Short
The ownership story creates legitimate uncertainty. Long-time Codeium users on Reddit and Trustpilot express concern about losing the original product vision. Will Windsurf remain standalone or merge into Devin? Will the free tier survive? No clear answers yet.
Performance degrades on files exceeding 300 to 500 lines, with a hard cap at 12,000 lines. The March 2026 quota changes drew backlash, with users reporting what felt like a 10x effective price increase on usage. Autocomplete suggestions occasionally lag or disappear, and Cascade sessions can stall during long operations.
The compliance story is actually strong: SOC 2 Type II, FedRAMP High, and HIPAA-eligible deployments are available, which matters for regulated industries.
Download Windsurf: windsurf.com/download/editor (macOS, Windows, Linux)
On macOS you can also install via Homebrew:
brew install --cask windsurfGitHub (plugins): github.com/Exafunction (Vim, Neovim, Visual Studio plugins are open source)
Kiro: Amazon’s Spec-Driven Approach
Kiro is the newest and most opinionated of the three. Built by Amazon/AWS, it launched in public preview in July 2025 (hitting capacity limits within days) and reached general availability in November 2025. Where Cursor and Windsurf jump straight from prompt to code, Kiro inserts a structured thinking phase in between.
What Makes Kiro Different
Spec-driven development is the core differentiator. When you give Kiro a task, it doesn’t immediately start generating code. Instead, it produces three artifacts first:
- Requirements with user stories in EARS (Easy Approach to Requirements Syntax) notation, including acceptance criteria
- Design document covering data models, APIs, and module structure
- Sequenced implementation tasks mapped back to requirements
Only after you review and approve these specs does Kiro generate code. A ThoughtWorks analysis found this approach produces code that more closely matches specifications with fewer hallucinated features compared to Cursor and Windsurf. The trade-off is speed: for a quick bug fix, generating requirements documents feels like overkill.
Agent Hooks are event-driven automation triggers. You configure what to watch (specific files or paths), when to act (on save, file create, file delete), and what to do (run tests, format code, update docs). This is similar to git hooks but integrated with the AI agent. There’s also a userTriggered mode for on-demand workflows.
Steering Rules live in .kiro/steering/ as three markdown files: product.md (product vision, target users), tech.md (frameworks, coding patterns), and structure.md (directory conventions, naming schemes). These give the agent persistent project context without repeating yourself in every prompt. They support YAML frontmatter for activation modes: always loaded, conditional (file pattern matching), manual, or auto.
Autopilot vs Supervised mode lets you toggle between fully autonomous execution and step-by-step approval. In Autopilot mode, Kiro makes architectural decisions and runs commands without asking. Supervised mode presents each change as individual hunks for granular accept/reject.
Claude-Only, Via Bedrock
Kiro runs exclusively on Anthropic’s Claude models through Amazon Bedrock: Sonnet 4, Sonnet 4.5, Haiku 4.5, Opus 4.5, and Opus 4.6. An “Auto” mode routes requests intelligently across models based on task complexity. There’s no OpenAI, no Gemini, and no BYOK option (this is a frequently requested feature on GitHub issue #481).
The credit system uses a multiplier: Sonnet 4 costs 1.3x per task compared to Auto mode. The free tier gives you 50 credits per month, which multiple reviewers describe as “disappearing in a single 2-hour session.”
Relationship to Amazon Q Developer
AWS now has two AI coding tools, and the distinction matters. Amazon Q Developer is an IDE extension (works inside VS Code, JetBrains, Eclipse) focused on inline suggestions, chat, and deep AWS service integration. Kiro is a standalone IDE focused on structured, spec-driven development. The Q Developer CLI has been merged into the Kiro CLI, with an official migration guide available.
Where Kiro Falls Short
The spec-driven workflow adds overhead that doesn’t pay off for simple tasks. Multiple reviewers describe it as “overkill for quick bug fixes.” Credits burn faster than expected because spec generation and context summarization both consume them, punishing iterative debugging workflows.
A Medium deep dive titled “Brilliant, Broken, and Frustrating” documented tasks that frequently get stuck, lose context, and force complete restarts. There’s also an ironic gap in AWS integration: despite being an AWS product, Kiro has no native CloudFormation, CDK, Amplify, or S3 deployment support.
The trust question is real. AWS has a history of killing developer tools (CodeCommit, AppRunner, CodeCatalyst). Developers on Hacker News openly worry that Kiro could be next, especially with Q Developer competing for the same internal resources.
Download Kiro: kiro.dev (macOS, Windows, Linux)
The CLI can be installed separately:
curl -fsSL https://cli.kiro.dev/install | bashGitHub (issue tracker): github.com/kirodotdev/Kiro
Head-to-Head: Key Dimensions Compared
The overview tables give you the broad picture. These sections go deeper on the dimensions that actually affect your daily workflow.
AI Code Generation Quality
In head-to-head tests reported across dev.to and Medium, Cursor tends to apply the smallest viable fix rather than redesigning entire subsystems. Professional developers who want predictable, minimal diffs prefer this conservative approach. Windsurf’s Cascade is more aggressive, planning multi-step changes autonomously and directly modifying files rather than showing sidebar diffs. Kiro’s spec-driven output is the most structured, but the quality advantage shows primarily on greenfield features where requirements are ambiguous.
For rapid prototyping, Windsurf and Cursor are faster. For building features where getting the requirements right matters more than speed, Kiro’s approach produces fewer “hallucinated” features that you didn’t ask for.
Context and Codebase Awareness
| Capability | Cursor | Windsurf | Kiro |
|---|---|---|---|
| Codebase indexing | Semantic embeddings, @codebase search | Local and remote indexing | Codebase-aware via Bedrock context |
| File references | @file, @folder, @symbol | @-mentions for files and errors | Spec references link to source files |
| Persistent context | .cursorrules (per-project) | Memories (auto-generated, local) + Rules | Steering Rules (.kiro/steering/) |
| Cross-session memory | No (per-session only) | Yes (Memories persist locally) | Steering Rules persist, no auto-memory |
| Web/docs context | @web, @docs | Web search integration | No native web search |
Cursor gives you the most explicit control over what context the AI sees. Windsurf’s Memories feature is the most “set it and forget it” approach. Kiro’s Steering Rules are the most structured but require manual setup.
Pricing Deep Dive
All three have converged on $20/month for the Pro tier. The real cost differences are in what that $20 buys you.
| Aspect | Cursor Pro ($20/mo) | Windsurf Pro ($20/mo) | Kiro Pro ($20/mo) |
|---|---|---|---|
| Effective requests | ~225 (usage-based credits) | Unlimited on SWE-1.5/1.6 models | 1,000 credits (variable per model) |
| Premium model access | Claude, GPT, Gemini (costs credits) | Claude, GPT, Gemini (costs 1-30 credits each) | Claude only (1-1.3x credits) |
| Free model option | No (all models cost credits) | Yes (SWE-1.5/1.6 cost 0 credits) | No |
| Overage | Usage-based (can spike) | API price per extra request | $0.04/credit (disabled by default) |
| BYOK savings | Yes (use own API keys) | Limited (Claude only) | No |
Windsurf offers the best raw value at the Pro tier because its proprietary SWE-1.5 and SWE-1.6 models cost zero credits. If those models meet your needs, $20/month gets you effectively unlimited usage. Cursor’s BYOK support lets cost-conscious teams route through their own API keys, bypassing Cursor’s credit system entirely for supported models. Kiro’s 1,000 credits sound generous until you realize that spec generation, context summarization, and the AI chat all consume credits.
Privacy and Security
| Capability | Cursor | Windsurf | Kiro |
|---|---|---|---|
| SOC 2 Type II | Yes | Yes | Yes (via AWS) |
| FedRAMP | No | Yes (High) | GovCloud available |
| HIPAA | No | Yes (eligible) | Via AWS BAA |
| Privacy mode | Yes (code never stored/trained on) | Telemetry opt-out available | AWS data handling policies |
| Self-hosted option | No | Yes (Enterprise) | No |
| File exclusion | .cursorignore | .codeiumignore | Not documented |
| Code training | Not with Privacy Mode | Not with telemetry disabled | Not used for training (AWS policy) |
Windsurf leads on compliance certifications with FedRAMP High and HIPAA eligibility. This matters for healthcare, finance, and government teams. Cursor’s Privacy Mode is well-documented and used by over 50% of its users. Kiro inherits AWS’s broad compliance framework but doesn’t yet have the IDE-specific certifications that enterprise security teams look for.
Extension and Plugin Ecosystem
All three use the Open VSX registry instead of Microsoft’s VS Code Marketplace. This means roughly 90% of VS Code extensions work, but Microsoft-proprietary extensions (C# Dev Kit, Remote SSH, Live Share, Pylance) are unavailable across all three IDEs.
Windsurf has an edge here: it ships open-source plugins for Vim, Neovim, Visual Studio, and other editors. If your team uses JetBrains or Neovim, Windsurf is the only one of the three that meets you where you are (with AI features, at least). Cursor and Kiro are standalone editors only.
What the Community Actually Says
Marketing copy says one thing. Developers on Reddit and Hacker News say another. Here’s the unfiltered sentiment from real users.
On Cursor
The praise centers on Composer’s multi-file editing. Developers consistently describe going from hours of manual refactoring to 20-minute Composer sessions. The .cursorrules feature has developed a community of its own, with teams sharing project-specific AI instructions on r/cursor.
The backlash centers on pricing. Cursor’s Trustpilot score sits at 1.7 across 203 reviews, driven almost entirely by the June 2025 credit system change. One Hacker News user reported “$350 in Cursor overage in a week.” The rate limiting (1 request/minute, 30/hour) frustrates developers in deep flow states.
On Windsurf
Windsurf’s Cascade gets credit for proactive codebase awareness. The switching story that comes up repeatedly: developers who moved from Cursor to Windsurf cite the simpler pricing (before March 2026 equalization), better Claude Sonnet implementation with larger context windows, and fewer hallucinations.
Those who switched back to Cursor cite the need for fine-grained context control (@codebase, @files shortcuts) and more reliable multi-file refactoring. The ownership uncertainty is the elephant in every Windsurf discussion thread.
On Kiro
Early adopters appreciate the spec-driven workflow as “a surprisingly useful thinking partner” for breaking down rough ideas into structured plans. The code quality from Claude Sonnet 4 gets genuine praise.
The complaints are louder: credits disappear fast, tasks get stuck and lose context, and the lack of native AWS service integration (from an AWS product) confuses everyone. The trust deficit from AWS’s track record of killing developer tools comes up in nearly every Hacker News thread about Kiro.
The Emerging Pattern: IDE + CLI Combo
A growing segment of senior engineers reported using a split setup: Cursor or Windsurf for daily editing combined with Claude Code (Anthropic’s terminal-based agent) for complex reasoning tasks like refactors, architecture decisions, and multi-repo changes. The total cost runs $40 to $220 per month, but developers describe it as “the sweet spot” where each tool handles what it’s best at.
Who Should Use What
After synthesizing documentation, community feedback, and real switching stories, here’s the practical guidance.
| Developer Profile | Best Pick | Why |
|---|---|---|
| Solo dev shipping MVPs fast | Windsurf | Cascade autonomy, zero-cost SWE models, beginner-friendly |
| Senior dev who wants control | Cursor | .cursorrules, explicit @-mentions, conservative diffs, BYOK |
| Enterprise with compliance needs | Windsurf | FedRAMP, HIPAA, self-hosted option, 40+ IDE plugins |
| Teams with ambiguous requirements | Kiro | Spec-driven workflow forces clarity before code generation |
| AWS-heavy teams | Kiro (with caution) | Bedrock integration, IAM Identity Center, but watch for service discontinuation |
| GitHub-native teams | VS Code + Copilot | Seamless PR/issue/CI integration, lowest friction, $10/month |
| Mixed-IDE teams (JetBrains + VS Code) | Windsurf | Only one with plugins for JetBrains, Vim, Neovim, Visual Studio |
| Cost-sensitive developers | Windsurf (SWE models) or Cursor (BYOK) | Zero-credit SWE models, or bring your own cheaper API keys |
Download Links and Getting Started
| IDE | Download URL | Platforms | Authentication |
|---|---|---|---|
| Cursor | cursor.com/downloads | macOS (ARM64, x64), Windows (x64, ARM64), Linux (.deb, .rpm, AppImage) | Email or GitHub |
| Windsurf | windsurf.com/download/editor | macOS (Intel, Apple Silicon), Windows, Linux (.deb, .rpm, .tar.gz) | Email, GitHub, or Google |
| Kiro | kiro.dev | macOS, Windows, Linux | GitHub, Google, AWS Builder ID, or IAM Identity Center |
All three offer free tiers, so the best way to decide is to install two of them and spend a week with each on a real project. Migration from VS Code is straightforward for all three since they’re all VS Code forks: settings, keybindings, themes, and most extensions transfer directly.
Frequently Asked Questions
Can I use my own API keys with these IDEs?
Cursor has the most complete BYOK support: OpenAI, Anthropic, Google, and Azure OpenAI keys all work. Windsurf supports BYOK for Claude 4 Sonnet and Opus only. Kiro does not support BYOK at all; it routes everything through Amazon Bedrock.
Are any of these IDEs open source?
None of the three are open source. All three are proprietary VS Code forks. Cursor and Kiro maintain GitHub repositories that function as issue trackers and community forums, not source code repos. Windsurf publishes open-source plugins for Vim, Neovim, and Visual Studio, but the IDE itself is closed source.
Which one has the best free tier?
Windsurf’s free tier is the most generous because the SWE-1.5 and SWE-1.6 models cost zero credits, giving you functional AI assistance without hitting a paywall quickly. Cursor’s free tier provides limited agent requests and tab completions. Kiro’s 50 credits per month is the most restrictive, with users reporting they run out in a single coding session.
What happens to Windsurf now that Cognition owns it?
Cognition acquired Windsurf’s product, brand, IP, and remaining team in July 2025 for approximately $250 million. Windsurf continues operating as a standalone product. Cognition has stated that Devin (their autonomous coding agent) and Windsurf are complementary, but the long-term integration roadmap is unclear. The original founders (Varun Mohan and Douglas Chen) left for Google.
Will AWS discontinue Kiro like they did CodeCommit?
There’s no official statement either way. AWS invested heavily in Kiro’s GA launch and re:Invent 2025 keynote presence, which suggests serious commitment. The Q Developer CLI was merged into Kiro’s CLI, indicating consolidation rather than competition. That said, the AWS developer tools track record (CodeCommit, AppRunner, CodeCatalyst) gives developers legitimate reason to watch for signals before going all-in.
