Cursor · PiniShv

The IDE Is Becoming Mission Control

Sun, 05 Apr 2026 10:00:00 +0200

Something happened in the last few months that’s bigger than any single product launch.

Cursor 3 rebuilt its interface from scratch “centered around agents.” GitHub Agent HQ calls its control surface “mission control.” VS Code describes itself as “your home for multi-agent development.” JetBrains Air says the quiet part out loud: traditional IDEs add tools to the editor, while Air “builds tools around the agent.”

That’s not one company experimenting. That’s every major vendor converging on the same architectural shift.

The IDE is becoming mission control. The file tree isn’t disappearing. It’s just no longer the main character.

What actually changed
#

I wrote about how AI IDEs work last year. Back then the story was three systems in a trench coat: autocomplete, context engine, agent harness. The editor was still the center. The AI was a feature bolted on.

That’s not what’s happening now. The center of gravity is moving. The primary surface is shifting from “navigate files and type code” to “assign, monitor, steer, and review agent work.”

Look at what the vendors are actually building:

Cursor 3 puts all local and cloud agents in one sidebar, including ones started from mobile, web, Slack, GitHub, and Linear. That’s closer to an operations console than a code explorer.

GitHub added an Agents tab directly inside repositories with a “mission control style view.” You choose from a fleet of agents, assign work in parallel, and track progress from any device. I covered Agent HQ when it launched. This is the next step.

Windsurf added parallel multi-agent sessions, Git worktrees, and side-by-side Cascade panes. Its vocabulary is plans, todo lists, queued messages, simultaneous cascades, and workflows. That’s orchestration language, not file navigation language.

Replit says the platform became “Agent-first.” Agent 4 adds parallel agents, visible task progress, and the ability to design while the agent builds in the background. That’s basically a kanban board fused with an IDE.

Firebase Studio describes itself as an agentic cloud-based development environment. But Google’s newer Antigravity is the one that says the quiet part out loud. Their tagline: “evolving the IDE into the agent-first era.” They explicitly frame it as: “the tools of yesterday focused on helping you write code faster; the tools of tomorrow need to help you orchestrate it.” That’s not an AI feature added to an editor. That’s a new product category.

Zed added Agentic Editing, third-party agents through ACP, and says the goal is switching between multiple agents without switching editors. Their roadmap includes subagent support and multi-agent collaboration.

Every one of these announcements uses the same vocabulary: agents, sessions, tasks, parallel work, orchestration, monitoring. Not files, buffers, tabs, and syntax highlighting.

Not everyone is moving at the same speed
#

There’s useful nuance here.

VS Code and Zed are still fundamentally editors that are becoming multi-agent hosts. The file tree is still front and center. The agents are a powerful addition, but the architecture is additive.

Cursor, Windsurf, and Replit are further along. The center of gravity has shifted toward session and task management. The code is still there, but it’s becoming a drill-down surface rather than the starting point.

JetBrains Air and Google Antigravity are the clearest examples of vendors saying, explicitly, that the editor is no longer the thing the rest of the product is built around. Air exists specifically because JetBrains decided another editor wasn’t enough differentiation and killed Fleet to focus on agentic workflows.

That spectrum matters. If you’re evaluating tools for your team, know where on this axis you’re comfortable. Some teams want an editor that happens to run agents. Some want an agent platform that happens to have an editor. Those are different products for different stages of trust.

What this actually means
#

This is a change in power structure.

For decades, the code editor held a monopoly as the primary surface of software development. You lived in it. Everything started there. The file tree was your map of the project.

That monopoly is ending. The editor is becoming one pane inside a larger agent-control system. You still need it. But you also need a task view, a session manager, an agent roster, a monitoring surface, and a way to review what shipped while you were doing something else.

I wrote about Cursor Automations triggering agents from events. I wrote about Claude’s computer use controlling your desktop from your phone. I wrote about DeerFlow orchestrating sub-agents in sandboxes. All of those are pieces of the same shift. The IDE is becoming the place where you manage all of it.

The engineers who adapt will treat their IDE the way a DevOps engineer treats a dashboard: a control surface for work happening across multiple systems, some of it human, some of it autonomous, most of it concurrent.

The ones who don’t will wonder why their editor feels increasingly like the wrong tool for the job.

How is your IDE workflow changing with agents? Still file-first or shifting to something else? I’d love to hear it. Find me on X or Telegram.

Cursor Automations: Your AI Just Stopped Waiting for Permission

Mon, 23 Mar 2026 09:00:00 +0200

