Lessons Learned from a Gemini CLI Experiment

I’ve been using Copilot Pro for a while now, so none of this was completely new to me. I already knew that Agent mode consumes more premium requests. That trade-off was clear going in, and I was fine with it.

What I didn’t expect was how quickly it would add up.

Four days after the monthly reset, I checked my usage and saw I was already at 25%. That was the part that caught me off guard. I hadn’t been experimenting recklessly or leaving agents running for fun. It was just regular work—some planning, some refactoring, some moments where letting the agent take the wheel felt like the most efficient choice.

At the time, I wasn’t really thinking in terms of quota. I was thinking in terms of momentum. Agent mode was helping me move faster, so I kept using it.

Seeing that number changed the mood almost instantly. With 26 days still to go, the math was hard to ignore. Even though I understood why the usage was high, I hadn’t realized it would start feeling tight this early in the month.

That was when the awareness kicked in. Not frustration—just a quiet shift in how I worked. I started noticing every prompt, every request, every moment I delegated something to the agent. And once you start thinking about the counter, it’s hard to unthink it.

That’s what pushed me to look for a fallback.

Looking for “Good Enough” (and Free)

I wasn’t looking to ditch Copilot entirely. I just needed a ‘plan B’—something nearby that I could lean on when that premium counter started breathing down my neck.

I poked around at a few free options. Some were great with context but too stingy with message limits. Others were powerhouse models but required so much configuration friction that I’d spend more time fiddling with rather than actually coding.

Gemini CLI ended up being the sweet spot.

First Impression of Gemini CLI

The free tier felt surprisingly generous—I didn’t hit any obvious limits during my testing, which was a relief. I ended up digging into the official pricing just to see where the boundaries were, but for my workflow, it felt plenty generous.

Getting it running on my machine was actually pretty painless. No complex config—I just added the Gemini CLI folder to my system path and I was good to go.

Since this was my first time using an AI agent directly in the terminal, the built-in commands were a huge help. They have a solid onboarding guide too, which made the initial setup feel seamless.

To see if the model could actually handle a real-world workload, I decided to run a small, contained experiment.

The Experiment: Scaffolding Three .NET MCP Servers

Because of my recent interest in Model Context Protocol, I decided to use Gemini CLI to build three small .NET MCP servers that pull data from the same MongoDB database, each from a different collection:

• Product inventory
• Product ranging
• Product pricing

The goal wasn’t correctness or performance. It was to understand how Gemini CLI behaved across repetition , context reuse , and incremental changes.

I started with inventory where I gave Gemini CLI a sample MongoDB JSON document and asked it to help scaffold a basic data ingestion app around that structure into MongoDB.

Once that was in place, I duplicated the same ingestion pattern for ranging and pricing. At this point, I was less interested in creativity and more interested in consistency. I wanted to see whether the tool could hold onto the same shape of solution without drifting.

From there, I moved on to creating the MCP servers themselves. First, the inventory MCP server. Follow by the ranging MCP server and last but not least the pricing MCP server.

Each server followed roughly the same structure. Different data, same expectations. Gemini CLI helped keep things consistent—and in this context, that was exactly what I wanted. It stayed on track without drifting into weird architectural tangents or overcomplicating the logic.

To close the loop, I ran a few checks using MCP Inspector. Nothing surprising came out of it, which was honestly the best outcome I could have asked for.

My Lesson Learned

By the end of the experiment, Gemini CLI definitely earned a spot in my toolkit. Here are my main takeaways as a first-time user:

• Response Speed was a bit slower than what I’m used to with Claude Sonnet in Copilot.
• The /chat Command: This was a standout feature for me. It makes it easy to save, list, resume, or export conversation history without any friction.
• Self-Correction: Just like Copilot, Gemini CLI is good at iterating through errors. When it got stuck creating the .NET MCP Server for inventory, it actually tried searching for ‘MCP csharp sdk example github’. When it still couldn’t resolve the issue, it didn’t just give up—it prompted me with specific instructions on what it needed to move forward.

Searching for MCP Examples Specific Instructions From Gemini CLI

• Testing Guidance: It provided a clear, step-by-step process for testing my server. Since this was my first time building an MCP server, the recommendation to use the MCP Inspector was incredibly insightful for me.

Instruction to Test MCP Server

• I can easily run shell command directly from Gemini CLI using shell mode commands.
• By default, Gemini CLI will automatically choose the best model for the tasks. If you want Gemini CLI to use specific model, you can refer to https://geminicli.com/docs/cli/model/ to configure it when starting the CLI.
• Last but not least, the /stats command is great for keeping an eye on token usage and session duration so you aren’t flying blind.

Statistics for Gemini CLI Session

What’s Next

I’m not switching camps. I’ll probably keep using Copilot Pro. But I’m glad I now have an alternative that doesn’t make me constantly aware of a usage counter.

This experiment was mostly about using Gemini CLI as a learning tool, and building a few MCP servers was just a convenient way to make that learning concrete. The next thing I’m curious about is going a bit deeper—specifically exploring the /mcp capability itself.

Building MCP servers with Gemini CLI is one thing. Understanding how it supports MCP workflows natively feels like a different experiment altogether. That’s likely where I’ll spend more time next.

For now, this is less about outcomes and more about building intuition, one small experiment at a time.

The post Lessons Learned from a Gemini CLI Experiment first appeared on Codey Grove.