Google banned the doorway, not the burglar By Rahmat Wibowo From InfraLoka

A look at why suspending developers for using OpenCode with Antigravity OAuth solves a quota problem by punishing the wrong people, and what a sane enforcement policy would have looked like instead.

Google did not ban OpenCode. It banned the people who logged into it. Somewhere between a community plugin and an automated trust-and-safety system, a quota-protection measure turned into blanket account suspensions, including for developers who were paying customers simply trying to use the models they'd already bought access to.

A plugin, an OAuth flow, and a shortcut

Antigravity is Google's own AI coding environment, built around models like Gemini and routed through its own subscription quotas. OpenCode is a separate, open-source terminal agent that supports many providers and auth flows. A community plugin, opencode-antigravity-auth, let OpenCode authenticate against Antigravity's OAuth flow, effectively letting a terminal tool borrow Antigravity's quota and model access without opening the Antigravity IDE at all.

Google's own Antigravity FAQ already states that third-party tools accessing Antigravity violate its Terms of Service. Once usage was detected, the response was swift: reports describe instant lockouts, shadow bans, and suspended accounts, including paid subscribers who say they assumed an "Sign in with Google" button was exactly what it looked like.

Three legitimate worries, one blunt response

Concern 01: Quota arbitrage

Subsidized access, unsubsidized use

Antigravity's pricing assumes usage happens inside Antigravity. Routing that same subsidized quota into a terminal agent breaks the economics Google built the product around.

Concern 02: Product boundary

Keeping Antigravity inside Antigravity

Google wants Antigravity access to remain a feature of Antigravity, not a backend any third-party coding agent can plug into for free.

Concern 03: Reliability

"Degrades the experience for legitimate users"

Google's framing is that unofficial access strains infrastructure meant for people using the product as intended.

None of these concerns are unreasonable. Platforms are allowed to protect their own economics. The problem isn't the worry. It's the instrument Google chose to address it.

The ban punishes the interface, not the abuse.The core failure of the enforcement design

Five fallacies hiding inside a ToS clause

Exhibit A: False equivalence

"Third-party client" was treated as "abuser"

A developer using their own paid account through a different interface is not automatically a quota reseller or attacker. Collapsing "unofficial access" and "malicious use" into one category ignores the much larger group of people just trying to work in their terminal.

Exhibit B: Slippery slope

"If we allow this, everyone will abuse it"

That's a possibility, not a demonstrated outcome. Rate limits, scoped tokens, and per-client registration exist precisely so platforms don't have to choose between "open the gates" and "ban on sight."

Exhibit C: Category error

A product violation became an account punishment

Misusing one feature of one product escalated into broader account-level consequences. The scope of the punishment didn't match the scope of the violation.

Exhibit D: Appeal to the rulebook

"It violates the Terms of Service" isn't a design defense

Pointing at the ToS explains why an action is legal. It says nothing about whether instant, unexplained suspension was the right way to enforce it.

Exhibit E: Collective punishment

Curious developers paid the same price as quota farmers

If a minority used the plugin to stack accounts and evade limits, banning everyone who touched it punishes ordinary experimentation alongside genuine abuse.

What enforcement could have looked like

None of this requires Google to tolerate quota arbitrage. It requires Google to build the same kind of graduated, scoped enforcement that API platforms already use elsewhere, distinguishing a curious developer from an automated account-rotation scheme, instead of treating an OAuth screen as a tripwire.

Closing argument

Google wants developers building with Gemini. But penalizing them for trying to bring that workflow into the tools they already use sends the opposite signal. The fix was never "official IDE or nothing." It was an official API, clear limits, and enforcement that looks at what someone did, not just which window they did it through.