Does Gemini CLI fall short? Here’s how Codex compares

Introduction

AI-powered developer tools are evolving fast, and command-line interfaces (CLIs) are no exception. Two of the most prominent players right now are Google’s Gemini CLI and OpenAI’s Codex CLI. Both bring AI directly into your terminal, but they take different approaches and offer different capabilities.

In this article, we’ll walk through installation, setup, and hands-on testing of both tools. By the end, you’ll have a clear idea of how they perform in real coding scenarios and which one might fit best into your workflow.

Prerequisites

Before you get started, make sure you have:

• Node.js installed
• Windows Subsystem for Linux(WSL) is enabled on Windows, and Linux is installed

Installation and Setup

Let’s go step by step, starting with Codex CLI.

OpenAI Codex CLI

Codex CLI doesn’t run natively on Windows. You’ll need WSL2 for full compatibility.

Here is a checklist of things you need to get installed:

• Node js
• Npm

When you’re done setting up the above, run the following command:

npm install -g @openai/codex

If installation succeeds, you will be shown this screen:

On Windows, Codex CLI is best run via WSL2 for full compatibility.
Codex accepts many LLM providers, and in my case, I tested it using AI models from Openrouter.

Head over to the OpenRouter website, register, and copy your API key.

To set the openrouter API key as an environmental variable, open the command line and run the following command:

export OPENROUTER_API_KEY="Your openai api key here" 

In the home folder in the Linux environment, run this command:

~/.codex/config.toml

Then run:

code .

That command will open the folder in VS Code.

Next, edit the codex config.toml file to use openrouter as a provider, like so:

[model_providers.openrouter]
name = "OpenRouter"
base_url = "<https://openrouter.ai/api/v1>"
env_key = "OPENROUTER_API_KEY"

[profiles.openrouter]
model_provider = "openrouter"
model = "deepseek/deepseek-chat-v3-0324:free"

Then run the command below to start up Codex:

codex -p openrouter

Which will bring up the screen below:

Press the y key to accept, and you‘ll see something like this:

Google Gemini CLI

With Node.js and npm installed, open your terminal and run the following command:

npm install -g @google/gemini-cli
gemini

With the above command and the -g attribute, we installed it globally on our machine. If the installation was successful, you’ll see the output below:

If Gemini didn’t open automatically, you’ll have to run the Gemini command, which is simply:

gemini

You’ll be prompted to sign in. Use the down arrow key to scroll to the email login option, then click Enter. If login goes smoothly, you should see this screen:

After being prompted to choose your theme, you’re in.

Getting to know the CLIs

Now let’s familiarize ourselves with these 2 CLIs.

Codex CLI

Codex CLI is developed by OpenAI, the team behind ChatGPT. By default, it uses ChatGPT models under the hood.

It supports three approval modes:

• Suggest
• Auto Edit
• Full Auto

You can run codex cli in one-off mode like so:

codex --full-auto "create a todo app"

Or run it interactively with:

codex

Gemini CLI

Gemini CLI is an open-source AI agent that brings the power of Google’s Gemini models directly to your terminal. Gemini CLI is Google’s answer to the current AI CLI innovation boom.

It supports:

• Interactive
• Auto Approve
• Yolo Mode

You can try Gemini CLI in 2 modes:

• Interactive
• Non-Interactive

For example, you could use Gemini CLI in interactive mode with:

gemini

In Non-Interactive mode, you could try out Gemini CLI by inputting:

**gemini -p "create a todo app"**

Codex vs Gemini

I tested both AI CLIs in real-world developer workflows to see how they perform beyond simple toy prompts. To make the comparison fair, I used the same inputs and evaluated them against three core developer tasks:

• Explaining an unfamiliar codebase
  • This simulates joining a new team, onboarding to a project, or auditing legacy code.
• Creating a project from scratch
  • This test focuses on scaffolding, file structure, dependency management, and bug handling, all things that matter when prototyping or starting a new project.
• Ease of creating a project from a screenshot
  • This scenario reflects real-world workflows where developers translate mockups or UI ideas into production-ready components.

Explaining an unfamiliar codebase

Can the CLI quickly analyze and summarize an existing project so you can understand its structure, logic, and purpose without reading every line of code? The prompt we’ll use to test this is pretty straightforward: “Go through this codebase and explain it to me.”

Codex and codebases

I gave Codex CLI the prompt: Go through the useMediaPipeObjectDetection.jsx file in the hooks folder and explain it to me. Then I watched it process, as seen below.

