Decide if Antigravity’s /boost is worth the extra reasoning with a 5-point scorecard
Reserve /boost for paid-plan work where a single-turn pass is likely to miss a stated invariant; use a five-point gate to decide when the extra reasoning is justified.
A patch can pass a smoke test while breaking a lock-order invariant; a failing test you forgot to write can be the only thing that catches it. Use the five-point gate below before escalating from a standard single-turn pass.
On paid plans in Google Antigravity 2.0 or the Antigravity CLI, skip the bigger-pipeline question; ask whether the task needs the extra reasoning phases. The documentation says it can be invoked across all Antigravity surfaces, so the decision is not about where you run it. It is about what you are asking it to do.
What /boost changes in the loop
The documentation positions /boost for cases where standard single-turn assistance is insufficient. The docs name complex bugs, race conditions, and intricate refactoring; use those as the starting suspect list, then check whether your task has hidden coupling or an unclear verification path.
/boost uses a three-phase multi-agent reasoning pipeline that separates strategy formulation from execution and verification. If the interface exposes the plan and verification, inspect them before accepting the diff; if not, judge the patch by your tests. That separation is the reason it can be worth the extra reasoning: it gives the system a chance to plan, act, and check before you spend time debugging a patch that looked reasonable in the diff. It is also the reason it can be overkill on simple tasks. A three-phase pass on a typo fix is like hiring a project manager to rename a variable.
If the task is small, that cost may exceed the value of the extra reasoning.
The 5-point /boost trigger scorecard
Use this as a gate before invoking /boost. Answer yes or no to each item. You do not need a perfect score. You need enough signal that the task is likely to fail in a subtle way, or that the standard single-turn pass will be too shallow.
- Files touched: Does the task span multiple files or modules? Non-trivial refactoring across multiple files is listed as a key use case. If a change touches interfaces, shared state, tests, configuration, or dependent modules, score it. If it is one function in one file with no cross-cutting effects, do not.
- Failing test exists: Can you write a failing test, a reproduction script, or a clear acceptance criterion before the agent runs? If yes, you have a checkable target for the result. If you cannot define success, you are adding extra steps to a guess.
- Invariant stated: Can you state the invariant, acceptance criterion, or failure mode that a correct patch must preserve? Race conditions, state bugs, timing issues, and concurrency edge cases are the kind of problems where a plausible patch can still be wrong. If you cannot name the constraint, do not score it.
- Budget available: If your plan or UI exposes token/credit usage, record it; if not, use time and review budget. Do you have explicit time to run the pass and check the verification your tests or interface expose? If you are in a time-boxed incident or running many experiments, mark it as constrained.
- Standard single-turn failure: Has the standard single-turn pass already failed, or is it likely to produce a plausible but wrong patch? If it has produced a patch that fails the stated invariant, or if the task is the kind where a clean diff can miss the real constraint, score it. If the task is mostly mechanical, do not.
Give one point for each yes; three or more points means run /boost, one or two means try the standard single-turn pass first, and zero means skip /boost.
How to judge it without vendor hype
The best way to evaluate /boost is to build a small local benchmark from your own work. Pick five recent tasks: one trivial edit, one single-file bug, one multi-file refactor, one concurrency or state issue, and one task where you already know the correct fix. For each task, run the standard single-turn pass first. Record wall time, prompt count, test pass/fail, and revert/hand-edit rate in a five-row table, one row per task, with the same prompt and verification test for both passes. Record token usage only if the interface exposes it. Then run /boost on the same tasks with the same prompt and the same verification test.
Do not judge it by how confident the explanation sounds. Judge it by whether the verification held. A useful /boost result should be tied to a verification you can check, not just a longer narrative. If the multi-agent reasoning produces a patch that still fails the test, mark the run as a failed verification and record the hand-edit or revert it required.
Rule of thumb: /boost is worth it when the task is hard to verify, hard to isolate, or likely to produce a confident wrong answer. It is not worth it when the task is easy to verify, easy to isolate, or easy to fix by hand.
Keep the scorecard next to your terminal. The goal is not to run the extra reasoning pass on every problem. The goal is to use it when the checkable fields line up: files touched, failing test exists, invariant stated, budget available, and standard single-turn failure. Next action: run the five-task benchmark and log only the metrics your interface exposes.
