Claude Code is here: what it means for IDEs

Anthropic shipped Claude Code on February 24th, alongside Claude 3.7 Sonnet. It's a coding agent that runs in the terminal, holds a project context, can read and write files, run commands, and iterate on tasks across multiple turns. It's not in beta. It's a product, billed by API usage.

The interesting thing about Claude Code is not that it exists, coding agents have been a category for almost two years at this point, with Cursor, Aider, Continue, Windsurf, Replit Agent, v0, and bolt.new all working different angles of the same idea. The interesting thing is the shape it shipped in. Anthropic chose terminal-first instead of editor-first. They chose first-party (their own model) instead of model-agnostic. They chose CLI ergonomics instead of GUI ergonomics. Each of those is a deliberate bet about where the agent sits in the developer's day, and worth working through what they actually change.

The architecture, minimally

The agent runs in the terminal as a long-running process. It reads a CLAUDE.md file from the project root for context. It has a fixed set of tools (file read/write, shell exec, search) and the model decides which to call. Your editor is unchanged; you can be in VS Code or Vim or JetBrains and the agent doesn't care, because the artifact it operates on is the filesystem, not the editor's buffer.

What that shape changes

The Cursor model (the dominant one for the prior eighteen months) is the AI inside the editor. The cursor (lower-case) is the unit of attention; the model sees what you're typing and rewrites blocks around the cursor in real time. Continue, Windsurf, GitHub Copilot's chat surface, JetBrains' AI Assistant, all variants of this shape. The IDE owns the relationship.

Claude Code inverts that relationship. The agent owns the project, the editor is a viewer for the result, and the workflow is conversational rather than continuation-style. A few practical consequences:

You don't have to switch IDEs. The reason Cursor became a category-defining product is that the AI integration is meaningfully better when the editor is built around it. The cost is that you have to switch editors. Claude Code's CLI-first architecture decouples the agent from the editor, if you're attached to your existing setup, you don't have to give it up.

The unit of work is bigger. Cursor is built around in-line completion and short-range edits. Claude Code is built around tasks, "refactor this module to use the new auth schema" or "find all usages of this deprecated function and update them." The longer-horizon framing changes what the agent is good at and what feels awkward.

The relationship to the model is direct. Cursor and friends abstract over multiple model providers. Claude Code is Anthropic's, talks to Anthropic's API, and uses Anthropic's extended thinking budget. That's a feature if you trust Anthropic to ship the best coding model and a constraint if you wanted the freedom to swap.

Billing is per-token, not per-seat. Subscription models smooth the cost, you pay $20/month and you don't think about it. Per-token billing makes the cost visible in real time, which is honest but also surprising the first time you let an agent grind on a long-running task and the daily spend hits a number.

What it doesn't try to do

Worth being explicit about what's not in Claude Code, because the absences are deliberate:

• No code completion. Cursor's killer feature isn't there. The agent is for tasks, not for in-line typing assistance.
• No native IDE integration. No language-server hooks, no syntax-aware refactoring, no "rename this symbol across the project" that talks to the editor's symbol index. The agent operates on text in files via grep and read/write.
• No persistent memory across sessions, by default. The CLAUDE.md file is the closest thing, a project-scoped instruction file the agent reads at the start of every session. There's no cross-session learning baked in.
• No multi-agent orchestration. A single agent works on a single task. The category of "swarm of agents collaborating on a feature" that some products are pitching isn't what Claude Code is.

These omissions sharpen the product. Trying to be the editor and the agent and the orchestration framework is what most of the AI-IDE category has been doing for two years. Picking one of those three and doing it well is a different shape of bet.

What this implies for the IDE category

Two years ago I wrote about the agent wave being the next thing after the chat interface. The IDE category has spent most of those two years trying to fit agents into the editor's existing ergonomics. Claude Code is the first widely-shipped product that flips the question, instead of "how do we put an agent inside the editor," it asks "what if the agent sits next to the editor and the editor stays out of its way."

The category answer for the next year is probably going to be both. Cursor isn't going anywhere; the in-editor experience is genuinely better for some kinds of work and worse for others. Claude Code's terminal-first model is going to coexist with editor-integrated agents the way the command line has coexisted with GUIs for forty years. Different shapes for different parts of the day.

The interesting structural change is that the model maker shipping a first-party agent puts pressure on the integration partners (Cursor, Continue, Windsurf) to differentiate on something other than "we use the latest Anthropic model." That something is going to have to be either the in-editor experience itself, or a multi-model story, or a workflow shape that Claude Code deliberately doesn't address. Each of those is a defensible answer. None of them is the same answer.