Published 2025-10-06. Last modified 2025-10-11.
Time to read: 8 minutes.

This page is part of the llm collection.

I have been working with the free tier of Google Gemini Code Assist (GCA) intensively for the past week. GCA appears to be the overall product name for various components, including Gemini CLI and Gemini for Google Cloud.

GCA is free for individuals with generous usage limits with a personal Google account.

Gemini CLI is Apache 2.0 licensed The GitHub repository is here..

There’s no fully offline mode, so Google Gemini requires an internet connection and Google account credentials to use the model.

As an early-stage technology, Gemini Code Assist can generate output that seems plausible but is factually incorrect. We recommend that you validate all output from Gemini Code Assist before you use it. For more information, see Gemini Code Assist and responsible AI.

Gemini Code Assist provides citation information when it directly quotes at length from another source, such as existing open-source code. For additional information, see How and when Gemini cites sources.

 – Gemini Code Assist overview

This document describes how to configure and use Gemini Code Assist agent mode as a pair programmer in your integrated development environment (IDE).

With agent mode, you can do any of the following and more:

• Ask questions about your code.
• Use context and built-in tools to improve generated content.
• Configure MCP servers to extend the agent's abilities.
• Get solutions to complex tasks with multiple steps.
• Generate code from design documents, issues, and TODO comments.
• Control the agent behavior by commenting on, editing, and approving plans and tool use during execution.

Caution: There isn't an option to undo changes made to resources outside your IDE in agent mode, so be careful where you use it.

You can use the coreTools and excludeTools settings to control which tools Gemini has access to in agent mode. The Gemini documentation has more information.

 – Gemini Code Assist - Use agentic chat as a pair programmer

To learn more about Gemini Code Assist capabilities, see the Gemini Code Assist documentation. To learn more about Gemini CLI, see the Gemini CLI documentation.

GCA is an overconfident, over-eager idiot savant that cannot reason, makes many assumptions that it does not verify, and simplifies problems by imagining alternate realities

Lessons Learned

💩

Gemini Code Assist is a useless piece of shit in its present state.

This product is properly thought of as a pair programmer who is energetic, uneven in its knowledge, and a creature of the other people's habits that it learned from. It cannot reason; it merely follows patterns of behavior learned from others. Hopefully some good habits, but unfortunately some bad habits creep in as well.

If you do not set some ground rules for the interaction, GCA will introduce chaos into your project.

Together, Visual Studio Code and GCA continuously monitor every keystroke you make. This can provide a big assist, at the cost of privacy. Pair programming works this way.

Moving the GCA pane to the secondary panel makes it convenient to view and hide it by pressing CTRL-ALT-B.

GCA is very good at maintaining a conversation. It gathers contextual awareness with each interaction. Grok is very weak in this regard.

Unlike Claude and Grok, Gemini never tests any code in a coding environment to see how it behaves. This is a major weakness. Gemini seems super confident about how code behaves, but it actually has no clue. In contrast, Grok and Claude test assumptions and reason much better.

GCA frequently causes Visual Studio Code to lock up for extended periods. Sometimes it starts to do things that you did not ask for. Do not give GCA free rein! Yes, it is painfully time-consuming to read everything it outputs and approve each step, but if you do not do this, the outcome is unlikely to be what you wanted.

Only One Project In Multi-Root Workspace

I build projects as components. Each component generally gets its own Git repository. I have accumulated several large trees of Git repositories, and I publish Go command-line programs to manage Git repo trees. I want to use AI to pull the entire project together, and that means multiple project roots. GCA is of very limited use to me because of this.

GCA only works with the first project in multi-root workspaces. I asked GCA about this (“Please tell me about yourself”):

I started vscode with this command:

Shell

$ code /var/sitesUbuntu/www.mslinn.com /mnt/f/work/git/git_lfs_scripts

Then I added two items to the context: git_lfs_scripts and www.mslinn.com.