I wrote last year that the developer’s work didn’t change, the sequence did. AI moved context gathering and scaffolding earlier. You opened your laptop to a draft instead of a blank file.

On March 5, Cursor moved the sequence again. Automations lets AI agents trigger without you prompting them. A Slack message, a Git push, a PagerDuty alert, a cron timer. The agent spins up a cloud sandbox, follows instructions you’ve defined, uses your configured MCPs and models, and reports back via PR, Slack, or ticket.

No human in the prompt loop. That’s a different category of tool.

What it actually does
#

Three trigger types: scheduled timers (hourly, nightly, weekly), external signals (Slack, Linear, PagerDuty, GitHub webhooks), and code events (new PRs, branch pushes, test failures).

Cursor is already using this internally. Security reviews on every code push. Risk classification that auto-approves low-risk PRs. Incident response kicked off by PagerDuty alerts. Weekly repo change summaries. Bug report triage. Test coverage identification.

The agents also have a memory tool that lets them learn from past runs. So the security review agent that ran on Monday remembers context when it runs on Friday.

This isn’t an assistant waiting for your question. It’s a coworker that works a different shift.

How the others compare
#

GitHub Copilot’s coding agent is the closest competitor. It already handles tasks end-to-end: assign an issue, the agent works autonomously, opens a PR. As of March 2026, agent hooks are in public preview, letting you run custom commands at key points during agent sessions. It also reviews its own changes before opening PRs and runs security scanning automatically. The big advantage is distribution: it lives where most teams already work (GitHub, VS Code, JetBrains). The limitation is that event triggers are still more constrained than Cursor’s broad webhook and Slack integration.

Claude Code is Anthropic’s terminal-based agent. It manages files, Git, shell commands, and tests independently of any IDE. Powerful for deep, autonomous coding sessions. But it doesn’t have event-driven triggers yet. You start it, it works, it finishes. There’s no “trigger Claude Code when a PagerDuty alert fires.” That gap will likely close, but right now it’s a different paradigm: on-demand autonomy versus always-on automation.

JetBrains Air launched the same month as an agentic development environment. It orchestrates multiple agents (Codex, Claude, Gemini, Junie) running in parallel in isolated containers. It’s the closest thing to “mission control for agents.” But it’s focused on delegating tasks and monitoring progress, not on event-driven automation. You still tell Air what to do. Cursor Automations lets the system tell the agent what to do.

Amazon Q doesn’t have event-driven features yet, but analysts expect an announcement soon. Given AWS’s strength in event-driven architecture (Lambda, EventBridge, Step Functions), their version could be interesting when it arrives.

Why this matters
#

The shift from “I prompt the AI” to “the system triggers the AI” changes the organizational model for engineering teams. Security reviews can happen on every push without a human bottleneck. Triage can happen before anyone looks at their morning tickets. Maintenance tasks can run on a schedule nobody has to remember.

But it also means more code being generated and committed with less human involvement per change. If your team is already struggling with understanding what shipped (and the data suggests many are), autonomous agents running on triggers will accelerate that gap.

The teams that will get the most out of this are the ones with strong guardrails already in place: good CI, real tests, meaningful review standards, and engineers who understand the systems well enough to evaluate what the agent produced. The teams that will get burned are the ones hoping automation replaces the discipline they never built.

Cursor crossed $2 billion in annual revenue in about 18 months, roughly 20x faster than GitHub Copilot reached $100 million ARR. That’s not just hype. Engineers are voting with their wallets. Automations is the bet that the next step isn’t a better copilot. It’s an always-on agent layer that treats your codebase as a continuously monitored system.

The sequence changed again. The question is whether your engineering practices changed with it.

Using Cursor Automations or building event-driven agent workflows? I’d love to hear what triggers you’re running. Find me on X or Telegram.

AI Is Now Reviewing AI's Code. That Should Make You Think.

Mon, 23 Mar 2026 07:00:00 +0200

Three things happened in the first two weeks of March 2026.

Anthropic launched Code Review for Claude Code. A multi-agent system that automatically reviews GitHub pull requests, dispatching specialized agents that analyze code for bugs, security issues, and logic errors. Internally at Anthropic, 54% of PRs now receive substantive review comments, up from 16%.

Cursor shipped Automations with security review triggers that fire on every code push. No human initiates the review. The system does.

GitLab made agentic code reviews available at $0.25 per review, including false positive detection for security scanning.

The industry is converging on the same answer to the same problem: AI generates more code than humans can review, so AI should review it too.

That answer is partly right. And partly something we should think harder about.

The bottleneck is real
#

