Gemini Conductor: Context-Driven Development Guide

Conductor was published in preview on 17/12/2025 by Keith Ballinger (VP and GM), Jay Kornder (Group Product Manager) and Sherzat Aitbayev (Senior Software Engineer). It is open source under Apache 2.0, and it has been iterating quickly ever since — enough that the recommended install command carries an auto-update flag. By the time Google published a full Codelab walking through a greenfield build with it in April 2026, the repository had accumulated several thousand stars and a few hundred forks, which is respectable for a developer tool that asks you to change how you work rather than simply adding a button.

The problem it targets will be familiar to anyone who has spent a week pair-programming with an agent. The first hour is superb. By the third session, the model has forgotten that you chose Postgres over MongoDB, has reintroduced the naming convention you corrected on Tuesday, and is confidently rewriting a module it has no memory of having written. The context was never lost exactly — it was just held in a chat transcript that nobody versioned, nobody reviewed and nobody could share. Conductor's answer is blunt: if the context matters, commit it.

Instead of diving straight into implementation, Conductor helps you formalise your intent. It unlocks context-driven development by shifting the context of your project out of the chat window and directly into your codebase.

Conductor is a structured workflow for agentic development which is ideal for tasks more complex than simple code edits. Unlike a standard chat session which is confined to a single session, Conductor uses a set of Markdown files to plan and track progress over time.

Everything Conductor knows lives in one directory that you commit alongside your source. That is the whole trick, and it is worth looking at the shape of it, because the layout tells you a great deal about how the tool expects you to work.

conductor/
  product.md              # Vision, users, goals, features
  product-guidelines.md   # UI standards, tone, error handling
  tech-stack.md           # Languages, frameworks, databases
  workflow.md             # TDD preferences, commit strategy
  code_styleguides/       # Per-language style guides
    python.md
    typescript.md
  tracks.md               # Registry of all tracks
  tracks/
    dark_mode_20260614/
      spec.md             # Requirements and constraints
      plan.md             # Phased implementation checklist
      metadata.json       # Track metadata

The split between product.md and product-guidelines.md is deliberate and often misunderstood on first use. The first answers "what are we building and for whom"; the second answers "what does good look like here" — error-handling conventions, tone of interface copy, how empty states behave. Agents are remarkably bad at inferring the second category and remarkably good at following it once written down, which makes product-guidelines.md the single highest-leverage file in the directory.

tracks.md is a registry rather than a workspace: each unit of work gets a timestamped directory beneath tracks/, so a feature started in June is still legible in November. On a large project this file grows, and the practical advice is to archive completed tracks so the registry stays lean — every command reads these files, so an unmaintained directory quietly makes every subsequent interaction more expensive.

Because it is all Markdown in Git, the artefacts behave like code. They diff. They go through pull request review. You can blame a line in tech-stack.md and find the conversation where you decided it. Compared with the alternative — a decision that exists only in the scroll history of a terminal session that was closed last Thursday — this is not a small improvement.

Most development work involves established codebases ("brownfield"). This is often where AI tools struggle, lacking the nuanced understanding of a project's history and architecture.

Conductor approaches this challenge by initiating an interactive session to help you create a foundational set of documents about your project’s architecture, guidelines, and goals. As you build new features, Conductor updates this shared context, ensuring its knowledge grows alongside your project.

Mechanically, /conductor:setup scans the codebase to infer what it is working with, respecting your .gitignore patterns as it goes — so vendored dependencies and build output do not pollute the picture. It then interviews you about the parts it cannot infer. This is the stage people rush and later regret: the tool will happily accept a three-line product.md, and every plan it generates afterwards will be exactly as vague as that file was. Treat the setup interview as the actual work, not as onboarding friction.

One realistic expectation to set: on a genuinely old codebase, the inferred tech-stack.md will describe what the repository contains rather than what you have decided to move towards. If half your services are mid-migration, say so explicitly in workflow.md, otherwise the agent will keep proposing changes in the style of the code it can see rather than the style you are trying to reach.