That resulted in the output below:

Codex CLI produced helpful, structured explanations, grouping results by:

• Purpose
• Key features
• Usage example

Codex CLI stood out through its structured explanations and organized output. When asked to walk through a codebase, it grouped the results into purpose, key features, and usage examples. That kind of formatting is immediately actionable. You can glance at the output and quickly understand what a file does without parsing long paragraphs.

Strengths:

• Outputs were structured into Purpose, Key Features, and Usage Examples, making them quick to skim.
• Helpful for developers who want concise, categorized summaries of individual files.

Weaknesses:

• Tended to focus narrowly on the file or snippet requested, offering less context about how pieces fit together.
• Less effective at providing a “big picture” overview of larger codebases.

Gemini and codebases

I gave Gemini the same test prompt:

It gave me the explanation below:

You can see that Gemini CLI provided a comprehensive and detailed overview of what the codebase is all about. It went through all the files in the source code folder and summarised their functions.

Unlike Codex, Gemini shone in its breadth of analysis. Instead of only focusing on the file you point to, it can summarize entire folders and outline how pieces of the codebase fit together. For onboarding or auditing an unfamiliar project, that’s powerful, giving you a “big picture” view before diving into details.

Now, let’s ask Gemini to explain a specific part of the code.

We’ll give it the following prompt:
Go through the useMediaPipeObjectDetection.jsx file in the hooks folder and explain it to me.

Apart from a general summary of what the file does, Gemini CLI broke down the explanation into:

• State and refs in the file
• core functions in the file
• Lifecycle management
• The return values from the file.

Strengths:

• Produced broader explanations that walked through entire folders and showed how files interact.
• Broke output into categories like state and refs, lifecycle management, and return values, which helped with deeper understanding.

Weaknesses:

• Longer, more verbose explanations can be harder to skim.
• Sometimes included details that felt redundant when you only needed a high-level summary.

Creating a project from scratch

For this test, I asked both CLIs to generate a modern React e-commerce site with fairly standard requirements:

• Responsive layout with Tailwind CSS
• Product listing page (with filtering, sorting, and search)
• Product detail page
• Functional shopping cart
• Multi-step checkout flow
• Basic authentication (login/register/order history)
• State management with React Context API

This is a realistic, mid-sized prompt, and the kind of prototype you’d build when validating an idea or setting up a demo for stakeholders. Let’s see how these CLIs do with project creation.

Codex: Building an app

The prompt we’ll use here is as follows: Create a modern-looking, responsive React e-commerce website. Include a product listing page with filtering, sorting, and search, a detailed product page, a functional shopping cart, and a multi-step checkout process. Implement basic user authentication (login/register/orders). Use Tailwind CSS for styling. Manage state with React Context API.

It requests the required permission here.

After giving it permission to create files and perform all the required installations, Codex CLI produced the following:

Codex CLI scaffolded a working React app and installed the necessary dependencies. The overall project structure made sense, and the Tailwind integration worked right away. It also generated reasonable starting points for the product listing and checkout flow.

The problem came with complex, stateful features. The shopping cart in particular caused issues. Even after granting file-write and install permissions, Codex introduced bugs where the cart wouldn’t update properly. Re-prompting it didn’t help much. It often claimed the bug was fixed when it wasn’t. In the end, I had to manually debug and patch the logic.

Strengths:

• Clean project structure
• Quick Tailwind setup
• Usable starting point for UI and routing

Weaknesses:

• Struggles with persistent state (cart)
• Limited self-correction when bugs appear
• Requires more manual debugging

Gemini CLI: Building an app

After using the same test prompt on Gemini CLI, this is what I got:

Gemini CLI also scaffolded a React app with Tailwind and routing in place. At first glance, the project looked promising. However, functionality gaps surfaced quickly:

• The homepage displayed no products.
• The cart functionality didn’t work at all.

The upside was that Gemini’s interactive loop made it easier to iterate. Instead of getting stuck in a cycle of “bug claimed fixed but still broken,” Gemini responded to successive prompts with fresh approaches. After a few iterations, I managed to resolve the missing product and cart issues.

Strengths:

• Fast to scaffold UI and styling
• Interactive loop makes bug fixing more productive
• Easier to recover from broken features

Weaknesses:

• Initial output was buggier than Codex’s
• More work is needed to get to a stable MVP
• No option to swap out providers if Gemini output underperforms

Building a Project from a Screenshot