Anthropic’s own numbers make the case. Their code output grew 200% year-over-year, but their human review capacity didn’t. That’s not unique to Anthropic. Any team using AI coding tools aggressively is hitting the same wall. More PRs, same number of reviewers, reviews get thinner.

The Plandek 2026 benchmarks across 2,000+ teams confirmed this: as AI speeds up coding, the bottleneck shifts downstream to review, testing, and integration. Bottom-quartile teams take 35+ hours to merge a pull request. That’s not a coding problem. That’s a review problem.

So AI code review tools are solving a real constraint. And early results are genuinely impressive. Anthropic reports less than 1% of Code Review findings are marked incorrect by engineers. On large PRs (1,000+ lines), 84% receive findings averaging 7.5 issues per review. That’s catching things humans were missing because they didn’t have time to look carefully.

The part that should make you think
#

Here’s my concern.

If AI writes the code and AI reviews the code, the human becomes the person who approves the merge. Not the person who understands the change. The approver.

That’s a fundamentally different role than reviewer. A reviewer reads, questions, understands, and decides. An approver looks at the green checkmarks and clicks the button.

I wrote this week about how the culture shifted toward rewarding speed over understanding. AI code review accelerates that shift. Not because the tools are bad, but because they make it even easier to ship code nobody on the team truly understood.

When the AI-generated PR gets an AI-generated review with AI-generated test suggestions, and a human clicks “approve” because all the signals are green, what exactly did the human contribute? And when that code breaks at 2 AM, who debugs it?

The right way to use this
#

I’m not arguing against AI code review. The bottleneck is real, and these tools catch things humans miss. Arguing against them would be arguing for worse code.

But I think the right approach is to treat AI review as a first pass, not the final word. Let the AI catch the mechanical stuff: unused variables, security patterns, style violations, common bugs. That frees human reviewers to focus on the things AI is still bad at: architectural fit, business logic correctness, failure mode analysis, and whether the approach makes sense given context the model doesn’t have.

The worst outcome is AI review replacing human review entirely. The best outcome is AI review making human review more focused and more valuable.

The difference depends on whether your team treats the green checkmark as the end of the process or the beginning of a better conversation.

That’s a culture decision, not a tooling decision. And based on what I’m seeing across the industry, most teams haven’t made it consciously.

Using AI code review on your team? Seeing it change how humans review? I’d love to hear how it’s working. Find me on X or Telegram.

When Nvidia's CEO Says 100% of Engineers Use Cursor, He's Not Exaggerating

Fri, 17 Oct 2025 00:00:00 +0000

Last week, Nvidia CEO Jensen Huang sat down for an interview with Citadel Securities and dropped a statement that should make every developer pay attention: “100% of our software engineers and chip designers use Cursor.”

Not “some teams are trying it.” Not “we’re evaluating it.” One hundred percent.

Then he listed five other AI companies shaping the future of work: OpenAI, Harvey, OpenEvidence, Replit, and Lovable. Six startups total. These aren’t random picks. This is Nvidia’s CEO, someone who sees the entire AI landscape, calling out the tools his engineers actually use to build some of the world’s most complex software.

Cursor stood out. Not just mentioned, but specifically highlighted as the tool that’s achieved total adoption across Nvidia’s engineering organization.

I’ve been using Cursor for about a year now. When I heard Huang’s statement, my reaction wasn’t surprise. It was recognition. He’s describing what I’ve been experiencing every day.

What Huang Actually Said
#

The interview with Citadel Securities, published on October 15, focused on how AI will reshape workforces. Huang has been saying for months that future companies will have both human and “digital” employees working together. He’s been calling it the age of “agentic AI,” where AI assistants handle specific tasks as part of integrated teams.

When talking about what that looks like in practice, he pointed to six companies: “Some of them will be OpenAI-based, and some of it would be Harvey-based or Open Evidence or Cursor or Replit or Lovable.”

OpenAI builds the foundation models that power much of this AI revolution. Harvey focuses on legal work, OpenEvidence on healthcare. Replit, Cursor, and Lovable are what Huang called “vibe coding” tools. AI-powered coding environments where you describe what you want and watch it materialize.

But Cursor got special attention. That 100% adoption number. And then this: “Productivity gains, the work that we do is so much better.”

Not just faster. Better.

That distinction matters. Plenty of tools make you faster while producing worse results. Cursor is apparently doing both: speed and quality improvements.

Why I Agree With Huang
#

I’m not going to pretend to have Nvidia’s scale or complexity. But I’ve been building software for years, and I’ve tried most of the AI coding assistants that have emerged in the last two years. Cursor isn’t just incrementally better than alternatives. It’s fundamentally different in ways that matter.

