Conductor Revolutionizes Development with Gemini CLI

Introduction to Conductor for Gemini CLI

When using Gemini CLI, you simply describe a feature you want to develop, and the agent immediately starts writing code. However, this process can often lead to unsatisfactory results. Indeed, the agent generates code without knowing the specific architecture of your project, leading to implementations that do not meet your expectations. You may find yourself untangling this generated code, wondering if you would have been better off writing it yourself.

This problem does not stem from Gemini itself, but from a lack of context. The agent knows nothing about your project: the libraries you use, your coding standards, or even the precise purpose of the feature. Each session begins without memory of the past.

Launching Conductor

To address this issue, Google launched Conductor in a preliminary version on December 17, 2025. This extension of Gemini CLI introduces a new workflow called Context-Driven Development (CDD). Unlike a simple ephemeral chat window, the context of your project, specifications, and implementation plans are stored in Markdown files within your repository. These files are read by the agent at every interaction with your project, ensuring that your directives, technical decisions, and product goals are always taken into account.

Since its launch, Conductor has seen notable success with over 3,600 stars and 284 forks on GitHub. A Google Codelab, published in April 2026, offers a comprehensive pathway to using Conductor in a project.

Understanding Conductor

Before exploring Conductor's commands, it is essential to understand the model it is based on, as it fundamentally changes the approach to AI-assisted development.

Traditional AI coding workflows are stateless. You open a session, describe your need, the agent works, and then you close the session. The next time you open it, the agent has forgotten everything. As a Google Cloud developer described, this model is "transient, forgetful, and a bit cowboy."

Conductor changes the game by making context a managed element. Rather than re-describing your project in every session, you maintain a set of Markdown files that permanently retain this information. The agent consults them at each execution, ensuring that your coding standards, product goals, and feature plans are always visible.

Google's announcement post cites Benjamin Franklin: "Failing to plan is planning to fail," to illustrate Conductor's philosophy. The Conductor workflow follows this order: build the context, specify the feature, plan the implementation, and then write the code.

Architecturally, Conductor operates through three collaborative layers:

• The Command Layer: this is the user interface you interact with via six commands in Gemini CLI.
• The Artifact Layer: a conductor/ directory in your repository that contains Markdown and JSON files for the project state.
• The Version Control Layer: Git, used by Conductor to create commits per task and manage rollbacks.

Conductor is compatible with both greenfield (new) and brownfield (existing) projects. For brownfield projects, Conductor analyzes your existing codebase, respects your .gitignore and .geminiignore files, and deduces your tech stack and architecture.

Prerequisites and Installation

Before installing Conductor, you need to have three items:

• Gemini CLI must be installed and functional. Use npm to install it globally:

# Install Gemini CLI globally
npm install -g @google/gemini-cli

# Check the installation
gemini --version

If you encounter permission issues, consider using a Node version manager like nvm. After installation, restart your terminal so that the gemini binary is in your PATH.

• A Google API key or Vertex AI configuration is necessary for Gemini CLI authentication. Upon the first execution of gemini, it will prompt you to authenticate. Select Vertex AI and follow the instructions to set your GOOGLE_API_KEY environment variable or complete the OAuth flow for personal use.

• Git must be initialized in your project directory. Conductor relies on Git to create commits per task and manage rollbacks. For a new project:

# Initialize a new git repository if not already done
mkdir my-project && cd my-project
git commit --allow-empty -m "Initial commit"

With these prerequisites in place, install Conductor:

# Install the Conductor extension
gemini extensions install https://github.com/gemini-cli-extensions/conductor

# The --auto-update flag keeps Conductor updated automatically.
# Recommended for most users.
gemini extensions install https://github.com/gemini-cli-extensions/conductor --auto-update

The installation downloads the extension from GitHub, registers the six Conductor commands, sets up a context file GEMINI.md as the entry point, and defines /conductor as the plan directory. The process is quick.

Check the installation by launching Gemini CLI and typing /conductor. You should see the complete list of subcommands: setup, newTrack, implement, status, revert, and review.

