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:

Per token, Gemini is far cheaper than the rest (compare OpenAI, Anthropic, and Google pricing). But on consumer plans, what matters is how far each tier gets you before it cuts you off.

Same codebase, same kind of work: features, 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. 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. Claude Code (with Opus 5.5) and Antigravity CLI (with Gemini 3.8 Flash) were virtually tied: neither needed constant reprompting, and both reliably shipped working code in one to two passes on comparable tasks.

3. UI and layout: closer than it used to be

Anthropic’s models used to handle UI and layout work better than the previous Gemini (3.7). Gemini 3.8 closed much of that gap and now gets layouts right in fewer passes.

Neither is flawless. 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.

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. Prompt caching softens this, but turn five still weighs far more than turn one, even if your message is a single sentence.

Reasoning tokens are invisible but count against your limit. 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; it depended on the task.

Claude Code (Opus 5.5 / Sonnet 5)

Claude Code became my go-to 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.

The biggest surprise: Gemini 3.1 Pro was sometimes noticeably worse than 3.8 Flash. Pro tended to overcomplicate changes and introduce regressions, while Flash was direct and landed cleaner diffs, so I now use Flash for my heavier reasoning tasks 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.

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

On the entry plan, Codex couldn’t finish a multi-file refactor across backend service boundaries before hitting its usage limit, at any reasoning level I tried. When I continued after the reset, the result sometimes had compile errors, and other times still needed refining.

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.

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 comes bundled with my Pixel, Antigravity CLI is likely to become my daily driver. Antigravity also offers Claude models with short free limits, which is just enough for reviews.

Limits, models, and pricing change constantly, so run your own comparison on a real task before committing to a plan. Which harness has given you the best mileage? I’d love to compare notes.

(If you want to try what I’m building with this workflow, you can start 7 days free on Max, no card needed.)