When I start working on a feature, Cursor understands the entire codebase. Not just the file I’m editing, but the patterns I’ve used elsewhere, the architecture I’m following, the dependencies that exist. It’s context-aware in a way that GitHub Copilot never was.

I can highlight a section of code and ask “why would this fail if the user uploads a file larger than 10MB?” and get an actual answer based on my specific implementation. I can describe a feature in natural language and watch Cursor scaffold the entire thing, following my existing patterns, using my preferred libraries, matching my code style.

The result: I spend less time writing boilerplate and more time thinking about architecture. Less time debugging syntax and more time catching edge cases. Less time searching documentation and more time making design decisions.

This is what Huang meant by “better work.” The cognitive load shifts from mechanical tasks to judgment calls. From typing to thinking.

The UI/UX Is Legitimately Good
#

Let me be specific about why Cursor’s interface works.

First, it’s built on Visual Studio Code. This isn’t a new interface you have to learn. If you know VS Code, you know Cursor. All your extensions work. Your keybindings work. Your color themes work. The learning curve is essentially zero.

Second, the AI features are integrated without being intrusive. There’s a sidebar where you can chat with the AI about your code. There’s inline suggestions that appear as you type. There’s the ability to highlight code and ask questions or request changes. All of it feels native, not bolted on.

Third, the AI understands scope. When I ask it to refactor something, it knows what files are related. When I ask it to implement a feature, it suggests which files to create or modify. It doesn’t just generate code in isolation. It thinks about the system.

Fourth, it shows you what it’s doing. When Cursor makes changes, you see a diff. You can accept, reject, or modify. You’re never locked into AI decisions. The AI is a collaborator, not a black box.

The interface respects the developer. You’re always in control. The AI makes suggestions, you make decisions. That balance is hard to get right, and Cursor nails it.

Compare this to some other AI coding tools. Some feel like chatbots awkwardly embedded in an IDE. Some generate code you can’t see until you accept it. Some fight with your existing workflow instead of enhancing it. Cursor got the UX right from the start.

The Pricing Problem Nobody Wants to Talk About
#

Here’s the uncomfortable truth: for the last year, the main reason people leave Cursor isn’t the product. It’s the pricing.

In mid-2025, Anysphere (the company behind Cursor) changed their Pro plan from a fixed request model to a usage-based credit system. The $20 monthly subscription still exists, but now it covers a variable amount of work depending on which AI models you use and how intensively you use them.

Some users suddenly found themselves burning through credits faster than expected. Others got surprise bills. The confusion was real enough that Anysphere’s CEO, Michael Truell, issued a public apology and offered refunds to affected users.

Then in July, they introduced a $200-per-month “Ultra” plan for heavy users. The jump from $20 to $200 is steep. The justification is that the Ultra plan offers 20 times more usage than Pro, but the messaging was unclear. People felt blindsided.

I’ve watched developers I know switch away from Cursor specifically because of pricing uncertainty. Not because the tool wasn’t valuable. Not because they found something better. Because they couldn’t predict their monthly costs.

This is the one area where Cursor is consistently failing. The product is excellent. The pricing model is a mess.

The irony: if Nvidia is willing to pay for 100% of their engineers to use Cursor, the value must be obvious at enterprise scale. But individual developers and small teams are jumping ship over billing confusion.

Anysphere needs to fix this. Transparent, predictable pricing. Clear tiers. No surprise bills. If they don’t, competitors will use pricing clarity as a wedge to steal market share, even if their products are technically inferior.

The Six Companies That Matter
#

Let’s go back to Huang’s list: OpenAI, Harvey, OpenEvidence, Cursor, Replit, and Lovable.

This is a CEO who sees the entire AI industry. He’s not picking companies because they have good marketing. He’s picking companies that are actually changing how work gets done.

OpenAI is obvious. They build the foundation models that power much of the AI revolution. GPT-4 and its successors are infrastructure for the AI age.

Harvey focuses on legal work. It’s an AI assistant specifically trained on legal documents, case law, and legal reasoning. Big law firms are adopting it because it actually understands legal context in ways general-purpose AI doesn’t.

OpenEvidence does the same thing for healthcare. It helps clinicians find relevant medical research and evidence-based guidance. In a field where being wrong can kill people, having AI that understands medical literature matters.

Replit is an online IDE with AI assistance. You can build and deploy entire applications from a browser. It’s lower friction than local development, which makes it powerful for prototyping and learning.

Lovable (formerly GPT Engineer) lets you describe an app and generates the entire codebase. It’s “vibe coding” taken to the extreme. Specify what you want, get a working application.

