Getting Began with Conductor for Gemini CLI

# Introduction

 
If you open Gemini CLI, describe a function it is advisable construct, and the agent instantly begins writing code. No questions, no clarifications, no plan. Ten minutes later, you have got 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 could have been sooner to only write it your self.

That is not a Gemini downside. That is a context downside. The agent would not know what you are constructing, what libraries you’ve got 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 Growth (CDD), a structured strategy the place your venture context, specs, and implementation plans dwell in Markdown recordsdata inside your repository, not inside an ephemeral chat window. The agent reads these recordsdata each time it touches your venture. Your fashion guides, your tech stack choices, your product objectives — all of it persists and travels with the code.

Since launch, the Conductor GitHub repository has amassed over 3,600 stars and 284 forks. A Google Codelab strolling by way of a full greenfield venture with Conductor went dwell in April 2026. This text covers the whole lot it is advisable go from zero to operating your first implementation observe.

# What Conductor Really Is

 
Earlier than entering 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 growth.

Commonplace 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 an alternative of describing your venture 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 publish 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 venture 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. If 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.

# Conditions and Set up

 
You want three issues earlier than putting in Conductor.

Gemini CLI have to 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 operating 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. If you first run gemini, it would immediate you to authenticate. Choose Vertex AI and observe the information to set your GOOGLE_API_KEY surroundings variable, or full the browser-based OAuth movement for private use.

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

# 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 robotically.
# 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 just a few seconds.

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

Then contained in the Gemini CLI session:

It’s best to 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 Challenge with /conductor:setup

 
Run this as soon as per venture. It is the command that builds the muse the whole lot else depends upon. Inside your Gemini CLI session, out of your venture listing:

Conductor will instantly begin analyzing your venture. For a brownfield venture, 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 venture, it asks you to explain what you are constructing.

Both method, 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 habits
├── 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 selected position. 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 outdoors your stack. workflow.md is the place you outline whether or not you need test-driven growth (TDD), what your commit technique seems like, and what handbook 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 be able to then customise.

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

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

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

# Beginning a Function with /conductor:newTrack

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

Begin a observe by describing what you need to construct:

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

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

Conductor takes your description, reads the total venture 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 observe ID format is shortname_YYYYMMDD, so dark_mode_20260614 for a darkish mode observe created on June 14, 2026. This retains tracks sorted chronologically in your file system.

spec.md comprises the specification: what downside 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 seems — 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

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

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

## Part 3: Settings Web page Integration
- [ ] Job: Import `ThemeToggle` into the Settings web page element
- [ ] Job: Confirm that desire 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 Guide 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 unsuitable, if a job is lacking, or if the scope is wider than you meant, edit plan.md now. When you run implement, Conductor commits code towards this plan. Altering course mid-implementation is feasible however costlier than catching it right here.

# Implementing with /conductor:implement

 
When you’re glad with the plan:

That is the place Conductor earns its place. It reads plan.md, picks up the primary unchecked job, and begins working by way of the listing. Because it begins a job, 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 job. Not per part, not per session, per job.

You will 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 element with conditional CSS
e5c6d78 check(theme): write unit assessments for useTheme hook
f7d9a34 feat(theme): create useTheme hook with localStorage persistence

On the finish of every part, Conductor pauses for handbook verification. You do not proceed to the following part till you verify the present one is working. That is the “proof over promise” precept from the workflow — the agent would 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 robotically: write the check first, verify it fails, implement the code, verify the check passes, then transfer to the following job. 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 may cease at any level, shut your laptop computer, swap machines, come again the following day, and run /conductor:implement once more. It picks up from the primary unchecked job. The implementation would not dwell in your chat historical past. It lives in plan.md.

If it is advisable change course mid-implementation, you may edit plan.md instantly. Add a job, 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 gives to archive the observe — transferring 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 primary workflow. These 4 deal with the whole lot round it.

// /conductor:standing

Run this at any time to see the place your venture stands throughout all lively tracks:

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

Present Date/Time: Saturday, June 14, 2026
Challenge Standing: 🟡 Energetic

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

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

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

// /conductor:revert

When one thing goes unsuitable and it is advisable undo work:

Conductor is Git-aware in a method 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 observe, 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 may 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 handbook 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 top quality test. It is searching for drift between what the plan specified and what was carried out, and for violations of your product tips — 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 may deal with earlier than the code merges.

// Checking Token Utilization

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

# How Conductor Works for Groups

 
Probably the most underappreciated components of the Conductor workflow is what occurs if you commit the conductor/ listing.

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

This modifications what onboarding seems like. A brand new developer becoming a member of the venture would 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, and so they have the operational image.

The consistency profit is equally important. Each AI-assisted contribution to the venture 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 tougher to take care of 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 whole Conductor workflow seems like from begin to end on a concrete function. Use this because the reference in your first observe on an actual venture.

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

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

Reply the guided questions. If you’re achieved, commit the conductor/ listing.

// Step 3: Create the observe

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

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

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

Open plan.md in your editor. Learn each job. Test that the phases make sense. If something is unsuitable — a lacking job, a part that should not exist, a scope that is too large — edit the file now and reserve it. 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 top of Part 1, it would pause and ask you to confirm manually. Check the work. If you verify it passes, Conductor strikes to Part 2.

// Step 6: Test progress at any level

// Step 7: Evaluate the finished implementation

Tackle 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 job, and a spec that paperwork precisely what was constructed and why.

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

# A Few Issues Price Figuring out Earlier than You Begin

• Token consumption is actual. Conductor reads your venture context recordsdata on each command. For a small venture, that is negligible. For a big brownfield venture with many tracks within the conductor/ listing, it provides up — particularly throughout setup and planning phases. Use /stats mannequin to watch utilization and think about archiving accomplished tracks often to maintain the lively tracks.md lean.
• The --auto-update flag is price utilizing. Conductor is in preview and has been releasing often since December 2025. The --auto-update flag means you get enhancements robotically 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 growth. A imprecise product.md produces imprecise 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 observe that follows.
• Conductor doesn’t substitute code overview. /conductor:overview is a helpful catch for apparent drift and magnificence points, but it surely’s not an alternative to human overview of the code earlier than it merges. Deal with it as a primary move, not a last gate.

# Conclusion

 
The shift Conductor represents isn’t 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 the whole lot that occurs after that first hour — the agent that stays on observe throughout classes, the teammate who can decide 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 fact” and “empowers Gemini to behave as a real extension of your engineering workforce.” That is correct, however the extra sensible method to consider it’s this: Conductor makes the agent’s habits 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 venture, and see what a plan seems like earlier than the primary line of code will get written.

// Assets

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