Getting Began with Conductor for Gemini CLI

# Introduction

 
Whenever you open Gemini CLI, describe a function it’s good to construct, and the agent instantly begins writing code. No questions, no clarifications, no plan. Ten minutes later, you could have 100 traces of implementation throughout 4 recordsdata and none of it matches your precise structure as a result of the agent by no means knew your structure. It made believable guesses. Some had been proper. Most weren’t. Now you are untangling AI-generated code whereas questioning if it might have been sooner to only write it your self.

That is not a Gemini drawback. That is a context drawback. The agent does not know what you are constructing, what libraries you have chosen, what your coding requirements are, or what the function is definitely purported to do. Each session begins from zero.

Conductor, launched in preview on December 17, 2025, is a Gemini CLI extension constructed to repair this. It introduces a workflow referred to as Context-Pushed Improvement (CDD), a structured strategy the place your challenge context, specs, and implementation plans stay in Markdown recordsdata inside your repository, not inside an ephemeral chat window. The agent reads these recordsdata each time it touches your challenge. Your fashion guides, your tech stack selections, your product objectives — all of it persists and travels with the code.

Since launch, the Conductor GitHub repository has accrued over 3,600 stars and 284 forks. A Google Codelab strolling by way of a full greenfield challenge with Conductor went stay in April 2026. This text covers every part it’s good to go from zero to working your first implementation monitor.

# What Conductor Really Is

 
Earlier than moving into the instructions, it helps to grasp the mannequin Conductor is constructed on, as a result of it modifications how you concentrate on AI-assisted improvement.

Normal AI coding workflows are stateless. You open a session, describe what you need, the agent works, you shut the session. Subsequent time you open it, the agent remembers nothing about what you constructed, why you constructed it, or what comes subsequent. As one Google Cloud developer put it, the mannequin is “transient, forgetful, and a little bit of a cowboy.”

Conductor solves this by making context a managed artifact. As a substitute of describing your challenge recent each session, you keep a set of Markdown recordsdata that try this job completely. The agent reads them on each run. Your coding requirements are at all times loaded. Your product objectives are at all times in scope. The function plan is at all times seen.

Google’s announcement submit invokes Benjamin Franklin’s “failing to plan is planning to fail” to explain the philosophy, and the framing holds. The Conductor workflow is: construct context first, spec the function, plan the implementation, then write code. In that order, each time.

Architecturally, Conductor operates as three layers working collectively.

• The Command Layer is what you work together with — six slash instructions inside Gemini CLI
• The Artifact Layer is a conductor/ listing in your repo containing Markdown and JSON recordsdata that maintain challenge state
• The Model Management Layer is Git, which Conductor makes use of to create per-task commits and assist its rollback performance

This works for each greenfield tasks (ranging from scratch) and brownfield tasks (present codebases). The brownfield assist is price highlighting as a result of most tutorials solely demo clean-slate tasks. Whenever you run /conductor:setup on an present repo, Conductor analyzes your codebase, respects your .gitignore and .geminiignore patterns, and infers your tech stack and structure — so you are not manually filling in context Conductor can determine itself.

# Stipulations and Set up

 
You want three issues earlier than putting in Conductor.

Gemini CLI should be put in and dealing. Set up it globally with npm:

# Set up Gemini CLI globally
npm set up -g @google/gemini-cli

# Confirm set up
gemini --version

In the event you run into permission errors, use a Node model supervisor like nvm quite than working as root. After putting in, restart your terminal so the gemini binary is in your PATH.

A Google API key or Vertex AI setup is required for Gemini CLI authentication. Whenever you first run gemini, it should immediate you to authenticate. Choose Vertex AI and comply with the information to set your GOOGLE_API_KEY atmosphere variable, or full the browser-based OAuth move for private use.

Git should be initialized in your challenge listing. Conductor creates per-task commits and depends on Git for its revert performance. In the event you’re beginning a brand new challenge:

# Initialize a brand new git repository if you have not already
mkdir my-project && cd my-project
git init
git commit --allow-empty -m "Preliminary commit"

With these in place, set up Conductor:

# Set up the Conductor extension
gemini extensions set up https://github.com/gemini-cli-extensions/conductor

# The --auto-update flag retains Conductor up to date to new releases mechanically.
# Advisable for many customers.
gemini extensions set up https://github.com/gemini-cli-extensions/conductor --auto-update

The set up downloads the extension from the GitHub repository, registers the six Conductor instructions, configures a GEMINI.md context file because the entry level, and units /conductor because the plan listing. The entire course of takes a number of seconds.

Confirm it labored by launching Gemini CLI and typing /conductor:

Then contained in the Gemini CLI session:

