Cursor 2.0 vs Google Antigravity: the late-2025 IDE arms race that nobody planned for

Cursor shipped 2.0 on October 30. Google shipped Antigravity on November 18. In the three weeks between those launches, two completely different bets about what an “AI IDE” should become in late 2025 landed in users’ hands. Both are real products; both are credible challenges to Claude Code’s terminal-first dominance; both reveal the philosophical split happening inside the AI-coding market.

Fireship’s October 30 video on Cursor 2.0 treats it as an incremental polish of an existing product. Theo’s November 18 reaction to Antigravity — “Google just dropped their Cursor competitor, and it’s uh. Well you’ll see…” — treats it as a credible third entrant. The honest read after three weeks of running both is that they’re solving different problems, and the late-2025 IDE arms race isn’t about which one wins — it’s about whether the IDE-shaped AI tool category survives the agentic shift at all.

What Cursor 2.0 actually shipped

Cursor 2.0 (October 30) was a substantial refresh of the existing product. The release notes lead with five major features:

1. Composer-1, a new mid-tier Cursor-specific model designed for the in-IDE workflow, positioned between Cursor’s smaller helper models and the frontier Anthropic / OpenAI options.
2. Background Agents that run in cloud sandboxes for tasks you don’t want to wait around for — an explicit lift of the agent-sandbox pattern I wrote about elsewhere.
3. Plan mode improvements with clearer scoping and explicit checkpoint approval.
4. Pricing model adjustments — still recovering credibility from the June 2025 pricing crisis. The 2.0 launch is mostly the technical product; the Sept follow-up was when pricing got honest.
5. Multi-tab agents — letting you fan work out across files more cleanly without losing track of which agent is doing what.

Fireship’s framing was diplomatic: “Cursor, the IDE of choice for any self-respecting vibe engineer, just released version 2.0… 5 new features every developer should know about.” That’s the level. Iterative product update. Reasonable execution. Nothing that fundamentally changes Cursor’s competitive position against Claude Code, GitHub Copilot, or the newer entrants.

The market context matters: Cursor in October 2025 was still recovering from the pricing crisis that pushed a meaningful slice of users to alternatives. 2.0 was as much a “we’re still building, please come back” message as it was a product release. Reddit reception was muted positive — the r/ChatGPTCoding “I Compared Cursor Composer-1 with Windsurf SWE-1.5” thread captured the practical assessment: Composer-1 is fine, not transformative, and the head-to-head against Windsurf’s SWE-1.5 was approximately a wash.

What Antigravity actually shipped

Three weeks later, Google dropped a product that operates from completely different assumptions. Antigravity isn’t an “AI features bolted onto an editor.” It’s an “agent-first IDE” — the editor surface is secondary; the Agent Manager is primary.

The key features from the Antigravity announcement:

1. Multi-agent orchestration as the central UI. Spawn multiple agent threads, each working on a different task in parallel. Watch them, redirect them, merge their work.
2. Gemini 3 Pro free as the default model. This is the loss-leader play — Google bundles its frontier model with the IDE at no charge for a launch window.
3. Tight integration with Google’s broader ecosystem. Cloud Run deploy, Firebase, Google Cloud Console operations from inside the agent loop.
4. Built on a fork of VS Code like Cursor, but with a noticeably different opinionated default behavior — Antigravity’s defaults push the agent to act more autonomously.

Theo’s framing in his November 18 reaction video was characteristically blunt: “Google just dropped their Cursor competitor, and it’s uh. Well you’ll see…” Watch the video and the “uh” carries real weight. The product is impressive in ambition and rough in execution. The Agent Manager UI is genuinely innovative. The default agent behavior is too aggressive. The Gemini 3 Pro integration is fast. The cross-window coordination is broken in week one.

The 443-upvote r/ChatGPTCoding review of Antigravity — published November 21, three days after launch — landed on a similar mixed verdict. The OP loved the agent orchestration UI: “The ‘Agent Manager’ is the real deal. Unlike the linear chat in VS Code/Cursor, here you can spawn multiple agent threads.” The comments surfaced the friction:

“The multi-agent orchestration is a nice UI, but like you say, it just makes it easier to do lazy vibe-coding. I also find that Gemini 3.0 is way more aggressive at doing stuff you probably don’t want.” — 41 upvotes

“Creating tests for a file at the same time as it’s being refactored, by two separate agents who are unaware of each other, seems… wrong.” — 22 upvotes

“I left cursor a long time ago for CLI tools, mainly codex and claude code. I’m curious how it compares to those, tbh I’m not particularly impressed with gemini for coding, seems over-hyped.” — 15 upvotes

