
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.
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.
At its core, plan mode enforces a two-phase loop:
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.
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.
Neither camp is wrong in all cases. The right choice depends on the task and the cost of being wrong:
| Situation | Better choice | Why |
|---|---|---|
| Unfamiliar codebase, high-stakes refactor | Plan mode | Mistakes are expensive; cheap checkpoint |
| Small, reversible edits | Autonomous loop | The gate costs more than it saves |
| Agent with a weak model or small context | Plan mode | Constrains blast radius |
| Strong model, good tests, version control | Autonomous loop | Review the diff, not the plan |
| Learning a new codebase | Plan mode | The plan is the documentation |
| Exploratory prototyping | Autonomous loop | Speed 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.
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.
If you're evaluating coding agents today, don't treat plan mode as a checkbox feature. Try it honestly and ask two questions:
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.