Codex vs Claude Code vs Antigravity CLI: Which AI Coding Agent Is Worth It?

Three AI coding agents. Two $20 subscriptions and one I get for free. One question: which one actually ships working code before the usage meter runs dry?

Short answer from my own daily use: Codex burned through my allowance the fastest and needed the most passes to get things right. Claude Code and Antigravity CLI both did more with less. If you are a solo builder on an entry-level plan, I would not start with Codex today.

The Setup

I’ve written before about moving to agent-based development and the constant battle to optimize context. This time I wanted a straight comparison of the three harnesses I actually use:

If you are looking at raw token economics across official provider rates, Google’s Gemini models are by far the cheapest on the market: Gemini 3.8 Flash sits around $0.10 per million input tokens, compared to $2.50 to $3.00 for OpenAI and Claude mid-tier models, and $15.00 for Opus. Prices shift frequently, so check the linked pricing pages for the latest numbers, but the gap in scale remains enormous. For a solo builder testing consumer plans, effective value comes down to how far each tier lets you get before cutting you off.

Same codebase. Same kind of work: feature implementation, refactors, and bug fixes on the JupiterGoals backend and landing page.

This is one builder’s hands-on experience, not a lab benchmark.

What I Saw

1. Token burn: Codex > Claude Code > Antigravity CLI

Codex drained my allowance the fastest, even with reasoning dialed down to medium or low. Claude Code came second. Antigravity CLI, especially with Gemini 3.8 Flash, stretched the furthest.

The biggest spike came during implementation, not planning. Even when I handed Codex a finished plan that only needed its steps followed, it still consumed the most tokens and took the longest to complete.

2. Passes to “done”: Codex needed the most

With Codex, I regularly needed multiple rounds of “that broke X, please fix it” before a task actually worked as expected. In contrast, Claude Code (with Opus 5.5) and Antigravity CLI (with Gemini 3.8 Flash) were virtually tied: neither required constant reprompting, and both reliably shipped working code in one to two passes on the exact same tasks.

Why Retries Are So Expensive

High burn per turn is annoying. High burn multiplied by more turns is what empties a plan in days. The right unit is cost per working change, not cost per prompt.

Three mechanics explain why the numbers diverge so sharply:

Every retry resends the conversation. Agent harnesses replay the accumulated context (your instructions, files read, previous diffs, error output) on each turn. Turn five is far more expensive than turn one, even if your message is a single sentence.

Reasoning tokens are invisible but billed. Lowering the effort level reduces this “thinking”, but does not remove it. If the agent also explores the codebase broadly before writing code, you pay for that exploration on every attempt.

A failed pass costs as much as a successful one. Worse, it adds its broken diff and error logs to the context, making the next attempt even heavier.

How Each Harness Earned Its Place

Neither Claude Code nor Antigravity CLI won across the board. Which one did better depended on the task.

Claude Code (Opus 5.5 / Sonnet 5)

I mainly used Claude Code for investigation. Its first exploration of a repository is not cheap, but once it has context, follow-up turns are efficient and it needs few correction passes.

Antigravity CLI (Gemini 3.8 Flash / 3.1 Pro)

Paired with Gemini 3.8 Flash, Google’s terminal agent was the lightest on my usage limits by a clear margin. When Flash gets something wrong, it gets it wrong quickly, without burning a huge reasoning budget first, so iteration stays cheap.

In fact, one of my biggest surprises was comparing Gemini 3.1 Pro against Gemini 3.8 Flash. You would expect a heavier “Pro” model to be better suited for complex reasoning and architecture, but 3.1 Pro was sometimes noticeably worse than 3.8 Flash. It tended to overcomplicate changes, drag out reasoning tokens, and introduce regressions. Gemini 3.8 Flash was more direct, landed cleaner diffs, and rarely required reprompting. Because of that, I ended up changing my reasoning model to 3.8 Flash too.

It also beat Opus outright in places. When refining my living specification, I gave Gemini 3.8 Flash and Claude Opus 5.5 (on high effort) the exact same prompt, and in several cases Flash produced the better refinement. The heavier model is not automatically the better one.

UI and layout: closer than it used to be

In my testing, Anthropic’s models handled UI and layout work better than Gemini 3.7. Gemini 3.8 closed much of that gap and now gets layouts right in fewer passes.

Neither is flawless. Even after corrections, both still sometimes miss basics, like a screen that doesn’t fill the whole viewport and forces you to scroll. Always check UI output in a real browser.

Codex (Sol / Astra): couldn’t finish within the limits

The deciding issue was simple: on the entry plan, Codex couldn’t complete a multi-file refactor across backend service boundaries before hitting its usage limit. That held with Sol on medium and high reasoning, and with Astra on low. When I continued after the limit reset, the result sometimes had compile errors, and other times still needed refining. Even Sol on low reasoning, which is already expensive on this plan, needed those extra passes.

The models may well do better on a higher tier. But for my workflow on this plan, I haven’t found a case where Codex is worth using.

Is It Just Me?

Other developers’ complaints about $20 Codex limits vanishing quickly, and about needing several prompts to fix regressions, lined up closely with mine. Still, treat all of this as anecdotal: limits, models, and pricing change constantly. Run your own comparison on a real task before committing to a plan.

Stay Harness-Agnostic

The real lesson is not “pick the best tool.” It’s don’t get locked into any tool. I set up harness-agnostic directive files early on, so I can swap harnesses whenever limits, pricing, or model quality shift. Three practices make that work:

1. Keep sessions clean per task. One session per task (or tight group of related tasks). A clean session doesn’t drag stale history along, and you never pay to reload context you no longer need.
2. Reference specs and plans, don’t paste them. Point the agent at the exact section of the spec and the implementation plan it needs, instead of loading everything up front.
3. Make every task resumable from any harness. Progress lives in the repo (the spec, the plan, the commits), not in one tool’s chat history. If one harness hits its limit mid-task, another can pick up exactly where it stopped.

My Verdict

For JupiterGoals, I’m dropping Codex entirely. Given its performance and the fact that it costs me nothing, Antigravity CLI is likely to become my daily driver. It also offers Claude models for free with short limits, which is just enough for reviews.

And because my workflow is harness-agnostic, that choice is never final. If the balance shifts again, I swap harnesses and keep going.

Which harness has given you the best mileage? I’d love to compare notes.

(If you want to follow the journey of building JupiterGoals, you can join the ‘Founding Member’ waitlist for early access and future updates.)