By centralising technical constraints and coding standards, you ensure that every AI-generated contribution adheres to your specific guidelines, regardless of which developer runs the command.

Conductor uses a precise sequence of commands to manage the development lifecycle:

1. Project Setup: /conductor:setup

Builds the base context in a conductor/ directory. Artifacts include:

• product.md: Users, goals, and high-level features.
• tech-stack.md: Languages, databases, and frameworks.
• workflow.md: Team preferences (e.g., TDD).
• styleguides/: Detailed coding standards.

2. New Tracks: /conductor:newTrack

Initialises a feature or bug fix. Generates a track-specific directory with:

• spec.md: Detailed requirements for the job.
• plan.md: Actionable to-do list (Phases, Tasks, Sub-tasks).

3. Implementation: /conductor:implement

The agent works through the plan.md, checking off tasks and pausing at checkpoints for human verification.

The detail that makes this workable in practice is that progress is recorded in the plan file itself. Task checkboxes move from [ ] to [~] while in progress and to [x] on completion, and each finished task produces its own Git commit. The agent pauses at phase boundaries so you can verify before it continues. Because state lives in files rather than in a session, you can stop halfway through on Friday, close the terminal, and resume on Monday from a different machine with nothing lost.

That same property gives you the most useful habit in the whole workflow: read plan.md before you run implement. Conductor re-reads the plan on every run, so editing it is not a workaround — it is the intended control surface. Delete a task you do not want, reorder a phase, tighten a vague instruction. Five minutes spent editing a plan is consistently cheaper than reviewing the code that a bad plan produces.

/conductor:revert is the counterpart and is smarter than it first appears: it reverts by logical unit — a phase or a task — rather than by commit hash, and it also unchecks the affected boxes in plan.md so the work is queued for re-execution rather than silently dropped.

Conductor started life as a Gemini CLI extension, but it did not stay in that lane. The repository now presents itself as a plugin for AI coding agents generally, with documented installation paths for Antigravity and for Claude Code alongside Gemini CLI. That is an unusual move for a first-party Google tool, and a telling one: the value is in the Markdown convention, not in the model that reads it.

agy plugins install https://github.com/gemini-cli-extensions/conductor

/plugin marketplace add gemini-cli-extensions/conductor
/plugin install conductor

One thing to watch: command naming differs between distributions. The Gemini CLI extension documents the short forms (/conductor:setup, /conductor:newTrack), while the plugin distribution registers longer names such as /conductor:conductor-setup and /conductor:conductor-new-track. If a command appears to be missing, list the available commands before assuming the install failed.

The cross-agent story matters for teams more than individuals. If one engineer prefers Gemini CLI, another lives in Antigravity and a third is in Claude Code, they can still share one set of specs, one style guide and one plan format. The convergence on Markdown-in-repo as the interchange layer is arguably the more important trend here, and it is the same instinct behind Claude Skills and the design-system files that agentic design tools now export.

Conductor is genuinely useful, and it is not free of trade-offs. Four are worth knowing before you roll it out.

Token consumption goes up, sometimes sharply. The project's own documentation flags increased token usage, particularly in larger projects during extensive planning and implementation phases — which is the direct consequence of reading a context directory on every command. On a small repository this is invisible. On a large one with a fat style guide and a long track registry, it is a line item. Monitor it rather than discovering it on an invoice.

Output quality is bounded by input quality. A vague product.md produces vague specs, which produce vague plans, which produce code you then have to argue with. Conductor does not add rigour; it makes the absence of rigour explicit and durable, which is uncomfortable but useful.

/conductor:review is not a code review. It checks work against your guidelines and hunts for specification drift and style violations, which catches the obvious failures well. It is a pre-flight check before opening a pull request, not a substitute for the human on the other end of it.

There is a real process cost. For a one-line fix, running setup, creating a track and generating a plan is absurd overhead, and you should just ask the agent to make the change. Conductor earns its keep on work that spans multiple files, multiple sessions or multiple people. Knowing which side of that line a task falls on is a judgement the tool cannot make for you.