# Introduction
Whenever you open Gemini CLI, describe a characteristic it’s essential to construct, and the agent instantly begins writing code. No questions, no clarifications, no plan. Ten minutes later, you could have 100 strains 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 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 downside. That is a context downside. The agent does not know what you are constructing, what libraries you’ve got chosen, what your coding requirements are, or what the characteristic is definitely speculated 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 mission context, specs, and implementation plans reside in Markdown information inside your repository, not inside an ephemeral chat window. The agent reads these information each time it touches your mission. Your type 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 mission with Conductor went reside in April 2026. This text covers every part it’s essential 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 concentrate on AI-assisted growth.
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 an alternative of describing your mission contemporary each session, you keep a set of Markdown information 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 characteristic 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 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 mission 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 initiatives (ranging from scratch) and brownfield initiatives (current codebases). The brownfield assist is price highlighting as a result of most tutorials solely demo clean-slate initiatives. Whenever 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:
# Set up Gemini CLI globally
npm set up -g @google/gemini-cli
# Confirm set up
gemini --version
In case 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. Whenever you first run gemini, it is going to immediate you to authenticate. Choose Vertex AI and observe the information to set your GOOGLE_API_KEY atmosphere variable, or full the browser-based OAuth stream for private use.
Git should be initialized in your mission listing. Conductor creates per-task commits and depends on Git for its revert performance. In case you’re beginning a brand new mission:
# 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.
# Really helpful 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 couple 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 complete record of sub-commands: setup, newTrack, implement, standing, revert, and assessment. In case you see these, you are prepared.
# Setting Up Your Undertaking with /conductor:setup
Run this as soon as per mission. It is the command that builds the muse every part else relies on. Inside your Gemini CLI session, out of your mission listing:
Conductor will instantly begin analyzing your mission. For a brownfield mission, 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 mission, it asks you to explain what you are constructing.
Both approach, 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 type 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 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/ comprises per-language guides that Conductor ships with pre-populated templates for, which you’ll then customise.
As soon as setup completes, you will see the conductor/ listing in your mission. 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 complete mission context accessible 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 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 desire to localStorage"
You can too name /conductor:newTrack with out an argument and describe the characteristic interactively when Conductor prompts you.
Conductor takes your description, reads the complete mission context from conductor/, and generates three information 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 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 may appear to be this:
# Implementation Plan - Darkish Mode Toggle
## Section 1: Basis
- [ ] Activity: Add `theme` key to the localStorage schema and doc it within the mission README
- [ ] Activity: Create a `useTheme` hook that reads/writes the `theme` worth and defaults to system desire
- [ ] Activity: Write unit assessments for `useTheme` -- confirm default conduct, localStorage learn, localStorage write
- [ ] Activity: Conductor - Consumer Handbook Verification 'Basis' (Protocol in workflow.md)
## Section 2: UI Part
- [ ] Activity: Construct `ThemeToggle` part with accessible toggle button (aria-label, keyboard assist)
- [ ] Activity: Apply conditional CSS lessons primarily based on the present theme worth from `useTheme`
- [ ] Activity: Write part assessments for `ThemeToggle` -- renders appropriately, fires toggle on click on
- [ ] Activity: Conductor - Consumer Handbook Verification 'UI Part' (Protocol in workflow.md)
## Section 3: Settings Web page Integration
- [ ] Activity: Import `ThemeToggle` into the Settings web page part
- [ ] Activity: Confirm that desire persists throughout web page refreshes and new browser tabs
- [ ] Activity: Write integration check for the complete settings web page with darkish mode enabled
- [ ] Activity: 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 improper, 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 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 job, and begins working by way of the record. 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 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 assessments 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 subsequent 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 case you’re in a TDD workflow (configured in workflow.md), Conductor follows the cycle robotically: write the check first, affirm it fails, implement the code, affirm the check passes, then transfer to the subsequent 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’ll be able to cease at any level, shut your laptop computer, change machines, come again the subsequent day, and run /conductor:implement once more. It picks up from the primary unchecked job. The implementation does not reside in your chat historical past. It lives in plan.md.
If it’s essential to change course mid-implementation, you’ll be able to edit plan.md immediately. Add a job, 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 — 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 complete implementation report.
# 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 mission 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 while you sit down after a break and want to recollect the place you had been.
// /conductor:revert
When one thing goes improper and it’s essential to undo work:
Conductor is Git-aware in a approach that uncooked git revert is not. It understands logical items 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’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:assessment
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 test. It is in search of 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, type 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 speculated to do. The output is a assessment report you’ll be able to deal with earlier than the code merges.
// Checking Token Utilization
Conductor’s context-driven strategy reads your mission 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 type guides, each monitor spec and plan — lives in your repository like another file. When a teammate pulls the repo, they’ve your entire mission context instantly. Once they open Gemini CLI and run /conductor:standing, they’ll see each energetic monitor and precisely the place each is within the implementation plan.
This modifications what onboarding appears like. A brand new developer becoming a member of the mission 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, and so they have the operational image.
The consistency profit is equally vital. Each AI-assisted contribution to the mission 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 type as one other developer’s, as a result of each periods are anchored to the identical code_styleguides/ listing. That is the “crew concord” property that will get more durable to take care of as initiatives 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 like from begin to end on a concrete characteristic. Use this because the reference to your first monitor on an actual mission.
// Step 1: Open Gemini CLI out of your mission listing
// Step 2: If you have not arrange Conductor for this mission, run setup first
Reply the guided questions. Whenever you’re accomplished, commit the conductor/ listing.
// Step 3: Create the monitor
/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 improper — a lacking job, a part that should not exist, a scope that is too large — edit the file now and put it aside. 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 Section 1, it is going to pause and ask you to confirm manually. Take a look at the work. Whenever you affirm it passes, Conductor strikes to Section 2.
// Step 6: Test progress at any level
// Step 7: Evaluate the finished implementation
Tackle any points surfaced by the assessment. Then open your pull request with a clear implementation, a full check suite, a Git historical past organized by characteristic job, and a spec that paperwork precisely what was constructed and why.
The whole stream — setup by way of assessment — is repeatable for each characteristic that follows. The conductor/ listing grows as a dwelling report of what was constructed, why every determination was made, and what requirements the mission follows.
# A Few Issues Price Realizing Earlier than You Begin
- Token consumption is actual. Conductor reads your mission context information on each command. For a small mission, that is negligible. For a big brownfield mission with many tracks within the
conductor/listing, it provides up — particularly throughout setup and planning phases. Use/stats mannequinto observe utilization and think about archiving accomplished tracks frequently to maintain the energetic tracks.md lean. - The
--auto-updateflag is price utilizing. Conductor is in preview and has been releasing incessantly since December 2025. The--auto-updateflag 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 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 assessment.
/conductor:assessmentis a helpful catch for apparent drift and elegance points, however it’s not an alternative choice to human assessment of the code earlier than it merges. Deal with it as a primary go, not a last gate.
# Conclusion
The shift Conductor represents is just not primarily about pace. 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 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 crew.” That is correct, however the extra sensible approach 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 instrument that prices one set up command to strive, that is an excellent ratio.
Set up it, run /conductor:setup in your subsequent mission, and see what a plan appears like earlier than the primary line of code will get written.
// Sources
Shittu Olumide is a software program engineer and technical author captivated with 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.