And Cursor, which sits between Replit’s simplicity and traditional development’s power. You get a full IDE, but the AI understands what you’re building deeply enough to be genuinely helpful.

What these six companies have in common: they’re not trying to replace humans. They’re building tools that let humans operate at a higher level of abstraction. Lawyers still make legal decisions, but Harvey handles research. Doctors still diagnose patients, but OpenEvidence surfaces relevant studies. Developers still architect systems, but Cursor handles implementation details.

That’s the pattern Huang sees. That’s the future he’s betting on.

Why Cursor Hits the Mark
#

I’ve used GitHub Copilot. I’ve tried Amazon CodeWhisperer. I’ve tested Tabnine and Kite and a dozen other AI coding assistants. Cursor is the one that stuck.

Here’s why:

It understands projects, not just files. Most AI coding assistants look at the file you’re editing and maybe a few related files. Cursor understands the entire repository. It knows your architecture, your patterns, your dependencies. This context awareness is the difference between “here’s generic boilerplate” and “here’s code that fits your specific system.”

It handles complex tasks. I can ask Cursor to implement a multi-file feature, and it will suggest creating new files, modifying existing files, and updating configuration. It thinks at the feature level, not the line level.

It learns your style. After working in a codebase for a while, Cursor generates code that looks like code I would write. Same patterns, same naming conventions, same structure. It’s not just correct. It’s consistent.

It explains what it’s doing. When Cursor suggests a change, I can ask why. It doesn’t just generate code and move on. It can walk through the reasoning, point out edge cases, explain trade-offs.

It gets out of the way. When I don’t need AI assistance, Cursor is just a normal editor. The AI features don’t interrupt or distract. They’re there when needed, invisible when not.

This combination is why Nvidia’s engineers use it. Not because someone mandated it. Because it actually makes their work better.

The Evolution Continues
#

Anysphere raised $900 million at a $9.9 billion valuation in mid-2025. They’re not treating Cursor as a finished product. They’re investing heavily in making it better.

Recent updates have added support for more AI models, better context handling, improved multi-file editing, and features specifically for reviewing AI-generated code. They acquired Supermaven, another AI coding tool, in late 2024 to enhance capabilities.

The trajectory is clear: Cursor is evolving toward being a development environment where AI assistance is native, not added on. Where the default mode is collaborating with AI, and the AI is good enough that you want to.

This is what I meant when I said it feels like Cursor is on the right path. Every update makes the product more capable and more usable. The core interaction model is solid. They’re building on a strong foundation.

If they fix the pricing confusion, there’s no reason Cursor shouldn’t become the standard development environment for anyone building software with AI assistance.

What This Means for Developers
#

When the CEO of Nvidia says his entire engineering organization uses a tool, pay attention. Nvidia builds some of the most complex software and hardware in the world. Their engineers are not easily impressed. If they’ve standardized on Cursor, it’s because Cursor delivers value at the scale and complexity they operate at.

I’ve seen this personally. The features I build now are more ambitious than what I would have attempted a year ago because I know Cursor can handle the implementation details. I spend more time thinking about what to build and less time fighting with syntax.

This is the future Huang is describing. Not AI replacing developers, but AI enabling developers to work at a higher level of abstraction. To be more ambitious. To focus on design and architecture while AI handles the mechanical work.

Cursor is the tool making that possible today. Not perfectly. The pricing issues are real and frustrating. But the core product is so good that even with pricing confusion, it’s achieving the kind of adoption Huang described.

The Bottom Line
#

Jensen Huang called out six companies shaping the future of work. Cursor was the only one he said has 100% adoption at Nvidia. That’s not a casual mention. That’s an endorsement from someone who sees the entire AI landscape and knows what actually works at scale.

I agree with him. After a year of using Cursor, I understand why Nvidia chose it. The UI is intuitive. The AI is capable. The integration is seamless. The productivity gains are real.

The pricing model needs work. That’s the one significant weakness, and it’s causing users to leave even though they value the product. Anysphere needs to fix this before competitors use pricing clarity to steal market share.

But the core insight remains: Cursor has figured out how to build an AI-assisted development environment that enhances rather than replaces developer judgment. It’s the tool that lets developers operate at the level Huang is describing, where AI handles implementation and humans focus on design.

That’s the innovation. That’s why it matters. And that’s why, despite the pricing frustrations, I keep using it every day.

The Magic Behind AI IDEs: How Cursor, Windsurf, and Friends Actually Work

Sun, 28 Sep 2025 00:00:00 +0000