You must see the total listing of sub-commands: setup, newTrack, implement, standing, revert, and overview. In the event you see these, you are prepared.

# Setting Up Your Undertaking with /conductor:setup

 
Run this as soon as per challenge. It is the command that builds the muse every part else is dependent upon. Inside your Gemini CLI session, out of your challenge listing:

Conductor will instantly begin analyzing your challenge. For a brownfield challenge, it scans your codebase to deduce what it is working with — respecting .gitignore to keep away from token-heavy directories like node_modules or __pycache__. For a brand new challenge, it asks you to explain what you are constructing.

Both manner, it then walks you thru a guided Q&A to populate six artifacts it creates inside a brand new conductor/ listing:

conductor/
├── product.md                 # Product imaginative and prescient, customers, objectives, key options, success standards
├── product-guidelines.md      # UI requirements, voice and tone, error dealing with conduct
├── tech-stack.md              # Languages, frameworks, databases, infrastructure
├── workflow.md                # TDD preferences, commit technique, verification protocol
├── code_styleguides/          # Language-specific fashion guides (auto-generated per language discovered)
│   ├── python.md
│   ├── typescript.md
│   └── ...
└── tracks.md                  # Grasp registry of all tracks (begins empty)

Every artifact performs a particular function. product.md solutions the “what are we constructing and for whom” query. tech-stack.md ensures the agent by no means suggests a library or sample exterior your stack. workflow.md is the place you outline whether or not you need test-driven improvement (TDD), what your commit technique appears to be like like, and what guide verification steps you require earlier than phases proceed. code_styleguides/ comprises per-language guides that Conductor ships with pre-populated templates for, which you’ll then customise.

As soon as setup completes, you may see the conductor/ listing in your challenge. Commit it:

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

From this level on, any teammate who clones the repo and opens Gemini CLI has the total challenge context accessible instantly — no onboarding dialog wanted.

# Beginning a Characteristic with /conductor:newTrack

 
A monitor is how Conductor represents a unit of labor. One function, one bug repair, one architectural change — one monitor. Tracks give the agent an outlined scope to work inside, which is the core mechanism that forestalls it from wandering.

Begin a monitor by describing what you wish to construct:

/conductor:newTrack "Add a darkish mode toggle to the settings web page, persisting the choice to localStorage"

You can too name /conductor:newTrack with out an argument and describe the function interactively when Conductor prompts you.

Conductor takes your description, reads the total challenge context from conductor/, and generates three recordsdata inside a brand new conductor/tracks// listing:

conductor/tracks/
└── dark_mode_20260614/
    ├── spec.md           # The "what and why" -- necessities, objectives, technical constraints, out of scope
    ├── plan.md           # The phased, task-level implementation guidelines
    └── metadata.json     # Observe ID, creation date, present standing

The monitor ID format is shortname_YYYYMMDD, so dark_mode_20260614 for a darkish mode monitor created on June 14, 2026. This retains tracks sorted chronologically in your file system.

spec.md comprises the specification: what drawback this solves, what the objectives are, the technical necessities, and explicitly what’s out of scope. The out-of-scope part issues greater than it appears to be like — it prevents the agent from gold-plating a function when it must be delivery it.

plan.md is the implementation guidelines, organized into phases. A darkish mode function may appear like this:

# Implementation Plan - Darkish Mode Toggle

## Section 1: Basis
- [ ] Job: Add `theme` key to the localStorage schema and doc it within the challenge README
- [ ] Job: Create a `useTheme` hook that reads/writes the `theme` worth and defaults to system choice
- [ ] Job: Write unit checks for `useTheme` -- confirm default conduct, localStorage learn, localStorage write
- [ ] Job: Conductor - Consumer Handbook Verification 'Basis' (Protocol in workflow.md)

## Section 2: UI Part
- [ ] Job: Construct `ThemeToggle` part with accessible toggle button (aria-label, keyboard assist)
- [ ] Job: Apply conditional CSS courses based mostly on the present theme worth from `useTheme`
- [ ] Job: Write part checks for `ThemeToggle` -- renders accurately, fires toggle on click on
- [ ] Job: Conductor - Consumer Handbook Verification 'UI Part' (Protocol in workflow.md)

## Section 3: Settings Web page Integration
- [ ] Job: Import `ThemeToggle` into the Settings web page part
- [ ] Job: Confirm that choice persists throughout web page refreshes and new browser tabs
- [ ] Job: Write integration check for the total settings web page with darkish mode enabled
- [ ] Job: Conductor - Consumer Handbook Verification 'Settings Web page Integration' (Protocol in workflow.md)

