Getting Began with Conductor for Gemini CLI

# Introduction

 Once you open Gemini CLI, describe a characteristic it’s worthwhile to construct, and the agent instantly begins writing code. No questions, no clarifications, no plan. Ten minutes later, you’ve gotten 100 traces of implementation throughout 4 information 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 have been proper. Most weren’t. Now you are untangling AI-generated code whereas questioning if it could have been sooner to simply write it your self.

That is not a Gemini downside. That is a context downside. The agent does not know what you are constructing, what libraries you have chosen, what your coding requirements are, or what the characteristic is definitely imagined 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 known as Context-Pushed Growth (CDD), a structured method the place your venture context, specs, and implementation plans stay in Markdown information inside your repository, not inside an ephemeral chat window. The agent reads these information each time it touches your venture. Your model guides, your tech stack selections, your product objectives — all of it persists and travels with the code.

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

# What Conductor Truly Is

 Earlier than entering into the instructions, it helps to know the mannequin Conductor is constructed on, as a result of it modifications how you consider 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 a substitute of describing your venture contemporary each session, you keep a set of Markdown information that do this job completely. The agent reads them on each run. Your coding requirements are all the time loaded. Your product objectives are all the time in scope. The characteristic plan is all the time 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 characteristic, 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 information that maintain venture state
The Model Management Layer is Git, which Conductor makes use of to create per-task commits and help its rollback performance

This works for each greenfield initiatives (ranging from scratch) and brownfield initiatives (current codebases). The brownfield help is price highlighting as a result of most tutorials solely demo clean-slate initiatives. Once you run /conductor:setup on an current 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 work out 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:

If you happen to run into permission errors, use a Node model supervisor like nvm slightly 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. Once you first run gemini, it should immediate you to authenticate. Choose Vertex AI and comply with the information to set your GOOGLE_API_KEY surroundings variable, or full the browser-based OAuth circulate for private use.

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

With these in place, set up Conductor:

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:

It’s best to see the total listing of sub-commands: setup, newTrack, implement, standing, revert, and evaluate. If you happen to see these, you are prepared.

# Setting Up Your Mission 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:

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 appears like, and what guide verification steps you require earlier than phases proceed. code_styleguides/ accommodates 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 may see the conductor/ listing in your venture. Commit it:

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

# Beginning a Characteristic with /conductor:newTrack

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

Begin a monitor by describing what you wish to construct:

It’s also possible to name /conductor:newTrack with out an argument and describe the characteristic interactively when Conductor prompts you.

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

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 accommodates 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 appears — it prevents the agent from gold-plating a characteristic when it ought to be transport it.

plan.md is the implementation guidelines, organized into phases. A darkish mode characteristic would possibly appear to be this:

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 fallacious, 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 towards this plan. Altering course mid-implementation is feasible however dearer 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 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 section, not per session, per activity.

You may see commits accumulating as Conductor works:

Output instance:

On the finish of every section, Conductor pauses for guide verification. You do not proceed to the following section till you verify 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.

If you happen to’re in a TDD workflow (configured in workflow.md), Conductor follows the cycle mechanically: write the take a look at first, verify it fails, implement the code, verify the take a look at 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 implies you’ll be able to 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 worthwhile to change course mid-implementation, you’ll be able to edit plan.md straight. Add a activity, take away one, re-order phases. Conductor reads the file contemporary on every run, so your modifications are picked up instantly.

As soon as all phases are verified and all duties are checked off, Conductor presents to archive the monitor — 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 file.

# The Supporting Instructions

 The three core instructions — setup, newTrack, implement — cowl the principle 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 energetic tracks:

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

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

// /conductor:revert

When one thing goes fallacious and it’s worthwhile to 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 — slightly than commit hashes. If you wish to revert the final section of a monitor, Conductor identifies the commits that belong to that section (utilizing its per-task commit construction) and reverts them cleanly. It additionally updates plan.md to uncheck the affected duties, so you’ll be able to 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 information throughout 14 commits over three phases is a guide train in distress. Conductor handles the archaeology for you.

// /conductor:evaluate

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 verify. It is on the lookout for drift between what the plan specified and what was applied, and for violations of your product pointers — inconsistent error dealing with, lacking accessibility attributes, model information violations.

Consider it as an AI code reviewer who has learn your complete product spec and is aware of precisely what the characteristic was imagined to do. The output is a evaluate report you’ll be able to deal with earlier than the code merges.

// Checking Token Utilization

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

# How Conductor Works for Groups

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

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

This modifications what onboarding appears like. A brand new developer becoming a member of the venture does not want a two-hour walkthrough to know the tech stack decisions, 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 important. Each AI-assisted contribution to the venture follows the identical requirements, as a result of each agent session reads the identical context information. One developer’s Conductor session writes code in the identical model as one other developer’s, as a result of each periods are anchored to the identical code_styleguides/ listing. That is the “group concord” property that will get tougher to keep up as initiatives scale — Conductor builds it into the workflow structurally slightly than counting on builders to implement it manually.

# A Full Walkthrough: Including a Darkish Mode Toggle

 This is what the entire Conductor workflow appears like from begin to end on a concrete characteristic. Use this because the reference in your first monitor 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. Once you’re completed, commit the conductor/ listing.

// Step 3: Create the monitor

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 activity. Test that the phases make sense. If something is fallacious — a lacking activity, a section that should not exist, a scope that is too large — edit the file now and reserve it. Conductor reads the file contemporary 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 Part 1, it should pause and ask you to confirm manually. Take a look at the work. Once you verify it passes, Conductor strikes to Part 2.

// Step 6: Test progress at any level

// Step 7: Evaluation the finished implementation

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

Your entire circulate — setup by way of evaluate — is repeatable for each characteristic that follows. The conductor/ listing grows as a dwelling file of what was constructed, why every determination was made, and what requirements the venture follows.

# A Few Issues Value Figuring out Earlier than You Begin

Token consumption is actual. Conductor reads your venture context information 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 contemplate archiving accomplished tracks usually to maintain the energetic tracks.md lean.
The –auto-update flag is price utilizing. Conductor is in preview and has been releasing ceaselessly 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 aspect of context-driven growth. 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 change code evaluate. /conductor:evaluate is a helpful catch for apparent drift and magnificence points, but it surely’s not an alternative to human evaluate of the code earlier than it merges. Deal with it as a primary cross, not a ultimate gate.

# Conclusion

 The shift Conductor represents just 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 monitor throughout periods, 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 group.” 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 appears like earlier than the primary line of code will get written.

// Assets

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. It’s also possible to discover Shittu on Twitter.