My AI Stack: Gemini, Claude, Antigravity, and JetBrains Air — Better Together
Hi everyone!
There’s a question I get a lot: “Which AI do you use?”
The honest answer is: all of them. Not because I can’t pick one, but because each one is genuinely the best at something specific, and the real productivity unlock comes from knowing which tool to reach for at which moment.
This is my current AI stack — Gemini, Claude (and Claude Code), Google Antigravity, and JetBrains Air — and how I make them work together.
Gemini — the Google Workspace native
If your day runs on Gmail, Docs, Sheets, Drive, Calendar, and Meet, Gemini is the AI that’s already inside the building. That’s not marketing — it’s the difference between copy-pasting context into a chat window and the model just seeing the document you’re working on.
Where Gemini wins for me:
- Gmail. Drafting replies that actually know who the person is, what we talked about last week, and which thread they’re referencing. “Summarize this thread and draft a reply” is a daily habit now.
- Google Docs. Long-form writing with a model that reads the whole doc, not a pasted excerpt. Rewriting, tightening, expanding, generating a TOC — all inline.
- Sheets. “Build me a formula that does X” works astonishingly well, and it can generate tables from a prompt directly into the cells.
- Meet. Live transcription and meeting notes that land in Drive automatically. I stopped taking notes in meetings months ago.
- Calendar + NotebookLM. Pulling research from a notebook into a calendar block, or feeding meeting notes into a notebook to query later.
Gemini’s superpower isn’t raw reasoning — it’s proximity to your data. When the model lives inside the suite where your work already lives, the friction disappears.
Claude and Claude Code — my reasoning and coding engine
When I need to think hard about something, write longform, design a system, or write code, I open Claude.
Claude (the chat)
For me Claude is the model with the best feel for nuance — it pushes back, asks the right clarifying questions, and produces writing that doesn’t sound like it was generated. I use it for:
- Architecture discussions and design docs
- Reviewing my own writing before I publish it
- Reading long documents (papers, contracts, RFCs) and arguing with them
- Drafting blog posts like this one
Claude Code
This is the one that changed how I work. Claude Code is the CLI agent that lives in my terminal and operates on my actual repos. Not “paste this snippet” — it reads files, writes files, runs tests, opens PRs.
What it’s great at:
- Multi-file refactors where context matters across the whole codebase
- “Implement this feature end-to-end” tasks where you describe the goal and let it iterate
- Reading unfamiliar code and explaining it back to me
- Driving git, gh, and the rest of the dev toolchain without me leaving the terminal
Claude Code is also where subagents, skills, and hooks show up — you can compose the agent to your project’s conventions. It’s not a chatbot bolted onto an editor; it’s an actual agent with tools.
Google Antigravity — the agentic IDE bet
Google Antigravity is Google’s agent-first IDE. The framing is different from a traditional editor: instead of you driving and the AI suggesting, the agent drives — planning, browsing, executing, verifying — and you supervise.
What makes it interesting:
- Multi-agent by default. You can spin up agents that work in parallel across different parts of a task — one researching, one coding, one validating.
- Browser-aware. Agents can open a browser, click around, read pages, and use that as part of their work. Great for “build this from this spec on the web” tasks.
- Tight integration with Google’s models. When you want Gemini’s massive context window and tool-use abilities driving an IDE, this is where it lands.
I use Antigravity for tasks that are bigger than a single repo edit — things involving web research, multi-step verification, or running something, observing the output, and adapting. It’s the closest thing to “give me a junior engineer for an afternoon” that I’ve used.
JetBrains Air — AI inside the IDE I already love
I’ve been a JetBrains user for over a decade. IntelliJ, WebStorm, PyCharm, GoLand — the muscle memory is deep. JetBrains Air is JetBrains’ answer to bringing serious AI assistance natively into that environment.
Where Air shines:
- Deep language understanding. JetBrains has always had the best static analysis. Pairing that with AI means suggestions that respect types, imports, and project structure — not just plausible-looking text.
- Refactorings on steroids. The classic JetBrains “Refactor This” menu, augmented by a model that understands what you actually meant.
- Test generation and explanation. Highlight a method, get a test class. Highlight a stack trace, get an explanation.
- Stays inside the IDE. No tab-switching. No context loss.
When I’m doing focused, deep work in a single project — Java, Kotlin, Python — Air is the assistant that fits the keyboard shortcuts I already have memorized.
The full potential: how they work together
Here’s the secret: no single AI is the best at everything, but together they cover the entire surface of my work.
A real workflow from last week:
- Research phase in Gemini. I needed to understand a third-party API. Pulled the docs into a NotebookLM notebook, asked questions, generated a summary in a Google Doc.
- Design phase in Claude. Pasted the Gemini summary into Claude, brainstormed the architecture, argued with the model about trade-offs, ended up with a design doc I was confident in.
- Implementation in Claude Code. Opened the repo in the terminal, gave Claude Code the design doc, let it scaffold the feature across multiple files. Reviewed each change.
- Heavy refactor in JetBrains Air. Once the feature was working, switched to IntelliJ for the kind of structural cleanup where JetBrains’ refactoring tools plus AI shine.
- Parallel side-quest in Antigravity. While the main work was happening, I had an agent in Antigravity scraping a set of pages and producing a structured dataset I needed for tests.
- Wrap-up in Gemini. Drafted the release notes email in Gmail, updated the spec doc in Google Docs, scheduled the demo in Calendar.
Five tools. One day’s work. Each one used exactly where it was strongest.
My mental model
If you want a cheat sheet for when to reach for what:
- Gemini → anything touching Google Workspace, long-context document work, meetings, email
- Claude → thinking, writing, reading hard things, design discussions
- Claude Code → coding in the terminal, multi-file changes, agentic dev work
- Google Antigravity → agentic tasks that need a browser, parallelism, or supervised autonomy
- JetBrains Air → focused IDE work in a strongly-typed language with deep static analysis
There’s overlap — Claude can write emails, Gemini can write code, Antigravity can do focused edits, Air has chat. Use whichever is closest to where you already are. But knowing the center of mass of each tool lets you start the task in the right place instead of fighting the wrong one.
The real multiplier: spec-driven development
If there’s one workflow change that quietly doubled my output across all of these tools, it’s spec-driven development — and the medium that makes it work is Markdown, everywhere.
The idea is simple: before you let an agent touch code, you write down what you actually want. Not as a chat message that disappears the moment the context window rolls over, but as a persistent file in the repo that any model, any session, any agent can read.
In practice this means a small set of Markdown files that live next to the code:
CLAUDE.md— the project’s instructions to Claude Code. Conventions, commands, “always do X, never do Y”, paths to important files. Every new session starts already knowing how this repo works.TODO.md— the running task list. Not a tracker, not Jira — just a Markdown file the agent can read at the start of a session and update at the end.SPEC.md(ordocs/specs/<feature>.md) — the spec for the thing being built. Goals, constraints, edge cases, acceptance criteria. Written before a single line of code.ARCHITECTURE.md,DECISIONS.md— the long-lived context: why the system looks the way it does, what alternatives were rejected and why.
Why this saves so many tokens
Without specs, every session starts with the agent rediscovering the project: re-reading the same files, re-deriving the same conventions, re-asking the same clarifying questions. Multiply that by every session, every model swap, every context reset, and the token bill — and the cognitive load — gets ridiculous.
With specs:
- The agent reads one file and has the project’s full mental model. CLAUDE.md is loaded once and pays for itself in every subsequent turn.
- Decisions don’t get re-litigated. If the spec says “use Postgres, not SQLite”, you don’t argue about it three sessions later.
- Sessions become resumable. Hand the same TODO.md to a fresh Claude Code session, a Gemini chat, or an Antigravity agent — they all pick up where the last one stopped.
- Reviews get fast. When the agent produces code, you check it against the spec, not against your fuzzy memory of what you wanted.
Markdown is the universal interface
The reason Markdown works as the glue between Claude, Gemini, Antigravity, and Air is that all of them read it natively. A spec written for Claude Code is just as readable by Gemini in a Google Doc, by an Antigravity agent, or by you on GitHub. No proprietary format, no lock-in, no conversion step.
The result is that the AI stack stops being five tools that each forget everything between sessions, and starts being one workflow with persistent memory — and that memory is just a folder of .md files.
If you remember one thing from this post: write the spec first, commit it to the repo, and let every tool in your stack read from the same source of truth. That’s the single biggest unlock I’ve found, and it costs nothing but discipline.
Closing thoughts
The “which AI is best” debate misses the point. The interesting question is: what does your workflow look like when you stop treating these as competitors and start using them as a team?
For me the answer is a stack where the model lives next to the work — Gemini in the suite, Claude in the terminal, Antigravity for agentic tasks, Air in the IDE — and the productivity gain comes from never being more than a keystroke away from the right one.
If you’re still picking one, my advice: stop picking. Pay for the two or three that genuinely fit how you work, and let each one do what it does best.
See you next time!