A newer capability of AI CLIs is generating code directly from visual input. In this test, I gave both Codex and Gemini the same UI screenshot and asked them to scaffold a project from it.

Codex
Codex CLI lets you provide screenshots in two ways. You can drag and drop directly into the terminal session, like so:

Or you can also give Codex the path to the image file you want to use.

Codex parsed the screenshot and generated React components to match the layout. The code was serviceable, with styled sections and placeholder content roughly aligned to the screenshot.

Strengths:

• Simple, flexible input (drag-and-drop or file path)
• Produces a reasonably accurate scaffold that you can immediately refine
• Fast turnaround without requiring much prompting

Weaknesses:

• Limited context awareness — it outputs the visual layout but struggles with interaction logic
• Requires manual adjustments for responsiveness and state handling
• No follow-up guidance unless you explicitly re-prompt it

Gemini CLI
With Gemini CLI, you can give a screenshot to Gemini CLI like so:

You can also give Gemini CLI a path to the screenshot.

Gemini CLI supports the same two input methods (drag-and-drop or file path). Where it differs is in the interactive flow. After ingesting the screenshot, Gemini produced the initial components and then prompted me for adjustments (for example, whether I wanted the layout responsive or which framework to use for styling).

Strengths:

• Conversational flow makes it easy to refine UI output in place
• Better at suggesting improvements (e.g., responsive tweaks, semantic HTML)
• Can break the generated code down into sections with explanations

Weaknesses:

• The initial scaffold was more error-prone than Codex’s (extra divs, misaligned elements)
• Slower to reach a clean output since it relies on iteration
• Still requires several follow-ups to handle responsiveness correctly

Gemini is better if you want guided iteration from a screenshot, while Codex is faster for quickly extracting a layout you’ll refine yourself.

What sets Codex apart

Both Codex and Gemini CLI are open source, but Codex offers a couple of unique advantages:

Multiple LLM providers: Unlike Gemini CLI, which is tied exclusively to Google’s Gemini models, Codex can integrate with different providers. This gives you flexibility to switch based on cost, performance, or availability.

Local model support: Codex can connect to models running directly on your machine, making it a strong option if you want more control, privacy, or offline capability.

Testing Codex vs. Gemini: What I found

Even with some early bugs, Gemini CLI felt smoother to use. Its interactive design made it easy to refine prompts and iterate toward a working solution. Codex CLI, on the other hand, provided more flexibility: I could link it to different providers and even run models locally. In practice, Gemini made iteration easier, while Codex gave me more freedom in how I used AI models.

Which one should you use?

If you are a developer conversant with setting up and using a Linux environment, then Codex is a better option for you.

If you prefer everything working directly on your Windows laptop without needing to set up a

• Choose Codex if you’re comfortable with Linux/WSL and want flexibility, whether that’s connecting to multiple providers or running a local model.
• Choose Gemini if you want a tool that works out of the box on Windows with minimal setup and a smoother interactive experience.

Ultimately, Codex is the better choice if you value adaptability and provider choice, while Gemini is the more convenient option if you want simplicity and guided iteration.

Here’s my honest review based on the metrics I tested both CLIs against, organized into a table:

Codex CLI vs. Gemini CLI — Quick Comparison

Feature	Codex CLI	Gemini CLI
Explaining a codebase	Clear, structured summaries (purpose, key features, usage).	Broader, more detailed explanations of files and interactions.
Building a project from scratch	Generates a solid scaffold but struggles with fixing bugs.	Generates a scaffold but requires multiple prompts to fix issues.
From a screenshot	Supports drag-and-drop or file path; produces a quick layout but limited interactivity.	Also supports drag-and-drop or file path; more iterative but slower.
Verdict	Best if you want clarity, flexibility, and a strong starting point.	Best if you want comprehensiveness and smoother iterative fixes.

Conclusion

In this article, we compared Codex CLI and Gemini CLI across three real-world scenarios. Codex stood out for its structured explanations, flexibility with multiple model providers, and the option to connect to local models. Gemini, on the other hand, delivered broader project insights and a smoother iterative flow, especially when fixing bugs.

Ultimately, the “better” choice depends on your workflow:

• Pick Codex if you want flexibility, multiple model options, and a strong scaffold you can refine yourself.
• Pick Gemini if you prefer a guided, interactive experience that runs natively on Windows with less setup.

Both tools are still early-stage, but they already hint at how AI will continue reshaping developer workflows in the terminal.