I had a nagging feeling about running Gemini 2.5 Pro as my default model every day.
"Fix this bug," "Add comments to this file," "Write a unit test for this function" — the kind of work that fills most of a developer's day. Does that really need the most capable model available? I started suspecting that response speed might matter more than peak accuracy for the tasks I repeat dozens of times a day.
So in mid-April, I switched Antigravity's default model to Gemini 2.5 Flash and kept it there for three weeks. Here's what I measured, what surprised me, and the system I settled on.
The Concern Before Switching
The intuitive worry was simple: a less capable model means more mistakes. Especially for complex refactoring sessions or long-context conversations where the model needs to hold many files in view at once.
That worry turned out to be half right, half wrong. The half that was wrong is the more interesting finding.
Setting Up Gemini 2.5 Flash in Antigravity
Changing the default model in Antigravity takes about 30 seconds. Navigate to Settings → Model → Default Model in the left sidebar. The dropdown offers both "Gemini 2.5 Flash (Thinking)" and plain "Gemini 2.5 Flash."
The difference matters: the Thinking variant runs a reasoning pass before generating output, similar to how Gemini 2.5 Pro operates. Plain Flash skips the reasoning step entirely.
For most purposes, I recommend starting with the Thinking variant. You can then tune the thinkingBudget parameter to find the right speed-quality balance:
// Antigravity config (~/.config/antigravity/settings.json)
{
"defaultModel": "gemini-2.5-flash",
"thinkingMode": "adaptive",
"thinkingBudget": 1000
}The thinkingBudget caps Thinking tokens per request. The default is auto (unlimited), but setting it to 1000–2000 cuts response times significantly for everyday tasks without causing noticeable quality loss. I've been running at 1000 for routine work and temporarily switching to auto for complex multi-file changes.
Response Time Measurements
Here are my actual measurements across three weeks (MacBook Pro M4 Max, 300Mbps Wi-Fi, average of 20+ requests per configuration):
- Gemini 2.5 Pro (Thinking auto): 8.2 seconds average
- Gemini 2.5 Flash (Thinking auto): 4.8 seconds average
- Gemini 2.5 Flash (Thinking budget 1000): 2.9 seconds average
- Gemma 4 local: 1.4 seconds average (varies heavily with context length)
Raw numbers can be misleading. The perceptible difference between 4 and 3 seconds is minimal — you barely notice it. The difference between 8 and 3 seconds is very noticeable. It's the difference between losing and maintaining your train of thought during a debugging session.
When you make 40–60 AI requests in a workday, that gap compounds. I estimated a saving of roughly 4–6 minutes of waiting per day. That doesn't sound like much in isolation, but it represents fewer interruptions to flow state.
Where the Quality Difference Was Real (Concrete Examples)
Tasks where Flash matched Pro closely:
- Single-function bug fixes (the vast majority of daily debugging)
- Adding code comments and generating docstrings
- Writing unit tests for existing functions
- Moderate refactoring contained within one or two files
- Resolving TypeScript type errors
- Explaining what a piece of code does
These categories cover roughly 75–80% of my daily AI-assisted work. Flash handled all of them without meaningful quality loss.
Tasks where Pro clearly outperformed Flash:
The gap appeared most clearly in multi-file changes requiring architectural awareness.
// Scenario: Adding authentication middleware to an Express app.
// Flash occasionally missed propagating changes to dependent files.
// Flash-generated version — functionally incomplete
const handler = async (req: Request) => {
const data = await db.query(req.params.id);
return Response.json(data);
// Missing: error handling, auth check, 404 case
};
// Pro-regenerated version — caught all edge cases
const handler = async (req: Request) => {
if (!req.user) {
return new Response('Unauthorized', { status: 401 });
}
try {
const data = await db.query(req.params.id);
if (!data) return new Response('Not found', { status: 404 });
return Response.json(data);
} catch (err) {
console.error('[handler]', err);
return new Response('Internal error', { status: 500 });
}
};For changes spanning three or more files, or anything requiring the model to reason about the overall project structure, Pro produced fewer omissions. The gap widened as context length increased. For a 5,000-line codebase, Flash was nearly equivalent to Pro. For a 50,000-line codebase spread across many files, the difference was significant.
Impact on Token Usage and Credits
Antigravity's Usage tab tracks token consumption per week. Comparing three weeks before and after the switch:
- Before switch (Pro as default): ~1.2M tokens/week
- After switch (Flash as default): ~0.9M tokens/week
Approximately 25% reduction. This doesn't translate directly to money saved on a flat subscription, but it extends credit longevity and — crucially — it creates headroom to use Pro more freely for the work that genuinely benefits from it.
The psychological effect matters too. When credits feel abundant, you make requests more freely. When they feel constrained, you hesitate and try to batch requests, which disrupts natural conversation with the IDE.
Adjusting Prompts for Flash
One observation worth noting: Flash responds slightly better to explicit, specific prompts than Pro does. Pro can work well with loose, conversational requests because it reasons more deeply about intent. Flash benefits from a little more structure.
# Less effective with Flash
"Clean up this file a bit"
# More effective with Flash
"Refactor this file: extract the validation logic into a separate function,
add JSDoc comments to public functions, and remove the commented-out code blocks"
This isn't a limitation so much as a calibration — being more specific also produces better results with Pro. The Flash switch encouraged me to be more deliberate about what I'm asking, which I think improved my overall prompting habits.
The Model Switching System I Settled On
After three weeks, I've established a simple rule of thumb. Antigravity's Cmd+Shift+M (Mac) or Ctrl+Shift+M (Windows/Linux) switches models instantly, making the overhead of switching negligible.
Use Flash (default):
- Everyday bug fixes and error resolution
- Changes within a single file
- Test generation and type corrections
- Code explanation and documentation
- Rapid iteration on small features
Switch to Pro when:
- Designing new features from scratch
- Making changes across 3+ files
- Asking "why is this approach better than alternatives"
- Responding to code review comments across a PR
- Anything where you sense Flash is missing context
Use Gemma 4 local for:
- Working offline or on unstable connections
- Code you prefer not to send to the cloud
- Fast completions when context is small
The interesting thing is that the Pro invocations feel more deliberate now. Before, Pro was the default and I used it for everything without thinking about it. Now, switching to Pro is a conscious choice that signals "this task needs more care." That subtle shift seems to improve how I frame the requests.
What Three Weeks Taught Me
Switching models revealed something I hadn't consciously noticed before: waiting 8 seconds repeatedly, throughout a workday, disrupts thinking rhythm in a way that 3 seconds doesn't. The cumulative effect is real.
The accuracy concern resolves naturally through use. After about a week of Flash-first development, I had a clear intuitive sense of which tasks needed Pro. That boundary is learnable — and it's worth learning, because it helps you understand what you're actually asking AI to do.
For solo developers optimizing AI usage, starting with Flash as the default is worth trying before assuming the highest-tier model is always necessary. The answer depends on your work patterns, but for most developers, Flash handles the majority of daily tasks with no meaningful quality drop.
Common Pitfalls When Switching Models
Forgetting that Flash defaults are different. When you create a new chat session in Antigravity, it uses your configured default model. But if you've been using Pro in a long session and switch back to Flash for a new session, your mental model of "how much the AI knows" may carry over inappropriately. Flash with a fresh context needs more explicit background for complex tasks.
Using the same thinkingBudget for all tasks. A budget of 1000 works well for most everyday tasks, but for architectural decisions or debugging obscure issues, temporarily setting it to auto (or at least 4000) produces noticeably better results. I keep a keyboard shortcut macro that temporarily overrides the budget for a single session.
Expecting Flash to volunteer caveats. Pro tends to proactively mention edge cases you didn't ask about. Flash is more literal — it answers what you asked and stops there. Once you know this, you can compensate by explicitly asking "what edge cases am I missing?" when it matters. It's a small prompt addition that closes most of the quality gap for those moments.
If you want to push further on Antigravity model efficiency, pairing Flash with good context management makes a significant difference. The context window management guide for large codebases covers how to structure your project to get consistent results regardless of which model you're running.