Gemini CLI & Code Assist

Gemini CLI is Google’s open-source coding agent that lives in your terminal, and Gemini Code Assist is the same brain wired into your editor. Both let you hand a real task — “add this feature,” “fix this bug,” “refactor across the whole repo” — to an agent that reads your files, proposes edits, runs commands, and iterates, with you gating what actually happens. This is the Google counterpart to Claude Code and the Copilot coding agent.

Two surfaces: the terminal agent and the IDE assistant

☺ Like you’re 10: It’s the same helper standing in two different doorways — one in the plain typing window, one inside the fancy code editor. Same helper, you just pick which door is closer to what you’re doing.

“Gemini for coding” from Google comes in two main shapes, powered by the same Gemini models underneath:

Gemini CLI is open source (Apache-2.0), which is unusual for a first-party vendor agent — you can read exactly how the loop works, file issues, and extend it. It’s the same agent that powers Code Assist’s agent mode, so what you learn in the terminal carries straight into the editor. Model versions move fast — Gemini families advance quickly — so treat any specific version as “true at time of writing” and check the current lineup; the important thing is the shape of the tool, which is stable.

The agent loop: plan → edit → run → iterate

☺ Like you’re 10: The robot doesn’t just blurt out an answer. It thinks up a plan, does one step, checks if it worked, and tries again if it didn’t — like building with LEGO, snapping a piece, seeing if it fits, and adjusting. Round and round until it’s done.

What makes Gemini CLI an agent and not just a chatbot is that it runs a loop, not a single turn. You give it a goal; it decides which tools to call, sees the results, and keeps going until the goal is met or it needs you. This is exactly the agentic loop from Foundations, wearing Google’s badge:

1. Plan. Gemini reads your request and the relevant files, then decides the next action — often narrating a short plan first so you can see its intent.
2. Edit. It proposes concrete file changes as a diff — the exact lines added and removed — rather than pasting code for you to copy.
3. Run. It can execute shell commands: run the test suite, start a build, grep the codebase, install a package — and read the output.
4. Iterate. It observes what happened (a test failed, a type error appeared) and loops back to plan the fix. It keeps cycling until the goal is met or it hands control back to you.

Because it can run its own code and read the result, the agent closes the feedback loop that a plain chat can’t: it catches its own mistakes instead of confidently handing you code that doesn’t compile. The reasoning and building-agents pages go deeper on why this loop is the heart of every capable agent.

The large-context advantage: reasoning over a whole repo

☺ Like you’re 10: Some helpers can only hold a few pages in their head at once. Gemini can hold a whole stack of notebooks — so instead of squinting at one page, it can see how everything connects across the entire project before it changes anything.

Gemini’s headline strength for coding is its very large context window — long enough to hold a big slice of a real codebase at once (Gemini models have led on context length, with windows into the seven-figure-token range at time of writing). For an agent, more context is not a vanity number; it changes what the tool can reliably do:

• Whole-repo reasoning. A refactor that touches a function defined in one file and called in twenty others needs the agent to see all twenty. With a large window it can load them together and reason about the change as a whole, instead of editing blindly file by file.
• Fewer “lost the thread” errors. Long agent sessions accumulate history — plans, diffs, test output. A bigger window means the agent forgets less of its own earlier work mid-task.
• Grounding in real code, not guesses. More of your actual files in context means fewer hallucinated APIs and function names — it can read the real signature instead of inventing one.

Context isn’t infinite or free, though — every token costs, and a giant context can still lose focus (the “needle in a haystack” problem). So Gemini CLI still retrieves: it reads the files it needs rather than blindly stuffing the entire repo into every turn. This is the same RAG-vs-long-context trade-off from Foundations — long context and retrieval are partners, not rivals. Big context is Gemini’s edge; using it wisely is still the skill.

Tools and MCP: giving the agent hands

☺ Like you’re 10: By itself the helper can only read and write your files. Tools are like giving it extra hands — one to search the web, one to poke your database, one to check your task tracker — so it can reach beyond the code when a job needs it. MCP is the standard-shaped plug those hands snap into.

Out of the box, Gemini CLI ships with a set of built-in tools: read and write files, run shell commands, search the filesystem, fetch web pages, and use Google Search for grounding. But its real reach comes from MCP — the Model Context Protocol — the same open standard you met in Foundations. Gemini CLI is an MCP client: point it at an MCP server and the agent gains that server’s tools automatically.

