Gemini CLI Is My Weirdest AI Productivity Hack?

I use a lot of AI tools—coding like copilot, agents, chat tools, and IDE integrations. But one tool somehow became one of the most used parts of my workflow: Gemini CLI.

What started as curiosity turned into something much bigger. Over time I began using it for everything: setting up repositories, writing documentation, generating architecture plans, and even running multiple AI “workers” from different terminal tabs. At some point, it stopped feeling like just another AI tool and started feeling more like an experimental productivity engine.

In This Article I'll talk about

• The strange reason Gemini CLI never seems to hit limits for me
• My workflow of running multiple AI terminals at once
• How I generate architecture docs and MVP plans in minutes
• A crazy experiment where I generated dozens of projects automatically
• The story of building a working CLI tool in 2.5 hours
• Things Gemini CLI does better than most AI coding tools
• And a few things that seriously need improvement

How I Started Using Gemini CLI

When I first heard about Gemini CLI, two things stood out:

• A very large context window
• A generous usage model compared to many other AI tools

Naturally, I wanted to test it.

What surprised me the most was something unexpected. While testing it with friends, they would often hit usage limits relatively quickly—sometimes after around a hundred requests. Meanwhile,** my sessions kept going. I could continue making requests, generating code, and experimenting without running into token limits. ** It's the same even now 😭

Friends joked that I was somehow exploiting Gemini CLI and that someone from Google team would eventually reach out to me for my weird use cases.

I still don’t know why that happened, but it gave me the freedom to experiment with some unusual workflows.

One Instruction Repository Setup

One of the first practical uses I discovered was using Gemini CLI to set up entire project repositories with a single instruction.

Normally, starting a project involves a lot of repetitive setup:

• creating folders
• configuring dependencies
• setting up linting and formatting
• writing base documentation
• preparing project architecture

With Gemini CLI, I started doing something much simpler. I would give it one instruction describing the project and the development stack, and it would generate the entire project scaffold.

This includes directory structure, configuration files, dependencies, and even initial documentation. Instead of spending time on boilerplate setup, I can immediately start focusing on the actual idea.

My Multi-Terminal Gemini Workflow

One of the most unusual ways I use Gemini CLI is by running multiple sessions simultaneously.

Instead of relying on a single AI interaction, I open several terminal tabs and assign different responsibilities to each one. Each session acts like a separate worker focused on a specific task.

For example:

one session generates system architecture

another handles frontend implementation

another builds backend logic

another writes documentation

All of these run at the same time.

It feels a little chaotic, but it also dramatically speeds up development. Instead of waiting for one step to finish before starting the next, everything progresses in parallel.

My Implementation Plan System

To make this workflow manageable, I usually start by generating an implementation plan.

These plans break the project into smaller steps and tasks. I store them as files such as:

implementation-1.4.md
implementation-1.5.md

Each file contains:

• implementation steps
• expected outputs
• technical constraints

Once these plans are ready, I distribute tasks across multiple Gemini CLI sessions. One session might implement step 1.4, another step 1.5, and another writes documentation explaining both.

This structured approach turns Gemini CLI into something that feels surprisingly close to a small development team.

Why I Use Gemini CLI for Documentation

Another place where Gemini CLI shines is documentation.

I frequently use it to generate:

• README files
• architecture documentation
• MVP planning documents
• project explanation guides
• system diagrams and architecture descriptions

Because the context window is large, I can provide the full project structure and ask it to generate complete documentation around it.

Some friends even asked how I was able to produce so many structured docs without constantly hitting AI limits. At the time I didn’t reveal the tool, but the answer was simple: Gemini CLI.

Research and Package Discovery

One capability that stands out compared to many AI coding agents is research.

Many tools struggle when asked to find the right libraries, frameworks, or documentation. They often suggest outdated packages or incomplete solutions.

Gemini CLI performs much better in these scenarios, likely because it leverages the broader search ecosystem connected to Google.

When I ask it to find a package, evaluate libraries, or read documentation to determine the correct dependency, it tends to produce much more reliable results.

This is particularly useful when setting up new stacks or integrating unfamiliar tools.

Now few cool stories I have with Gemini cli

The 40-Project Experiment

One of the first major experiments I tried with Gemini CLI was intentionally extreme.

I found a repository on GitHub containing around fifty small web development projects. Instead of building them manually, I selected forty of those projects and asked Gemini CLI to analyse them and generate new versions inspired by them.

The instruction was simple: use the existing projects as inspiration but rewrite them with modifications, improved functions, and additional features.

The process ran for several hours. When it finished, Gemini CLI had produced roughly forty projects with altered logic and added functionality.

They were not perfect, and some contained bugs, but a surprisingly large portion worked correctly. For me, this experiment demonstrated how powerful AI-assisted code generation could become when given sufficient context.

Rewriting Full-Stack Projects

After seeing the results of the first experiment, I tried something more difficult.

This time I found a repository containing multiple full-stack projects built with the MERN stack. I selected ten of those projects and asked Gemini CLI to analyze and rewrite them with structural modifications.

Again, the results were not flawless, but many applications ran successfully with minimal adjustments. The fact that such large transformations could be generated automatically was impressive.

Building a Hackathon Project in Two and a Half Hours

One of my most memorable uses of Gemini CLI happened during a hackathon organized by Major League Hacking.

The challenge involved using MongoDB alongside Gemini.

I didn’t have much time to code, so I decided to rely heavily on Gemini CLI. The project I built was a tool called GitWhisperer.

The idea behind it was simple:

• store commit messages in MongoDB
• analyze commits using the Gemini API
• generate summaries of development progress
• automatically create demo explanations for completed projects

Gemini CLI helped design the architecture, structure the CLI application, and implement the functionality. The entire project was completed in roughly two and a half hours.

For a working command-line tool connected to external APIs, that speed was remarkable.

Now, Things I Think it Could Improve

Even though Gemini CLI is extremely useful, there are still areas where improvements would make it significantly better.

• One limitation is the lack of straightforward image input support. Being able to pass screenshots, diagrams, or UI images directly into the CLI workflow would help with debugging and interface design.

• Another issue is code visibility. Sometimes the CLI shows only partial code changes until they are approved. It would be helpful to preview the entire generated code before applying modifications.

• Session management is another area that could be improved. Currently, sessions often need to be saved manually. Automatic session recovery and resume functionality would make long development sessions more reliable.

• Performance could also be better. Installation can be resource-heavy, and even simple tasks sometimes require significant memory. A more lightweight implementation—possibly built with languages such as Go or Rust—could improve efficiency.

Why I Still Use It Every Day?

Despite these issues, Gemini CLI has become one of my favorite tools.

I regularly use it for:

• documentation generation
• architecture planning
• repository setup
• research and package discovery
• rapid prototyping

More than anything, it enables experimentation. Running several sessions simultaneously and assigning different tasks makes development feel surprisingly dynamic.

It sometimes feels less like using a single AI assistant and more like coordinating a small team of automated developers.

Final Thoughts

AI tools often try to replace existing workflows. Gemini CLI fits differently into the process.

Instead of replacing the workflow, it becomes an extension of it.

For me, it has turned into a flexible system for experimentation, automation, and rapid idea exploration. If you enjoy building things quickly and experimenting with AI-assisted development, it is definitely a tool worth trying.