Article

Plan Mode vs. Just Do It: Why AI Coding Agents Are Splitting on the Simplest Design Question

Plan Mode vs. Just Do It: Why AI Coding Agents Are Splitting on the Simplest Design Question

Should an AI coding agent plan before it touches your code — or just start writing? It sounds like a trivial design question, but the coding-agent world is splitting down the middle on it right now. Google's Antigravity 2.0 just doubled down on Plan Mode, while OpenCode's founder announced he wants to remove plan mode from his tool entirely. And as discussed on LINUX DO, developers have strong, conflicting opinions about which side is right.

The short answer: plan mode works great when it actually plans — the problem is that many implementations are "fake plan mode" that executes changes anyway, and purists argue the whole concept is a band-aid for agents that can't be trusted. Both sides have a point.

The split: Antigravity 2.0 vs. OpenCode

Antigravity — Google's AI coding environment, nicknamed "反重力" (anti-gravity) by Chinese developers — shipped Plan Mode in its 2.0 release. The idea is simple: before the agent writes or modifies any code, it must produce a written plan describing what it intends to do, get your approval, and only then proceed.

The timing caught people off guard. As forum members noted, OpenCode founder Tibo had just indicated he wants to cut plan mode from OpenCode. So within the same week, one major coding tool pushed plan mode forward while another moved to kill it — a clean illustration of how unsettled agent design still is.

Google is clearly investing heavily in Antigravity's direction. Community members confirmed the tool now supports hooking up local models, and Google has been pushing its Gemma 4 model series alongside it. The message is unambiguous: Antigravity is meant to be a serious, long-term bet on agent-assisted development, not a side experiment.

What "plan mode" actually means

At its core, plan mode enforces a two-phase loop:

  1. Plan phase — the agent explores the codebase, proposes a design, lists the files it will touch, and waits.
  2. Execute phase — only after the developer approves (or edits) the plan does the agent start making changes.

Contrast this with the default agentic loop — read, edit, run tests, fix, repeat — where the agent moves through planning and execution fluidly, often without telling you what it decided.

The appeal of plan mode is obvious to anyone who's watched an agent confidently demolish a codebase: it inserts a human checkpoint at exactly the moment where cost is lowest. Reviewing a plan takes thirty seconds. Reviewing a diff of 400 lines the agent generated — and then unwinding it when it's wrong — takes much longer. For a disciplined AI development workflow, where you grill the agent on its approach before letting it act, plan mode is the productized version of a practice many senior developers already enforce manually.

The case against: why OpenCode wants to kill it

So why would a tool's creator want to remove a feature that sounds so sensible? The strongest argument is that plan mode is a workaround for a trust problem that shouldn't exist in the first place.

Here's the logic: if your agent is good enough, its first-pass execution should be reliable enough that reviewing the plan is redundant. The agent already shows you its diffs before you commit them — you have version control, you have tests. Adding a mandatory planning gate doesn't eliminate risk; it just adds friction to every loop. For experienced developers who review changes quickly, the gate feels like a seatbelt alarm that won't stop beeping.

There's also the honesty problem. As forum users complained about earlier implementations, some "plan mode" versions were fake — the agent was supposed to only plan, but ended up doing the work during the planning phase anyway. A feature that leaks its own boundary trains users to distrust the boundary entirely. If plan mode doesn't actually stop execution, it's theater, and theater is worse than nothing because it lets your guard down.

Finally, there's a philosophical argument gaining traction: plan-first is a human workflow pattern. Humans plan because execution is expensive for us. For an agent that can generate, test, and revert in seconds, the economics flip — maybe the right move is to let it try things fast and judge the results, not the plan. In this view, insisting on plan mode is like insisting your calculator show its long division.

When each side wins

Neither camp is wrong in all cases. The right choice depends on the task and the cost of being wrong:

SituationBetter choiceWhy
Unfamiliar codebase, high-stakes refactorPlan modeMistakes are expensive; cheap checkpoint
Small, reversible editsAutonomous loopThe gate costs more than it saves
Agent with a weak model or small contextPlan modeConstrains blast radius
Strong model, good tests, version controlAutonomous loopReview the diff, not the plan
Learning a new codebasePlan modeThe plan is the documentation
Exploratory prototypingAutonomous loopSpeed beats ceremony

This is why the industry isn't converging: the "correct" answer is conditional, so different tools are optimizing for different default users. Antigravity is optimizing for developers who want guardrails and control; OpenCode is optimizing for developers who want the agent out of their way.

The bigger picture: agents are still searching for their interface

Zoom out and this disagreement looks familiar. Every new computing interface went through an era of competing interaction models — think of the early battles over GUI conventions, or the decade it took to settle mobile app navigation patterns. Coding agents are in that era now.

The AI coding-subscription race is mostly fought on model capability and pricing, but the quieter war is over interaction design: plan gates, approval prompts, autonomous loops, diff review. These choices matter as much as raw model strength, because a brilliant model behind a frustrating interface still gets abandoned.

What's interesting about Antigravity's 2.0 bet is the combination: plan mode plus local model support plus Gemma 4. That's a tool positioning itself as the controlled, private, deliberate way to code with AI — the opposite of the move-fast-and-break-things agent. Whether developers reward that positioning will be a real signal about where the market is heading.

The practical takeaway

If you're evaluating coding agents today, don't treat plan mode as a checkbox feature. Try it honestly and ask two questions:

  1. Does it actually stop? Run a plan-mode session and check whether the agent made file changes during the planning phase. If it did, the feature is decoration.
  2. Does the checkpoint pay for itself? If you find yourself approving plans without reading them, the gate is pure overhead — turn it off and review diffs instead.

The split between Antigravity and OpenCode isn't a disagreement about whether planning is good. Everyone agrees planning is good. It's a disagreement about where the human belongs in the loop — and that's a question each developer will have to answer for themselves, one codebase at a time.

Keep reading
Stop Vibe Coding: Matt Pocock's Grill-Me Agent Skills for Disciplined AI Development
Read next →