Skip to content

AI-native editors: Cursor, Windsurf, Kiro and Antigravity

  • What makes an editor “AI-native”, and how that differs from an AI extension or a terminal coding agent.
  • How the four editors covered on this site differ in approach, as of November 2026.
  • The shared building blocks (project rules, MCP servers, checkpoints, model choice) and how to make them portable.
  • How to choose and roll out an editor for a team, and what goes wrong.

An AI-native editor is a development environment built around AI assistance rather than one with AI added as a plugin. All four editors covered here started as forks of Visual Studio Code, so extensions, keybindings and settings mostly carry over, and all four now put agents at the center: you describe a task, an agent reads the codebase, edits several files, runs commands and tests, and you review the result as a diff.

They differ in workflow philosophy. Cursor is the broad, model-agnostic option, and since Cursor 3 (April 2026) it has an agent-first workspace for running several agents in parallel. Windsurf, owned by Cognition since 2025, was renamed Devin Desktop in June 2026 and now leads with an agent command center. AWS Kiro is built around spec-driven development: requirements, design and tasks are written and reviewed before code. Google Antigravity pairs an editor with an agent manager and Gemini models.

Context: editor, extension or terminal agent?

Section titled “Context: editor, extension or terminal agent?”

There are three ways to bring AI into everyday coding, and most teams end up using more than one:

Form Examples Strength Weakness
AI-native editor Cursor, Devin Desktop, Kiro, Antigravity Tight integration: inline completions, multi-file diffs, agent panels, codebase index Switching editors; a fork can lag upstream VS Code
Extension in an existing editor GitHub Copilot in VS Code, Visual Studio or JetBrains IDEs Keep your editor and its ecosystem; central admin for organizations Less control over the editor’s interface
Terminal and cloud agents Claude Code, Codex, Gemini CLI Editor-independent, scriptable, run in CI or in the cloud Less visual review inside the editor

The lines are blurring. Editors now run background and cloud agents, terminal agents integrate with editors, and several products ship both an editor and a CLI. The useful question is not which category, but where your team wants to review and approve the agent’s work.

Snapshot as of November 16, 2026, from vendor announcements and release notes found through search. These products ship updates weekly; confirm details in each vendor’s changelog.

Editor Approach Models Notable in 2026 Read more
Cursor General-purpose AI editor; agents, inline edits and Tab completions Several vendors’ models plus Cursor’s own (Composer) Cursor 3 (April 2026) added an agent-first workspace for parallel agents across repositories, worktrees and cloud environments Cursor, installation
Windsurf, now Devin Desktop Agentic editing, now organized around an “agent command center” Several vendors’ models plus Cognition’s own Renamed Devin Desktop on June 2, 2026, delivered as an update to existing installs Windsurf
AWS Kiro Spec-driven: requirements, design and task list before implementation Hosted models selected by Kiro Generally available with a CLI; steering files, hooks and MCP; property-based tests checked against specs Kiro, steering, hooks
Google Antigravity Editor plus an agent manager for running and supervising several agents Gemini models (see Google models) Public preview began November 2025 alongside Gemini 3; later releases extended the agent manager Antigravity

What actually separates them in daily use:

  • How work is planned. Kiro makes the plan a reviewed document. Cursor, Devin Desktop and Antigravity let the agent plan inside the conversation, with optional plan modes. Spec-first costs time on small changes and pays off on features that touch many files or need sign-off.
  • Where agents run. Locally in the editor, in separate Git worktrees, or in vendor cloud sandboxes. Cloud agents free your machine but need repository access and secrets in someone else’s environment.
  • Model choice and lock-in. Cursor and Devin Desktop offer several vendors’ models; Antigravity centers on Gemini. Being able to switch models matters when a model is retired or a better one ships.
  • Administration. Single sign-on, central policy for allowed models and MCP servers, privacy modes, and audit logs vary by plan; check them before a team rollout.

The concepts are common even where file names differ.

  • Project rules tell the agent how your codebase works: build and test commands, conventions, what not to touch. Cursor uses project rules, Kiro uses steering files in .kiro/steering/, and many tools also read an AGENTS.md file at the repository root, an open format described at agents.md as “a README for agents”.
  • MCP servers connect the agent to tools and data: issue trackers, databases, documentation. One server works across editors that support the Model Context Protocol. See the Kiro MCP overview for a worked setup.
  • Checkpoints and diffs let you review and roll back what an agent changed. Commit before large agent tasks anyway; Git is the checkpoint every tool understands.
  • Codebase indexing builds a searchable representation of your code so the agent can find relevant files. Check where the index is stored and what leaves your machine.
  • Hooks and automations run actions on events, such as tests after a save or a check before a commit (Kiro hooks, MCP versus hooks).