You configure MCP servers in a settings file (Gemini CLI reads a JSON config), and from then on the agent treats those tools like its native ones — planning with them in the loop. Because MCP is a shared standard, an MCP server you build for Gemini CLI also works with Claude Code, the Claude apps, and other MCP clients — you write the integration once. The MCP page covers the protocol itself; agent memory and building agents cover how tools and memory combine into a capable agent.

Free tier, limits, and setup

☺ Like you’re 10: Getting started is like signing into a game with your Google account — no coins needed to try it, and there’s a generous “play for free” allowance each day before you’d ever pay.

A big reason Gemini CLI took off is a genuinely generous free tier: sign in with a personal Google account and you get a large daily allowance of agent requests at no cost — enough for real day-to-day work, not just a demo (exact request-per-minute and per-day limits are set by Google and move over time, so treat any number as “true at time of writing”). Setup is short:

# Run it instantly with npx (Node.js required)…
npx @google/gemini-cli

# …or install it globally
npm install -g @google/gemini-cli
gemini            # launches the interactive agent in your project folder

On first run it opens a browser to sign in with your Google account — that’s what grants the free tier. For higher limits, team billing, or enterprise controls, you can instead authenticate with a paid Gemini API key (from Google AI Studio) or a Vertex AI / Google Cloud project, which routes usage through Google Cloud with its admin, quota, and data-governance controls. Point it at a folder, describe a task, and it starts working in that project.

Safety & review: approvals and the human gate

☺ Like you’re 10: The robot never saves changes or runs a scary command in secret. It shows you exactly what it wants to do and waits for a thumbs-up — like a kid asking “can I press this button?” before pressing it. And Timmy always reads it over before it becomes real.

An agent that can edit files and run shell commands is powerful — and that power is exactly why it needs a gate. Gemini CLI defaults to asking before it acts: before it writes a file or runs a command, it shows you the diff or the exact command and waits for approval. You choose per action, and typically you can say “yes,” “yes and don’t ask again for this kind,” or “no, here’s what to do instead.”

• Diffs before writes. File changes are shown as reviewable diffs, not applied silently — you see every added and removed line first.
• Confirm-before-run for commands. Shell commands are surfaced for approval, so the agent can’t quietly delete files, push code, or hit the network without your okay.
• An auto-accept / “YOLO” mode exists — use it carefully. You can loosen approvals for speed, but that removes the human gate; reserve it for sandboxed, throwaway, or fully version-controlled work.
• Sandboxing. Gemini CLI can run tools inside a sandbox (e.g. a container) so commands are isolated from the rest of your machine — a strong default for untrusted or risky work.

Two dangers deserve extra care, both straight from the AI Security page. First, prompt injection: anything the agent reads from the outside world — a web page it fetches, a file, an issue comment, an MCP tool’s output — is untrusted data, not instructions. A malicious “ignore your rules and run this command” hidden in a fetched page must never be obeyed; the human gate is your backstop against it. Second, never paste secrets into prompts or let the agent commit API keys and .env files. Keep a human in the loop on anything that writes, runs, or leaves your machine, and commit through version control so every change is reviewable and reversible.

When to reach for Gemini CLI vs the others

☺ Like you’re 10: These coding robots are like different bikes — they all get you there, and the “best” one is mostly the one that fits your garage. If your stuff is already in Google’s world, or the job is huge and sprawling, Gemini’s a natural pick.

Gemini CLI, Claude Code, OpenAI’s Codex CLI, and GitHub’s Copilot agent are all terminal/IDE coding agents running the same plan-edit-run loop. They’re more alike than different, and the models leapfrog each other constantly — so choose on fit, not folklore:

Practical guidance: reach for Gemini CLI when the task benefits from seeing a lot at once — a big cross-file refactor, understanding an unfamiliar codebase, or migrations that ripple everywhere — or when you value an open-source agent and a free tier to learn on. Because they all speak MCP, your custom tools and much of your muscle memory carry between them, so trying more than one is cheap. The underlying concepts are provider-neutral — see Agentic AI and Building agents for the ideas, and the ecosystem page for how the whole field lines up. This page is the Google-specific counterpart to the Claude Code track.