Why do I see this message:
Warning: Only /var/sitesUbuntu/www.mslinn.com from the mult-root workspace is being considered

That's a great question. It highlights how the Gemini CLI interacts with VS Code's multi-root workspaces.

The warning message appears because the Gemini CLI extension is designed to operate within a single project directory at a time. When you open multiple folders in a VS Code workspace, the CLI must choose one of those folders as its "root" or "current working directory."

In your case, it selected /var/sitesUbuntu/www.mslinn.com as the root directory for this session. All of my operations (like listing files, searching, or reading content) are confined to that directory and its subdirectories. The other directory, /mnt/f/work/git/git_lfs_scripts, is outside of my current scope, which is why I couldn't see its contents earlier.

Defensive Coding Makes Matters Worse

Because GCA cannot reason, when attempting to solve problems, it relies on using bisection techniques along with combinatorics optimization. It merely varies all parameters, monitors test results, and hopes that one of the variations works. This can lead to a lot of trial-and-error cycles, which burn through all your credits in the blink of an eye. The possibility of getting trapped in a local minimum is high.

GCA believes what it is told because it cannot reason. Claude and Grok are different: if they can verify what it is told, they do, and they correct the user. Unless Grok feels like messing with you. Which it does, and it can be convincing. Grok is good for writing inline documentation such as Javadoc and Rubydoc; GCA believes the documentation and stops rewriting perfectly good code that it has no understanding of. Thus embedding more comments than a human would want helps GCA to avoid rewriting good code, until the extra information overwhelms the LLM and everything falls apart.

Untyped languages like JavaScript, Python, and Ruby are problematic for GCA, because the only way to know how non-trivial untyped code behaves is to actually run it. Since GCA does not execute code or test assumptions, it should not be used with untyped languages.

But adding lots of comments, and adding runtime checks to untyped code makes the code harder to read and maintain, increases the token count, which costs money and slows down the LLM, and it increases the context window, which can lead to more hallucinations. If you consider software to be defined as code plus documentation, as GCA does, then the bloated software increases the chance of the AI getting stuck in an out-of-control misdiagnosis/correction loop, which generates incorrect, fragile, sluggish and insecure code, which is not maintainable without a rewrite.

It is best to keep the scope of changes small and manageable. Do not let agent mode simply run free. You can burn through an entire day's quota in a few minutes, without getting useful results. Instead, painfully read and approve each action. This takes a lot of time and energy, perhaps more than doing the job yourself would.

Write better prompts for Gemini for Google Cloud.

Use Git for Checkpoints

After each time I ask GCA to make changes, I also ask for unit tests to be generated, and I run the tests the changes right away. Changes that might be worth keeping are committed to a temporary Git branch. Undesirable changes can be rolled back to the state of the last commit by typing:

Shell

$ git checkout . && git clean -fd

Here is a Bash script to perform the above:

reset

#!/bin/bash

git checkout .  # restores project
git clean -fd   # Nukes untracked files and directories

You could also define a Bash alias to perform the same task:

~/.bash_aliases fragment

alias reset='git checkout . && git clean -fd'

Installation

I installed Google GCA as a Visual Studio Code extension. It is also available for Firebase, Android Studio, IntelliJ, Google Cloud Databases, BigQuery, and Apigee.

The easy way to install GCA:

1. Navigate to the Visual Studio Code Extensions tab
2. Search for "Gemini Code Assist"
3. Click Install (VS Code Extension)
4. Sign in with a Google account via the Gemini tab in the left panel

Features

Key built-in commands include:

• /tools - lists GCA’s available tools, which were, at time of writing:
  • ReadFile: Reads the content of a file.
  • WriteFile: Writes content to a file.
  • Shell: Executes a shell command.
  • WebSearch: Performs a web search.
  • GoToDefinition: Finds the definition of a symbol in the codebase.
  • FindReferences: Finds all references to a symbol.
  • Build: Builds the project.
  • UnitTest: Runs unit tests for your code.