The pattern: the Agent Manager UI is the genuinely innovative part. The defaults — what the agents do without explicit instruction — are too aggressive. Six months from now this is probably fixed. Today, the friction is real.

The philosophical split this exposes

Cursor 2.0 and Antigravity are betting on opposite philosophies about what an AI IDE should be:

Cursor’s bet: refine the IDE surface, integrate AI deeply but keep the engineer in the editor. Composer-1, multi-tab agents, plan mode improvements — all of these are about making the existing IDE-with-AI experience smoother. The engineer is still mostly in the editor most of the time. The AI is a powerful tab-completion / pair-programmer that you reach for as needed.

Antigravity’s bet: make the agent the primary interface, the editor secondary. Open Antigravity and the first thing you see is the Agent Manager. You don’t write code; you tell agents what code to write, then review their work. The editor surface exists for the cases where you want to step in manually, but the default workflow has you not touching the keyboard much.

IndyDevDan’s pattern (Claude Code-flavored): make the terminal the primary interface, deploy agents to sandboxes, treat the IDE as a viewer. Dan’s “One Agent to RULE them ALL” video lays out the third path — a terminal-native orchestrator that dispatches to parallel sandboxes and never quite settles into one IDE.

These three bets are not compatible. They imply different muscle memory, different team conventions, different tooling investments. Each is the right answer for some engineers and the wrong answer for others. The market is bifurcating — and the IDE-first vs agent-first vs terminal-first division is more important than the Cursor-vs-Antigravity question.

Where the late-2025 IDE arms race actually leaves working engineers

Three weeks into the dust settling:

Cursor 2.0 is the right answer for:

• Engineers who have invested significant muscle memory in IDE-based AI
• Teams who prefer the “AI assists in the editor” mental model
• Use cases where the editor surface is genuinely the right interaction loop (refactoring within a single file, in-IDE chat with context, line-by-line edits)
• Anyone migrating from VS Code who wants minimal cognitive shift

Antigravity is interesting for:

• Engineers exploring the agent-first paradigm and willing to deal with rough edges
• Cases where parallel multi-task work is natural (UI variant exploration, multi-microservice scaffolding)
• Google ecosystem developers who get genuine value from Cloud Run / Firebase integration
• The “I want to vibe-code and review at the end” workflow

Neither is the right answer for:

• Heavy multi-file backend refactoring where Claude Code’s terminal-native sub-agent pattern is more refined
• High-stakes production work where agentic defaults need to be conservative — both Cursor 2.0 and Antigravity push toward more autonomous action than experienced engineers want
• Cost-sensitive use cases where the included models burn through budget — Claude Code on Pro subscription remains the better cost-per-task

The honest take from running all three for three weeks: Claude Code (terminal-native) still wins for serious daily-driver work. Cursor 2.0 is the right choice for users who genuinely need the IDE surface. Antigravity is interesting but not yet ready for production reliance.

What this means for the IDE-tool category long-term

Two predictions worth flagging for the next six months:

Prediction 1: The IDE-shaped AI tool category survives but consolidates. Cursor, Antigravity, and Windsurf will all still be around in Q1 2026 but the market will sort into “the IDE for users who want IDE polish” (Cursor) vs “the IDE for users who want agent orchestration” (Antigravity or its eventual cleanups). Windsurf becomes the lower-cost middle option. Smaller IDE wrappers (Continue.dev, GitHub Copilot inside VS Code proper) take the rest.

Prediction 2: Terminal-native tools (Claude Code, Codex CLI) keep gaining share among senior engineers. The pattern shown across IndyDevDan, AI Jason, Cole Medin, and the r/ChatGPTCoding heavy-user cohort is consistent: experienced engineers are increasingly leaving the IDE-first paradigm for terminal-first agentic workflows. This isn’t going to flip overnight, but the direction of travel is clear.

The YouTube vs Reddit reconciliation

Fireship’s Cursor 2.0 coverage was incremental-positive — the right tone for an incremental product update. Theo’s Antigravity coverage was excitable-uncertain — the right tone for a flashy but unfinished launch. Both creators landed the right vibe on their respective subjects.

The Reddit response in both cases — muted on Cursor 2.0, mixed on Antigravity — settled the practical question. Neither product is reshaping anyone’s workflow yet. Both are credible enough to keep watching. The real action in late-2025 AI coding tools is happening in the terminal-native agentic stack and in the agent-sandbox primitives, not in the IDE-vs-IDE skirmishes.

If you’re picking an IDE-shaped tool in November 2025: Cursor 2.0 if you want polish, Antigravity if you want to try the agent-first paradigm and accept the rough edges. If you’re picking based on raw productivity for serious daily work: stay on Claude Code in the terminal and check back in March when both Cursor and Antigravity have iterated.