You’ve installed Cursor. Or maybe Windsurf, or Copilot. The autocomplete feels magical. The chat knows your codebase. Sometimes it writes entire functions that actually work.

But what’s really happening? How does it know what to suggest? Why does Cursor feel different from Copilot? And why are you paying $20 a month when you already have ChatGPT?

Let’s pull back the curtain. No marketing fluff, no hand-waving. Just the actual engineering that makes these tools tick.

The 10-minute mental model
#

Every “AI for coding” tool is basically three products wearing the same trench coat:

1. The Autocomplete Engine (FIM)
#

This is that instant suggestion that appears as you type. It’s using something called Fill-In-the-Middle (FIM), where the model predicts what goes between your cursor position and the rest of your code. It’s fast, runs on limited context (usually just your current file and a few open tabs), and feels instantaneous.

This isn’t revolutionary tech. It’s a well-studied training approach that teaches models to predict the middle given the before and after. Think of it as smart tab completion on steroids.

2. The Context Engine (Smart RAG for code)
#

While you’re typing, there’s a background system indexing your entire repository. When you ask a question or trigger an edit, this engine:

Searches for relevant code snippets
Pulls in documentation
Finds similar patterns
Grabs your project rules and constraints

Then it builds a comprehensive prompt around all this context. This is where most quality differences live. Cursor’s context engine works differently from Windsurf’s, which works differently from Copilot’s. More on this in a bit.

3. The Agent Harness
#

This is the planner that can actually do things. It doesn’t just suggest code; it can:

Search your codebase
Run tests
Edit multiple files
Call APIs (via MCP)
Create pull requests
Roll back changes when things go wrong

The best systems maintain a persistent plan (like a todo list), make multiple tool calls per step, and know how to recover from failures.

Everything else? The pricing tiers, model selection, pretty UI? That’s just window dressing on these three core systems.

How Cursor actually works
#

Let’s start with the current favorite. Here’s what happens when you use Cursor:

The indexing magic. When you open a project, Cursor computes embeddings for each file. These are mathematical representations that let it find semantically similar code quickly. You control what gets indexed: it respects .gitignore and you can add exclusions. This index stays synced as you work.

Rules as religion. Cursor treats project rules as first-class citizens. Drop a .cursorrules file in your repo with your coding standards, library preferences, and “never do this” warnings. These rules get versioned with your code and automatically steer every suggestion. Sarah on your team prefers functional components? Put it in the rules. The whole team hates nested ternaries? Rules.

Two different brains. Cursor splits “tell me about code” from “change my code”:

Chat helps you understand existing code
Composer (Cmd+K) makes actual edits across multiple files
Terminal integration turns “run the tests” into actual shell commands

Your code, their servers. Even when you use your own OpenAI key, requests go through Cursor’s backend. Why? That’s where they assemble the final prompts, mixing your code with context, rules, and prompt engineering. They say they don’t store your code beyond the request lifecycle, and they offer a Privacy Mode for paranoid enterprises.

The secret sauce: It’s not the models (everyone uses the same ones). It’s the obsessive prompt engineering plus the rules system plus that multi-file diff UI that makes saying “yes” to changes so easy.

Windsurf: The operations-minded alternative
#

Windsurf (from Codeium) takes a notably different approach:

Cascade, the methodical agent. Their agent system, Cascade, is surprisingly sophisticated. It maintains a long-term plan while executing short-term actions. Think of it like a senior developer who writes a todo list before diving into code. It can create named checkpoints, revert when things go sideways, and queue up multiple tasks.

Local indexing that stays local. Windsurf explicitly documents their indexing as “optimized RAG for code.” They generate embeddings but store them locally on your machine. No code leaves for indexing. You control what gets indexed with .codeiumignore files.

MCP everywhere. They’ve gone all-in on the Model Context Protocol (Anthropic’s standard for tool integration). Want Cascade to check Jira tickets? Add a Jira MCP server. Need it to query your database? There’s an MCP server for that. Admins can control which servers teams can use.

Secret sauce: An ops-minded agent that actually plans its work, plus genuinely local indexing, plus that comprehensive MCP integration.

Copilot: Distribution is everything
#

GitHub’s Copilot started as autocomplete but is rapidly evolving:

Multi-file edits are here. “Copilot Edits” in VS Code can now change multiple files from a single instruction. No more copy-pasting suggestions file by file.

The agent grows up. GitHub’s rolling out a proper coding agent that can:

Spin up a VM
Clone your repo
Make changes
Run tests
Open a PR

You delegate a task, you get a pull request. That’s the vision they’re building toward.