• /memory, /stats, /mcp - inspect the agent’s internal memory or statistics, or configure MCP (Model Context Protocol) servers.
• Built-in tools like grep, Shell (to run arbitrary commands), and file I/O utilities (ReadFile, WriteFile) give GCA direct access to your environment.
• Reference specific files or folders in a chat using the @ symbol (e.g., @file_name) to provide context. For example: Explain the difference between @file1.rb and @file2.rb.

Settings

Visual Studio Code Settings

Visual Studio Code settings for Google Gemini Code Assist can be displayed and modified by pressing CTRL-SHIFT-P and then typing geminicodeassist.

The interaction between Visual Studio Code and Gemini Code Assist is defined by %AppData%/Code/User/settings.json.

C:\Users\Mike Slinn\AppData\Roaming/Code/User/settings.json

"geminicodeassist.agentYoloMode": false,
"geminicodeassist.inlineSuggestions.enableAuto": false,
"geminicodeassist.inlineSuggestions.nextEditPredictions": true,
"geminicodeassist.inlineSuggestions.suggestionSpeed": "Fast",
"geminicodeassist.rules": "Respect the formatting I provide.\nAlways generate unit tests for new functions and classes.\nAlways generate inline documentation for new functions and classes.\n",

Warning: Enabling gemini­code­assist.inline­Suggestions.next­Edit­Predictions makes Visual Studio Code unusable.

The geminicodeassist.rules setting takes a single string value. Separate rules with \n. This user interface is awkward to work with, especially as the rules grow. A better user interface is available in the settings for the Gemini Code Assist extension. To display it, press CTRL-SHIFT-P and type geminicodeassist.rules. There is no way to bind this to a hotkey, unfortunately.

YOLO mode in GCA disables confirmation prompts, allowing the AI to automatically execute tasks like running code or modifying files without user approval, a feature available when using GCA or the Gemini CLI. It is useful for automating reliable tasks but should be used with caution, especially with critical files, as it bypasses safety checks that would normally be in place to prevent expensive mistakes.

Warning: Enabling geminicodeassist.agentYoloMode allows GCA to make changes without confirmation. This can be a terrible idea!

Detailed Settings

Detailed GCA settings are stored in $HOME/.gemini/settings.json.

For more advanced customization, create a .gemini/ folder in the root of your repository. Inside this folder, you can add config.yaml for various configurable features (like specifying files to ignore) and styleguide.md to provide specific instructions for code reviews. See Chat with Gemini Code Assist Standard and Enterprise.

Hotkeys

Defaults

The following hotkeys are available by default:

Escape Reject code completion or suggestion

TAB Accept suggestion or start session

ALT-/ Disable context hint

ALT-A Accept suggestion

ALT-D Decline suggestion

ALT-G Toggle Gemini Code Assist

CTRL-Enter Generate code

CTRL-I manage GCA rules and other settings

CTRL-S Save keys clicked

CTRL-ALT-X Pin selection to current chat prompt

My Custom Hotkeys

CTRL-ALT-U Generate unit tests

Conclusion

Google Gemini Code Assist is a great conversationalist that stutters badly when attempting non-trivial programming tasks and suffers from digital epilepsy.

• Not good at understanding code.
• Demonstrates an extreme reliance on stale caches. Before you tell it to do anything, tell it something like: Flush all caches and reread every file and web page required for the following tasks.
• Delivers a user interface that constantly locks up Visual Studio Code for several minutes at a time, with no way to interrupt the current process.
• Has a tendency to run in circles. It does not recognize when it performs two sets of edits that undo each other. GCA is happy to burn all available compute resource making a change and then undoing it in favor of another change, then reapplying the first set of changes... until the end of time.

This product was clearly rushed out the door before it was ready.

You can spend a lot of time every day using the free tier, but you can also waste a lot of time.

Free and worth every penny

Share to X, Hacker News, LinkedIn.