Gemini for Coding: Best Prompts and Tips

Picture this: you're a backend developer who's been using Gemini CLI in your terminal for months, and one morning it just stops responding to your usual commands. This isn't a bug — Google retired Gemini CLI and the Gemini Code Assist IDE extensions for individual, Google AI Pro, and Ultra users in mid-June 2026, folding that functionality into a new unified platform called Antigravity. If your gemini coding prompts and workflows were built around the old CLI, some of them need a home in the new tool, and if you haven't touched Gemini's coding tools in a while, this is worth knowing before you build a habit around something that's already being phased out.

Let's tear down a weak Gemini coding prompt and rebuild it for how these tools actually work now.

Before: The Weak Prompt

Here's a prompt that's common with developers new to AI coding assistants:

Fix the bug in my code.

Pasted alongside a file, this produces something — Gemini will find a plausible-looking issue and "fix" it. But without a description of the actual symptom, it's guessing at what "bug" even means, and a confident-looking fix for the wrong problem is worse than no fix at all, because it can mask the real issue while looking resolved.

Why It Fails

Gemini can't distinguish between "code that looks unusual" and "code that's actually causing your specific problem" without you telling it what the actual symptom is. There are many things in any codebase that could theoretically be improved, and without a specific failure description, the model has no way to know which one you actually care about.

⚠️ Common mistake: Assuming the AI can infer your bug from the code alone, the way an experienced teammate familiar with your whole system might. It's reading the file you gave it, not running your application, and it has no access to your actual error logs, test failures, or user reports unless you paste them in. Treat it like briefing someone who joined your team five minutes ago — capable, but starting from zero context about what's actually happening in production.

After: The Improved Prompt

This function is supposed to calculate the discounted price for a 
cart, but it's returning a negative number when the discount 
percentage exceeds 50%. Here's the function [paste code] and here's 
an example input that triggers the bug: cart total $40, discount 
60%. Walk through the logic step by step, identify where it goes 
wrong, and propose a fix.

What this does: A specific symptom, a specific reproducing example, and a request to walk through the logic step by step gives Gemini something concrete to actually debug against, rather than pattern-matching against "code that looks like it might have issues" in the abstract.

Breaking Down Each Element

The reproducing example — the specific input that triggers the bug — is the single highest-value addition to any debugging prompt. Without it, Gemini has to guess at what input might cause the described symptom, and it's guessing across the same space of possibilities you'd be guessing across yourself if you were debugging blind. With it, the model can trace through the exact execution path that produces the failure.

⚡ Pro tip: For bugs that only show up intermittently or under specific conditions, ask explicitly for multiple candidate explanations before a fix: "List at least 2 possible root causes before proposing which is most likely." This matters more for coding than almost any other use case, because a wrong first-guess fix that "resolves" the visible symptom without addressing the actual cause is a genuinely dangerous outcome — the bug often resurfaces later in a different, harder-to-trace form.

Choosing the Right Tool for the Job

Where you actually run these prompts has shifted meaningfully in 2026. Gemini Code Assist Standard and Enterprise, aimed at organizations, continue to support the CLI and IDE extensions with ongoing access to current Gemini models. For individual developers and those on Google AI Pro or Ultra plans, Google has moved coding-agent functionality into Antigravity, a newer multi-agent development platform built to handle more complex, multi-step coding workflows than the original CLI was designed for.

⚠️ Common mistake: Building a critical daily workflow around a specific tool name without checking whether it's still the current supported path. AI coding tools have moved fast in 2026 — features, tool names, and access tiers have shifted more than once within a single year — and it's worth a quick check of official documentation before assuming last year's setup instructions still apply exactly as written.

Code Review and Refactoring Prompts

Beyond debugging, code review benefits from the same specificity principle. A vague "review this code" prompt tends toward generic praise or generic nitpicks. A specific one produces something you'd actually act on.

Review this function for potential issues, specifically: does it 
handle a null or empty input correctly, is there a race condition 
if called concurrently, and does the error handling match our 
team's convention of always returning a Result type rather than 
throwing an exception?

What this does: Naming specific failure categories to check gives the review actual teeth. This is the same principle that makes document-review prompts work well in Docs or Sheets — explicit criteria beat an open-ended "does this look okay" every time, in code just as much as in prose.

⚡ Pro tip: For refactoring requests specifically, separate the "what's wrong" question from the "how should it be structured instead" question into two prompts rather than one. Asking for both simultaneously tends to produce a rewrite that fixes some things while introducing new stylistic choices you didn't ask for, making the diff harder to review carefully.

Common Mistakes

The most consequential mistake in AI-assisted coding isn't prompting at all — it's insufficient review of generated code before it ships, especially for anything touching security, payments, authentication, or data integrity. AI-generated code can look completely correct and pass a casual read while still containing a subtle logic error, and the more "obviously correct" a chunk of generated code looks, the more careful the review it deserves, precisely because confident-looking code lowers a reviewer's guard.

A second mistake, specific to agentic modes like Gemini Code Assist's agent mode or Antigravity's agent workflows: granting broad auto-approval for file changes before you've built trust in a specific tool's judgment for your specific codebase. Auto-approve settings exist for good reason once you've validated a tool's behavior on your project, but starting with manual review of every proposed change, and only relaxing that as the tool proves reliable on your actual code, is the safer default for anyone new to agentic coding tools.

A third mistake worth naming: asking an agentic coding tool to make a large, multi-file change in one shot without checkpoints along the way. A backend engineer at a healthcare startup learned this after an agent mode session touched six files to implement a feature, and one of those changes introduced a subtle regression in an unrelated function that wasn't caught until a later test run. Breaking a large change into smaller, reviewable steps — even when the tool is capable of doing it all in one pass — keeps each individual diff small enough to actually review carefully, rather than trusting a sprawling multi-file change wholesale.

A fourth mistake: not giving the model your project's actual conventions before asking for new code. A prompt like "write a function that validates user input" with no context about your codebase's existing validation patterns, error-handling style, or naming conventions produces code that works but doesn't match anything else in your project — technically functional, but a maintenance headache the moment someone else has to read it alongside your existing code.

Conclusion

The gap between a Gemini coding prompt that wastes the tool's capability and one that uses it well comes down to specificity that mirrors how you'd actually brief a human colleague: the real symptom, a reproducing example, and explicit criteria for what "fixed" or "good" actually means in your context. Combine that with staying current on which specific tool — Code Assist, CLI, or Antigravity — is the right home for your workflow this year, since that's shifted meaningfully even within 2026.

It's a good habit, roughly once a quarter, to spend a few minutes checking whether the specific coding tool you've built your workflow around is still the actively maintained option, rather than assuming a setup that worked six months ago is still the current recommended path. AI coding tools in particular have seen names, tiers, and even entire product lines retired and replaced faster than most other software categories, and a quick documentation check costs far less than discovering mid-project that your terminal tool quietly stopped receiving updates weeks earlier.

Once you've built debugging and review prompts that work reliably for your codebase's conventions, save them — I keep mine in PromptABCD tagged by language and by which tool I built them for, so a debugging session starts from a tested prompt structure instead of reconstructing the right level of specificity from scratch every time.