Learn this plan earlier than you run /conductor:implement. That is the human-in-the-loop second Conductor is designed round. If the phases are mistaken, if a activity is lacking, or if the scope is wider than you meant, edit plan.md now. When you run implement, Conductor commits code in opposition to this plan. Altering course mid-implementation is feasible however dearer than catching it right here.

# Implementing with /conductor:implement

 
When you’re happy with the plan:

That is the place Conductor earns its place. It reads plan.md, picks up the primary unchecked activity, and begins working by way of the listing. Because it begins a activity, it updates the checkbox from [ ] to [~] (in progress). When it completes the duty, it updates it to [x] and creates a Git commit — one commit per accomplished activity. Not per part, not per session, per activity.

You may see commits accumulating as Conductor works:

Output instance:

a3f9c12 feat(theme): write integration check for settings web page darkish mode
b7e2d45 feat(theme): import ThemeToggle into Settings web page
c1a8f90 feat(theme): add accessible toggle button with aria-label
d4b3e21 feat(theme): create ThemeToggle part with conditional CSS
e5c6d78 check(theme): write unit checks for useTheme hook
f7d9a34 feat(theme): create useTheme hook with localStorage persistence

On the finish of every part, Conductor pauses for guide verification. You do not proceed to the following part till you affirm the present one is working. That is the “proof over promise” precept from the workflow — the agent does not simply say it really works, you confirm it really works earlier than the plan advances.

In the event you’re in a TDD workflow (configured in workflow.md), Conductor follows the cycle mechanically: write the check first, affirm it fails, implement the code, affirm the check passes, then transfer to the following activity. You do not have to inform it to do that; the workflow file handles it.

Conductor’s state is saved to disk between duties, which suggests you possibly can cease at any level, shut your laptop computer, change machines, come again the following day, and run /conductor:implement once more. It picks up from the primary unchecked activity. The implementation does not stay in your chat historical past. It lives in plan.md.

If it’s good to change course mid-implementation, you possibly can edit plan.md straight. Add a activity, take away one, re-order phases. Conductor reads the file recent on every run, so your modifications are picked up instantly.

As soon as all phases are verified and all duties are checked off, Conductor provides to archive the monitor — shifting conductor/tracks/dark_mode_20260614/ to conductor/tracks/archive/dark_mode_20260614/ and updating tracks.md to mark it full. Your Git historical past retains the total implementation document.

# The Supporting Instructions

 
The three core instructions — setup, newTrack, implement — cowl the principle workflow. These 4 deal with every part round it.

// /conductor:standing

Run this at any time to see the place your challenge stands throughout all energetic tracks:

Conductor reads conductor/tracks.md and every energetic monitor’s plan.md and returns a abstract:

Present Date/Time: Saturday, June 14, 2026
Undertaking Standing: 🟡 Lively

Lively Tracks:
  * dark_mode_20260614 -- Section 2 of three | 7/12 duties full (58%)
  * api_auth_20260610  -- Section 1 of 4 | 3/5 duties full (60%)

Subsequent Motion Wanted:
  * Run /conductor:implement to proceed dark_mode_20260614 (present monitor)

That is the command to run whenever you sit down after a break and want to recollect the place you had been.

// /conductor:revert

When one thing goes mistaken and it’s good to undo work:

Conductor is Git-aware in a manner that uncooked git revert is not. It understands logical models of labor — tracks, phases, particular person duties — quite than commit hashes. If you wish to revert the final part of a monitor, Conductor identifies the commits that belong to that part (utilizing its per-task commit construction) and reverts them cleanly. It additionally updates plan.md to uncheck the affected duties, so you possibly can re-run /conductor:implement to redo the work.

This issues virtually as a result of rolling again by commit hash when an agent has touched 11 recordsdata throughout 14 commits over three phases is a guide train in distress. Conductor handles the archaeology for you.

// /conductor:overview

After implementation completes, earlier than you open a pull request:

Conductor reads your accomplished plan.md alongside conductor/product-guidelines.md and performs a high quality examine. It is searching for drift between what the plan specified and what was carried out, and for violations of your product pointers — inconsistent error dealing with, lacking accessibility attributes, fashion information violations.

Consider it as an AI code reviewer who has learn your total product spec and is aware of precisely what the function was purported to do. The output is a overview report you possibly can handle earlier than the code merges.

// Checking Token Utilization

Conductor’s context-driven strategy reads your challenge recordsdata on each command, which will increase token consumption — particularly for bigger tasks throughout setup and planning phases. Verify present session utilization with:

# How Conductor Works for Groups

 
One of the underappreciated elements of the Conductor workflow is what occurs whenever you commit the conductor/ listing.

Each file Conductor creates — product.md, tech-stack.md, workflow.md, the fashion guides, each monitor spec and plan — lives in your repository like another file. When a teammate pulls the repo, they’ve the complete challenge context instantly. After they open Gemini CLI and run /conductor:standing, they’ll see each energetic monitor and precisely the place every one is within the implementation plan.

