AI IDEs exploded from "Copilot in VS Code" to Cursor, Kiro, Zed, Windsurf, and a pile of others in less than two years. None are just UI reskins; each has real architectural differences. If you’re burning money on stacked subscriptions (been there), you need to know what each is actually for — and how to plug them into your automation pipeline.
How They're Really Built
VS Code with GitHub Copilot
Copilot is a VS Code extension. You get:
- Inline ghost code: shows up as you type, classic Copilot
- Chat panel: ask stuff, get code, with
@workspacefor context - Edits mode: single prompt triggers multi-file changes
It's OpenAI behind the curtain (GPT-4o, "o3"), but Copilot just boosts VS Code. You’re still driving the code — Copilot’s just an assistant.
When it fits: You already live in VS Code and want autocomplete plus an occasional code genie.
Cursor
Cursor gutted and rebuilt VS Code to make AI central — not just an extension. Key differences:
- Composer mode: Describe a change; get multi-file diffs, apply/reject each change before commit.
- Semantic search: Finds relevant code anywhere in your repo.
.cursorrules: Project-wide instructions baked into every AI message.- Direct model swaps: Pick GPT-4.1, Claude Sonnet, even your local Ollama instance.
Composer is the killer feature. Example: “Switch file uploads to S3, update all handlers.” It’ll show every plan and patch, you greenlight what ships.
When it fits: Big refactors, adding features, or codebase-wide sweeps. If you want a step-by-step delta before merging.
Kiro (Amazon)
Kiro is the most opinionated: specs in, code out. No back-and-forth chat. You define a feature spec, Kiro builds, tests, and iterates on its own.
How it works:
- Spec files:
.kiro/specs/feature.md— explicit requirements, models, acceptance tests - Hooks: Triggers on file save, lint/test fail, etc.
- Autonomous agent: Writes code, executes tests, loops until green
Sample spec:
# .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
Feed it the spec — Kiro generates the plan, writes code, runs tests, and patches failures, no handholding.
When it fits: New features, automation, and anywhere you can write a decent spec.
Quick Feature Shootout
| Feature | VS Code Copilot | Cursor | Kiro |
|----------------------|-----------------|-------------------|---------------|
| Inline autocomplete | ✅ Best | ✅ Good | ✅ Decent |
| Multi-file edits | ✅ Edits mode | ✅ Composer | ✅ Agent |
| Project search | ✅ @workspace | ✅ Semantic index | ✅ Spec-aware |
| Full autonomy | ❌ | Limited | ✅ Yes |
| Custom instructions | ✅ Per-repo | ✅ .cursorrules | ✅ Specs |
| Local model support | Limited | ✅ Ollama | ❌ |
| Price (2026) | $10/mo | $20/mo | $19/mo |
| Electron/CDP | Electron | Electron fork | Electron |
| CDP automation | ✅ | ✅ | ✅ |
Programmatic IDE Control (CDP)
All three use Electron, so they expose a Chrome DevTools Protocol (CDP) endpoint. This lets you drive the UI with code — click stuff, trigger edits, copy results out — zero mouse/keyboard required.
I've automated all three using Playwright + chromium.connect_over_cdp(). Feels weird but works.
Spinning Each IDE Up with CDP
# VS Code
code --remote-debugging-port=9222 /your/project
# Cursor
cursor --remote-debugging-port=9223 /your/project
# Kiro
kiro --remote-debugging-port=9224 /your/project
Simple Playwright Automation (Python)
from playwright.async_api import async_playwright
import asyncio
async def control_cursor_ide():
async with async_playwright() as p:
browser = await p.chromium.connect_over_cdp("http://localhost:9223")
ctx = browser.contexts[0]
pages = ctx.pages
# Find main workbench webview
wb = next(page for page in pages if 'workbench' in page.url or page.url.startswith('vscode-file://'))
await wb.keyboard.press("Control+Shift+P")
await wb.keyboard.type("Cursor: Open Composer")
await wb.keyboard.press("Enter")
await asyncio.sleep(1)
await wb.keyboard.type("Refactor the auth module to use refresh tokens. Update all callers. Run tests and fix any failures.")
await wb.keyboard.press("Enter")
await wb.wait_for_selector('[data-testid="composer-complete"]', timeout=120_000)
print("Composer task completed")
asyncio.run(control_cursor_ide())
Swap port/command for Kiro or VS Code Copilot as needed.
Generalizing: The IDEBridge Pattern
This is basically how we bridge an agent to sub-task code generation in any IDE that's running and ready to take orders:
class IDEBridge:
def __init__(self, ide: str, port: int):
self.ide = ide # "cursor", "kiro", "vscode"
self.port = port
async def connect(self):
from playwright.async_api import async_playwright
self.pw = await async_playwright().start()
self.browser = await self.pw.chromium.connect_over_cdp(f"http://localhost:{self.port}")
async def run_task(self, task: str) -> str:
context = self.browser.contexts[0]
wb = context.pages[0]
if self.ide == "cursor":
await wb.keyboard.press("Control+Shift+P")
await wb.keyboard.type("Cursor: New Composer Session")
await wb.keyboard.press("Enter")
await wb.keyboard.type(task)
await wb.keyboard.press("Control+Enter")
elif self.ide == "kiro":
await wb.keyboard.press("Control+Shift+P")
await wb.keyboard.type("Kiro: Start Agent Task")
await wb.keyboard.press("Enter")
await wb.keyboard.type(task)
await wb.keyboard.press("Enter")
return await self._wait_for_completion(wb)
async def _wait_for_completion(self, page, timeout_ms=180_000):
start = asyncio.get_event_loop().time()
while True:
await asyncio.sleep(3)
elapsed = (asyncio.get_event_loop().time() - start) * 1000
if elapsed > timeout_ms:
return "timeout"
# Insert IDE-specific UI checks here
That’s straight out of brand_cron.py and our agent code, just simplified.
When I’ll Use Each One
- VS Code Copilot: I just want rapid autocomplete. I’m already in VS Code, don’t need AI changing everything.
- Cursor: Big refactor, greenfield feature, or want to control every delta.
.cursorrulesenforce team style. I use local Ollama with it sometimes to cut latency/cost. - Kiro: New API or feature from a bullet list, especially if I want 10 test cases written and passing in a loop with zero touch.
How The Pricing Actually Shakes Out
If you bang on Claude Sonnet or GPT-4 for hours, it’ll nuke $40-80/day in API credits. Cursor and Kiro roll fat model quotas into $20/mo — unlimited, if you script right. I use the IDE bridge trick to route heavy jobs through these subs, run agent workflows, and pay near zero marginal cost. That’s the arbitrage if you build automations on top.
Want the same automation? NEPA AI’s IDE Bridge Pack wires up Cursor, Kiro, and Copilot for agent delegation. Point your orchestration at axon.nepa-ai.com, pick your task, get code back per IDE strengths.
→ Get the IDE Bridge Pack at axon.nepa-ai.com
Stop burning OpenAI credits for what Cursor or Kiro already covers in a subscription.
Keychron K2 Wireless Mechanical Keyboard →