Setting Up Your Project with /conductor:setup

Run this command once per project. It establishes the foundation upon which everything else rests. From your Gemini CLI session, in your project directory:

/conductor:setup

Conductor begins analyzing your project. For a brownfield project, it scans your codebase to determine what it is working with, respecting .gitignore to avoid heavy token directories like node_modules or pycache. For a new project, it will ask you to describe what you are building.

It then guides you through a series of questions to fill out six artifacts it creates in a new conductor/ directory:

├── product.md                 # Product vision, users, goals, key features, success criteria
├── product-guidelines.md      # UI standards, tone and voice, error handling behavior
├── tech-stack.md              # Languages, frameworks, databases, infrastructure
├── workflow.md                # TDD preferences, commit strategy, manual verification protocol
├── code_styleguides/          # Language-specific style guides (automatically generated by found language)
│   ├── python.md
│   ├── typescript.md
└── tracks.md                  # Master log of all tracks (starts empty)

Each artifact has a specific role. product.md answers "what are we building and for whom." tech-stack.md ensures that the agent never suggests a library or framework outside your stack. workflow.md defines your test-driven development (TDD) preferences, your commit strategy, and the manual verification steps required before progressing through phases. code_styleguides/ contains language guides that Conductor provides with pre-filled templates, which you can customize.

Once the setup is complete, you will see the conductor/ directory in your project. Commit it:

# Commit the Conductor context to your repository
git add conductor/
git commit -m "chore: initialize Conductor context-driven development"

From then on, any team member who clones the repository and opens Gemini CLI has immediate access to the complete project context, without the need for onboarding conversations.

Starting a Feature with /conductor:newTrack

A track is how Conductor represents a unit of work. A feature, a bug fix, an architectural change — all of these constitute a track. Tracks give the agent a defined scope, which is essential to prevent it from going off track.

To start a track, describe what you want to build:

/conductor:newTrack "Add a dark mode toggle button to the settings page, retaining the preference in localStorage"

You can also call /conductor:newTrack without an argument and describe the feature interactively when Conductor prompts you.

Conductor takes your description, reads the complete project context from conductor/, and generates three files in a new directory conductor/tracks/<track_id>/:

conductor/tracks/
└── dark_mode_20260614/
├── spec.md           # The "what and why" -- requirements, goals, technical constraints, out of scope
├── plan.md           # The phased and task-based implementation checklist
└── metadata.json     # Track ID, creation date, current status

The track ID is formatted as shortname_YYYYMMDD, so dark_mode_20260614 for a dark mode track created on June 14, 2026. This keeps tracks sorted chronologically.

spec.md contains the specification: what problem it solves, what the goals are, technical requirements, and what is explicitly out of scope. The out-of-scope section is crucial to prevent the agent from overloading a feature.

plan.md is the implementation checklist, organized by phases. A dark mode feature might look like this:

# Implementation Plan - Dark Mode Toggle
## Phase 1: Foundation
- [ ] Task: Add the `theme` key to the localStorage schema and document it in the project README
- [ ] Task: Create a `useTheme` hook that reads/writes the `theme` value and defaults to the system preference
- [ ] Task: Write unit tests for `useTheme` -- check default behavior, reading from localStorage, writing to localStorage
- [ ] Task: Conductor - Manual User Verification 'Foundation' (Protocol in workflow.md)
## Phase 2: UI Component
- [ ] Task: Build the `ThemeToggle` component with an accessible toggle button (aria-label, keyboard support)
- [ ] Task: Apply conditional CSS classes based on the current theme value from `useTheme`
- [ ] Task: Write component tests for `ThemeToggle` -- renders correctly, triggers toggle on click
- [ ] Task: Conductor - Manual User Verification 'UI Component' (Protocol in workflow.md)
## Phase 3: Integration into Settings Page
- [ ] Task: Import `ThemeToggle` into the settings page

Each phase is clearly defined, allowing the agent to work efficiently while adhering to your specifications and context.