This modifications what onboarding appears to be like like. A brand new developer becoming a member of the challenge does not want a two-hour walkthrough to grasp the tech stack selections, the coding requirements, or what options are in flight. They learn conductor/product.md and conductor/tech-stack.md, run /conductor:standing, they usually have the operational image.

The consistency profit is equally vital. Each AI-assisted contribution to the challenge follows the identical requirements, as a result of each agent session reads the identical context recordsdata. One developer’s Conductor session writes code in the identical fashion as one other developer’s, as a result of each classes are anchored to the identical code_styleguides/ listing. That is the “workforce concord” property that will get more durable to keep up as tasks scale — Conductor builds it into the workflow structurally quite than counting on builders to implement it manually.

# A Full Walkthrough: Including a Darkish Mode Toggle

 
This is what the entire Conductor workflow appears to be like like from begin to end on a concrete function. Use this because the reference on your first monitor on an actual challenge.

// Step 1: Open Gemini CLI out of your challenge listing

// Step 2: If you have not arrange Conductor for this challenge, run setup first

Reply the guided questions. Whenever you’re finished, commit the conductor/ listing.

// Step 3: Create the monitor

/conductor:newTrack "Add a darkish mode toggle to the settings web page, persisting the consumer choice to localStorage and defaulting to system choice on first go to"

Conductor generates spec.md and plan.md in conductor/tracks/dark_mode_20260614/.

// Step 4: Learn the plan earlier than working something

Open plan.md in your editor. Learn each activity. Verify that the phases make sense. If something is mistaken — a lacking activity, a part that should not exist, a scope that is too vast — edit the file now and put it aside. Conductor reads the file recent on each run, so your edits take impact instantly.

// Step 5: Run the implementation

Watch Conductor work by way of the duties, creating commits because it goes. When it reaches the tip of Section 1, it should pause and ask you to confirm manually. Check the work. Whenever you affirm it passes, Conductor strikes to Section 2.

// Step 6: Verify progress at any level

// Step 7: Overview the finished implementation

Deal with any points surfaced by the overview. Then open your pull request with a clear implementation, a full check suite, a Git historical past organized by function activity, and a spec that paperwork precisely what was constructed and why.

The whole move — setup by way of overview — is repeatable for each function that follows. The conductor/ listing grows as a residing document of what was constructed, why every choice was made, and what requirements the challenge follows.

# A Few Issues Value Figuring out Earlier than You Begin

• Token consumption is actual. Conductor reads your challenge context recordsdata on each command. For a small challenge, that is negligible. For a big brownfield challenge with many tracks within the conductor/ listing, it provides up — particularly throughout setup and planning phases. Use /stats mannequin to observe utilization and contemplate archiving accomplished tracks repeatedly to maintain the energetic tracks.md lean.
• The --auto-update flag is price utilizing. Conductor is in preview and has been releasing steadily since December 2025. The --auto-update flag means you get enhancements mechanically with out having to reinstall manually.
• The standard of your context determines the standard of the output. That is the flip facet of context-driven improvement. A obscure product.md produces obscure planning. A tech-stack.md that does not specify your testing framework produces plans that guess at it. The time you spend on the setup artifacts pays dividends on each monitor that follows.
• Conductor doesn’t exchange code overview. /conductor:overview is a helpful catch for apparent drift and elegance points, however it’s not an alternative choice to human overview of the code earlier than it merges. Deal with it as a primary cross, not a ultimate gate.

# Conclusion

 
The shift Conductor represents shouldn’t be primarily about velocity. Writing a spec and a plan earlier than coding is slower within the first hour than diving straight into implementation. The payoff is every part that occurs after that first hour — the agent that stays on monitor throughout classes, the teammate who can choose up the place you left off, the codebase that appears coherent as a result of each contributor labored from the identical context.

Google’s framing for Conductor is that it “treats your documentation because the supply of reality” and “empowers Gemini to behave as a real extension of your engineering workforce.” That is correct, however the extra sensible manner to consider it’s this: Conductor makes the agent’s conduct predictable. Predictable is what you want when the agent is writing code that ships.

The setup takes one session. The context it creates outlasts each session that follows. For a device that prices one set up command to strive, that is an excellent ratio.

Set up it, run /conductor:setup in your subsequent challenge, and see what a plan appears to be like like earlier than the primary line of code will get written.

// Sources

Shittu Olumide is a software program engineer and technical author keen about leveraging cutting-edge applied sciences to craft compelling narratives, with a eager eye for element and a knack for simplifying advanced ideas. You can too discover Shittu on Twitter.