AI Code IDEs Compared: Cursor vs Kiro vs VS Code Copilot (and How to Control Them via CDP)

The AI IDE market fragmented fast. In 2024 you had GitHub Copilot autocomplete and not much else. In 2026 you have Cursor (chat + edit), Kiro (agentic specs), VS Code Copilot (inline + workspace), Windsurf (flow-based), and Zed (collaborative). Each is genuinely different — not just reskins.

If you're paying for multiple subscriptions, you should know what each one is actually good at — and how to programmatically delegate tasks to whichever fits the job.

The Core Architectural Differences

VS Code + GitHub Copilot

Copilot integrates into VS Code as an extension. It has three primary surfaces:

• Inline completions: ghost text as you type (the original feature)
• Chat panel: conversational code help with @workspace context
• Edits mode: multi-file changes from a single instruction

Copilot uses a mix of OpenAI models (GPT-4o, o3) behind the scenes. The key architectural constraint: it enhances VS Code, it doesn't replace it. You still drive the editor. Copilot assists.

Best for: developers who live in VS Code and want AI to stay in the background, available when called.

Cursor

Cursor is a VS Code fork that makes AI a first-class citizen rather than a plugin. Notable differences from Copilot:

• Composer mode: multi-file edits with full diff view, accept/reject per change
• Codebase indexing: semantic search across your entire project, not just the current file
• .cursorrules: project-specific instructions baked into every conversation
• Direct model selection: choose GPT-4o, Claude, or local models per conversation

The Composer is where Cursor earns its subscription. You describe a feature, it plans edits across 5-10 files, shows you exactly what changes, and lets you selectively apply them.

Best for: refactoring, feature development, when you need to see the full delta before committing.

Kiro (Amazon)

Kiro takes the most opinionated approach: spec-first development. Instead of chatting with an AI, you write a spec for what you want to build, Kiro generates a task breakdown, then executes the tasks autonomously.

Key concepts:

• Spec files: .kiro/specs/feature-name.md — structured description of requirements, data models, and acceptance criteria
• Hooks: AI actions that trigger on file save, lint failure, test failure
• Agent mode: Kiro can autonomously run tests, fix failures, and iterate

# .kiro/specs/user-auth.md

## Requirements
- Email/password registration
- JWT-based session tokens
- Password reset via email

## Data Models
User: { id, email, password_hash, created_at }
Session: { token, user_id, expires_at }

## Acceptance Criteria
- POST /auth/register creates user and returns token
- POST /auth/login validates and returns new token
- POST /auth/reset sends reset email within 60s

Kiro reads this spec, generates an implementation plan, writes the code, runs the tests, and fixes failures — all autonomously.

Best for: greenfield features, when you want to specify what and have AI handle how.

Head-to-Head Feature Matrix

| Feature | VS Code Copilot | Cursor | Kiro | |---|---|---|---| | Inline autocomplete | ✅ Best-in-class | ✅ Good | ✅ Good | | Multi-file editing | ✅ Edits mode | ✅ Composer | ✅ Agent mode | | Codebase context | ✅ @workspace | ✅ Indexed search | ✅ Project-aware | | Autonomous execution | ❌ | Limited | ✅ Full agent | | Custom instructions | ✅ Per-repo | ✅ .cursorrules | ✅ Spec files | | Local model support | Limited | ✅ Via Ollama | ❌ | | Price (2026) | $10/mo | $20/mo | $19/mo | | Runs in Electron | Yes (VS Code) | Yes (fork) | Yes | | CDP accessible | ✅ | ✅ | ✅ |

Controlling IDEs via Chrome DevTools Protocol (CDP)

Here's where things get interesting for automation. All three IDEs are Electron apps — which means they expose a CDP endpoint you can connect to and drive programmatically. This is exactly how AI agents can delegate tasks to IDEs without human interaction.

Starting an IDE with CDP enabled

# VS Code
code --remote-debugging-port=9222 /path/to/project

# Cursor
cursor --remote-debugging-port=9223 /path/to/project

# Kiro
kiro --remote-debugging-port=9224 /path/to/project

Connecting via Playwright

from playwright.async_api import async_playwright
import asyncio