Spaces: Context containers. Copilot Spaces let you create bubbles of context: “These 5 files, this issue, and these docs are what matters for this feature.” Share the space with your team. Everyone works with the same context. It went GA on September 24, 2025.

MCP support. Enterprises can enable MCP to bring in external tools. GitHub even ships their own MCP server for GitHub-specific operations.

Secret sauce: Distribution. Copilot lives where developers already work: GitHub, VS Code, Visual Studio, and now Xcode. When your AI assistant is one click away in your existing workflow, friction disappears.

Kiro: AWS’s process-first bet
#

Kiro is AWS’s entry, and they’re taking a radically different approach:

Specs drive everything. Instead of “vibe coding” where you chat until code appears, Kiro enforces spec-driven development. You co-write a specification first, then agents implement tasks with tests and documentation. It’s like having a junior developer who refuses to code without clear requirements.

Hooks and automation. Kiro bakes in event-driven automation. Save a file? Trigger tests. Commit code? Update documentation. It’s connecting the AI to your development lifecycle, not just your editor.

AWS-native from the start. Unsurprisingly, it integrates deeply with AWS services. But more interesting: they’re shipping Nova Act, an IDE extension that works in Kiro, Cursor, and VS Code. They’re playing both the platform and plugin game.

Secret sauce: Process over prompts. By forcing specs and integrating with your development lifecycle, Kiro ensures the AI aligns with how you’re supposed to work, not just how you happen to work.

“Why hasn’t JetBrains won already?”
#

Fair question. JetBrains makes the IDEs many of us grew up on. They’ve shipped AI features: inline completions, chat, file-wide edits, enterprise controls. They route to multiple LLMs and even run their own models for certain features.

So why does it feel like they’re behind?

Different DNA. JetBrains built deep IDE tools for 20 years. Their reflexes optimize for correctness, refactoring safety, and enterprise governance. Cursor and Windsurf were born in the AI age. Their reflexes optimize for agent workflows and rapid iteration.

Agent ergonomics matter. The perceived gap isn’t about model access. It’s about the experience of working with an agent. That “task to plan to multi-tool execution to rollback” loop that Windsurf and Cursor nail? JetBrains is still finding their version of it.

Open ecosystem friction. MCP support and “bring your own tools” is where the new players are loud. JetBrains prioritizes security and compliance (great for enterprises, slower for experimentation).

Translation: JetBrains hasn’t failed. They’re shipping for enterprise realities and deep IDE integration. The others are shipping for AI-first workflows. Different games, different rules.

“Aren’t these just expensive wrappers around ChatGPT?”
#

Sometimes, yes. But the good ones aren’t. Here’s what you’re actually paying for:

A context engine that works. Ever tried to explain your codebase to ChatGPT? These tools maintain living indexes with semantic understanding, symbol awareness, and cross-file relationships. That’s systems engineering, not prompt templates.

Agent orchestration. Planning, multi-file diffs, rollback, tool quotas, secure API access. This is distributed systems work. You could build it yourself. You probably shouldn’t.

Privacy and compliance. Zero-retention modes, SOC 2 compliance, team controls, audit logs. The boring stuff that keeps your company’s lawyers happy.

Workflow integration. For Copilot, the value is being one click away in GitHub. For Cursor, it’s that buttery-smooth diff UI. Distribution and UX matter more than model quality.

When you shouldn’t pay:

You only want autocomplete and you’re happy with a local model
Your team can build and maintain your own indexer, agent runtime, and diff system
You’re a solo developer on open-source projects with no compliance requirements

How to build your own (please don’t)
#

Want to understand how hard this is? Here’s the minimum architecture:

IDE Integration Layer
├─ Autocomplete (FIM)
│ ├─ Keystroke capture
│ ├─ Context window management
│ └─ Suggestion ranking
├─ Context Engine
│ ├─ Repository indexer
│ ├─ Embedding generator
│ ├─ Hybrid search (semantic + keyword)
│ ├─ Rules engine
│ └─ Reranking system
├─ Agent Runtime
│ ├─ Task planner
│ ├─ Tool executor
│ ├─ Multi-file diff engine
│ ├─ Checkpoint/rollback system
│ └─ Safety controls
└─ Model Router
├─ Provider management
├─ Cost optimization
└─ Fallback handling
Supporting Infrastructure
├─ Telemetry pipeline
├─ Privacy controls
└─ Audit system

Each of these components is a project. The integration between them is another project. The testing and reliability? Another project.

This is why these tools cost $20/month. You’re not paying for API access. You’re paying for thousands of engineering hours solving problems you haven’t even discovered yet.