Writing project instructions once in AGENTS.md keeps them usable when developers prefer different tools. A fragment for the invented OrdersPortal repository (not executed; it is configuration text, not code):

# AGENTS.md - OrdersPortal
## Build and test
- Install: `npm ci`
- Unit tests: `npm test`; run them before proposing any change.
- Type check: `npm run typecheck`
## Conventions
- API handlers live in `src/api/`; one file per resource.
- Money is stored in integer cents; never use floating point for amounts.
- Every new endpoint needs a test in `tests/api/`.
## Boundaries
- Do not edit files under `migrations/`; ask a person to write migrations.
- Never commit secrets or `.env` files.
- Refund logic in `src/payments/` changes only with a reviewer from the payments team.

Tool-specific files (Cursor rules, Kiro steering) can then hold only what is unique to that tool, or point to AGENTS.md.

  1. Pilot on real work. Pick two or three teams and a month of normal tickets, and measure review time, defects found after merge and developer satisfaction, not only lines generated.
  2. Write the rules file first. Most early disappointment comes from agents that do not know how to build, test or follow conventions.
  3. Decide the data posture. Which repositories may be indexed, which models may be used, whether privacy mode is required, and which MCP servers are approved.
  4. Keep review standards. Agent-written code goes through the same pull request review, tests and security scanning as any other code.
  5. Re-evaluate quarterly. Products, models and pricing change fast; avoid long commitments without an exit path.
  • Large, unreviewed diffs. Agents change many files at once and reviewers skim. Ask for smaller steps, and use specs or plans for large changes.
  • Plausible but wrong code. Invented APIs, missing edge cases, tests rewritten to pass. Require tests to run, and read the tests the agent changed.
  • Secrets and data exposure. Indexing or sending .env files, customer data in fixtures, or tokens pasted into chat. Use ignore files, privacy modes and secret scanning.
  • Untrusted MCP servers and extensions. A tool server is code with access to your environment; install only reviewed ones (Risks of agentic AI).
  • Commands run without care. Agents that run shell commands can delete files or call production systems. Keep approval for commands on, at least for anything outside tests and builds.
  • Fork drift. VS Code forks may lag upstream releases or lack some marketplace extensions; check the extensions your team depends on.
  • Cost surprises. Agent modes consume far more model usage than completions; watch usage-based plans.
  • Your team is productive in another IDE (JetBrains, Visual Studio, Xcode) and an extension or terminal agent covers the need.
  • Code cannot leave the machine and the editor’s privacy options do not meet your rules; consider local models with an editor that supports them.
  • The work is mostly small, well-understood edits where completions in your current editor are enough.

1. What is the practical difference between an AI-native editor and an AI extension? An AI-native editor controls the whole interface, so agents, diffs, indexing and completions are designed together. An extension works within the host editor’s extension points, which limits the interface but keeps the editor and its ecosystem. For organizations the trade is integration depth against switching cost and central administration.

2. Why write an AGENTS.md or rules file, and what belongs in it? Agents start without knowledge of how the project builds, tests and is organized, so they guess. A rules file gives commands, conventions and boundaries (files not to touch, reviews required). Keep it short and factual, and keep it in the repository so it is versioned and reviewed like code.

3. When is spec-driven development worth the overhead? For features that span several files or services, need sign-off, or will be implemented by agents in several steps. The written requirements, design and task list catch misunderstandings before code exists and give reviewers something to check the result against. For a one-line fix it is overhead.

4. Senior scenario: leadership wants every developer on one AI editor by next quarter. How do you approach it? Run a time-boxed pilot with a few teams on real tickets, measuring review time, escaped defects and satisfaction against a baseline. In parallel, settle the data posture (indexing, privacy mode, approved models and MCP servers), identity and audit requirements, and cost. Put a portable AGENTS.md in key repositories so the choice of tool stays reversible. Recommend based on the measurements, allow an extension-based path for teams on other IDEs, and keep pull request review and security scanning unchanged.

  • All four editors are VS Code forks that now center on agents; they differ in planning style, where agents run and model choice.
  • Windsurf is now Devin Desktop; Cursor 3 introduced an agent-first workspace; Kiro is spec-first; Antigravity is Gemini-centered.
  • Project rules, MCP servers, checkpoints and indexing are the shared building blocks; keep rules portable with AGENTS.md.
  • Keep normal review, testing and secret hygiene for agent-written code.
  • Products change monthly: pilot, measure, and keep an exit path.