async def control_cursor_ide():
    async with async_playwright() as p:
        # Connect to existing Cursor instance
        browser = await p.chromium.connect_over_cdp(
            "http://localhost:9223"
        )
        
        # Get the main page (VS Code / Cursor webview)
        context = browser.contexts[0]
        pages = context.pages
        
        # Find the workbench page
        workbench = next(
            page for page in pages 
            if 'workbench' in page.url or page.url.startswith('vscode-file://')
        )
        
        # Open the command palette
        await workbench.keyboard.press("Control+Shift+P")
        await workbench.keyboard.type("Cursor: Open Composer")
        await workbench.keyboard.press("Enter")
        
        await asyncio.sleep(1)
        
        # Type a task into Composer
        await workbench.keyboard.type(
            "Refactor the authentication module to use refresh tokens. "
            "Update all callers. Run tests and fix any failures."
        )
        await workbench.keyboard.press("Enter")
        
        # Wait for completion signal (check for specific UI state)
        await workbench.wait_for_selector(
            '[data-testid="composer-complete"]',
            timeout=120000  # 2 min timeout
        )
        
        print("Composer task completed")

asyncio.run(control_cursor_ide())

Practical Agent Delegation Pattern

The real use case: your orchestrating agent decides "this task needs IDE-level code editing" and delegates to whichever IDE is available:

class IDEBridge:
    def __init__(self, ide: str, port: int):
        self.ide = ide  # "cursor", "kiro", "vscode"
        self.port = port
        self.playwright = None
        self.browser = None
    
    async def connect(self):
        from playwright.async_api import async_playwright
        self.playwright = await async_playwright().start()
        self.browser = await self.playwright.chromium.connect_over_cdp(
            f"http://localhost:{self.port}"
        )
    
    async def run_task(self, task: str) -> str:
        """Send a task to the IDE's AI assistant and wait for completion."""
        context = self.browser.contexts[0]
        workbench = context.pages[0]
        
        if self.ide == "cursor":
            # Open Cursor Composer
            await workbench.keyboard.press("Control+Shift+P")
            await workbench.keyboard.type("Cursor: New Composer Session")
            await workbench.keyboard.press("Enter")
            await workbench.keyboard.type(task)
            await workbench.keyboard.press("Control+Enter")
            
        elif self.ide == "kiro":
            # Open Kiro agent panel
            await workbench.keyboard.press("Control+Shift+P")
            await workbench.keyboard.type("Kiro: Start Agent Task")
            await workbench.keyboard.press("Enter")
            await workbench.keyboard.type(task)
            await workbench.keyboard.press("Enter")
        
        # Poll for completion (implementation varies by IDE)
        return await self._wait_for_completion(workbench)
    
    async def _wait_for_completion(self, page, timeout_ms=180000):
        """Monitor IDE for task completion indicators."""
        start = asyncio.get_event_loop().time()
        while True:
            # Check for completion indicators in IDE UI
            # This varies — check spinner disappearance, status bar, etc.
            await asyncio.sleep(3)
            elapsed = (asyncio.get_event_loop().time() - start) * 1000
            if elapsed > timeout_ms:
                return "timeout"
            # Add IDE-specific completion checks here

When to Use Which IDE

Use VS Code Copilot when:

• You want AI assistance without changing your workflow
• You're already paying for GitHub
• You want autocomplete to be the primary mode

Use Cursor when:

• You're doing significant refactoring or feature work
• You want to review every change before applying it
• You need .cursorrules for consistent coding style across the team

Use Kiro when:

• You're building new features from specs
• You want autonomous test-and-fix loops
• You have well-defined acceptance criteria to give it

The Subscription Arbitrage Play

Here's the economics: if you're using Claude Sonnet via a direct API for 8 hours of coding/day, you're spending $40-80/day in API credits. Cursor and Kiro bundle heavy model usage into flat subscriptions.

A single Cursor subscription pays back in 1-2 hours of heavy use. The IDE bridge skill lets you delegate to these subscriptions from your orchestration agent — effectively running high-compute coding tasks at $0 marginal cost per the models bundled in the IDE subscription.

---

The NEPA AI IDE Bridge Pack gives your agent the ability to delegate coding tasks to Cursor, Kiro, and VS Code Copilot automatically — choosing the best tool for each task type and reporting results back to your orchestration pipeline.

→ Get the IDE Bridge Pack at /shop/ide-bridge-pack

Stop paying per-token for tasks an IDE subscription already covers.