What actually matters: A buyer’s guide
#

Here’s the real differentiation today:

What to look for	Cursor	Windsurf	Copilot	Kiro
How good is the context?	Excellent indexing, rules-driven	Local indexing, RAG-optimized	Repository-aware via Spaces	Spec-driven context
Can it plan and execute?	Composer for edits	Cascade planner with checkpoints	Agent with VM execution	Spec to implementation
Tool integration?	Growing MCP support	Native MCP with controls	GitHub-native + MCP	Native MCP + AWS
Enterprise ready?	Privacy mode, SOC 2	Local indexing, controls	Platform integration	AWS security posture
Unique strength?	Rules + diff UX	Planning + local-first	Distribution + GitHub	Process enforcement

The next 12 months
#

Based on current trajectories, here’s what’s coming:

Context becomes product. Expect “knowledge bases” where teams pin architecture decisions, coding standards, and project context. The AI treats these as law. Copilot Spaces is the early signal.

Tool ecosystems explode. MCP adoption is accelerating. Winners will curate safe, useful tool catalogs with enterprise controls. Think “app stores” for AI agent capabilities.

Verification becomes standard. “Plan, change, prove it” becomes the minimum bar. Every change comes with test results, linter output, and security scans.

Specs eat prompts. Kiro’s bet on spec-driven development will spread. Why? Because it aligns AI with how software should be built, not how it happens to be built.

Models commoditize, routing wins. Everyone will offer the same models. The differentiator becomes intelligent routing: which model for which task, based on cost, latency, and accuracy.

Practical advice for today
#

If you want agent-powered editing right now:

Windsurf if you like plans, checkpoints, and local control
Cursor if you want the smoothest diff experience and love rules
Copilot if you live in GitHub and want to delegate entire features
Kiro if you believe in specs and want AWS integration

If you’re married to JetBrains: Their AI Assistant is evolving fast. It’s the safe enterprise choice that prioritizes governance over bleeding-edge features.

If you’re thinking of building your own: Start with open-source. Use Continue for the IDE integration, Langchain for the agent logic, and focus on your unique differentiation. But honestly? Just pay the $20.

The uncomfortable truth
#

These aren’t just “ChatGPT with syntax highlighting.” They’re complex distributed systems solving real engineering problems:

How do you index a million-line codebase in real-time?
How do you maintain context across multiple files without sending your entire repo to OpenAI?
How do you let an agent make changes while keeping rollback ability?
How do you do all this without leaking proprietary code?

The teams winning aren’t the ones with the best models. They’re the ones treating this as systems engineering, not prompt engineering.

Your AI IDE is three systems in a trench coat: autocomplete, context engine, and agent runtime. The quality lives in how these systems work together, not in any single component.

Choose based on your workflow, not the hype. And remember: the goal isn’t to have an AI write all your code. It’s to handle the boring parts so you can focus on the interesting problems.

The magic isn’t magic. It’s just good engineering. And now you know how it works.

Next time someone asks why you pay for Cursor when “it’s just ChatGPT,” send them here. Or don’t. More server capacity for the rest of us.

Cursor · PiniShv

The IDE Is Becoming Mission Control

What actually changed #

Not everyone is moving at the same speed #

What this actually means #

Cursor Automations: Your AI Just Stopped Waiting for Permission

What it actually does #

How the others compare #

Why this matters #

AI Is Now Reviewing AI's Code. That Should Make You Think.

The bottleneck is real #

The part that should make you think #

The right way to use this #

When Nvidia's CEO Says 100% of Engineers Use Cursor, He's Not Exaggerating

What Huang Actually Said #

Why I Agree With Huang #

The UI/UX Is Legitimately Good #

The Pricing Problem Nobody Wants to Talk About #

The Six Companies That Matter #

Why Cursor Hits the Mark #

The Evolution Continues #

What This Means for Developers #

The Bottom Line #

The Magic Behind AI IDEs: How Cursor, Windsurf, and Friends Actually Work

The 10-minute mental model #

1. The Autocomplete Engine (FIM) #

2. The Context Engine (Smart RAG for code) #

3. The Agent Harness #

How Cursor actually works #

Windsurf: The operations-minded alternative #

Copilot: Distribution is everything #

Kiro: AWS’s process-first bet #

“Why hasn’t JetBrains won already?” #

“Aren’t these just expensive wrappers around ChatGPT?” #

How to build your own (please don’t) #

What actually matters: A buyer’s guide #

The next 12 months #

Practical advice for today #

The uncomfortable truth #