# Conductor: spec-driven development for Antigravity and Claude Code

> Conductor is an Apache-2.0 plugin that makes an AI coding agent write a spec and a plan before it writes code. Here is how the install works, what it generates, and where the approach gets expensive.

**gemini-cli-extensions/conductor** — A plugin for AI coding agents (Antigravity, Claude Code) enabling Spec-Driven Development to specify, plan, and implement software features.

- Repository: https://github.com/gemini-cli-extensions/conductor
- Stars: 3,754 · Forks: 298
- Language: Python
- License: Apache-2.0
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/gemini-cli-extensions-conductor

## What Conductor actually solves for AI coding agents

Most agent sessions start from a blank prompt. You describe a feature, the agent writes code, and the reasoning behind the structure it chose is never recorded anywhere you can review. Conductor's answer is to make the agent behave like a project manager: it runs a fixed protocol of Context, then Spec and Plan, then Implement, and it writes each stage to disk. The README frames the goal as treating context as a managed artifact alongside your code, so the repository becomes the source of truth that drives later agent interactions. The audience is teams already using Antigravity or Claude Code on a codebase that outlives a single session, where a second engineer or a second agent needs to know why a module is shaped the way it is. For a one-file script, none of this pays for itself.

## Tracks, specs and the conductor/ directory

The unit of work is a track, created by /conductor:conductor-new-track. According to the README, Conductor generates two artifacts for a track: specs, which hold the detailed requirements for the job, and a plan. Setup runs once and produces a fixed set of files: conductor/product.md, conductor/product-guidelines.md, conductor/tech-stack.md, conductor/workflow.md, conductor/code_styleguides/ and conductor/tracks.md. That layout is the whole mechanism. Because the files are plain markdown in the repository, they are diffable and reviewable, and the agent reads them back on later tasks instead of guessing at your conventions. The README states that workflow.md is used as a customizable template, so team preferences such as TDD or a commit strategy are edited in a file rather than passed in a prompt each time. The trade-off is that this context is re-read on every task, which the README itself flags under token consumption.

## Installing Conductor in Antigravity and Claude Code

The README gives two end-user paths. For Antigravity, installation is a single command from GitHub:

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

For Claude Code, the plugin is registered through the marketplace commands inside a session:

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

Contributors who want live edits can clone the repository and symlink it into the Antigravity plugin directory, so local changes load without reinstalling:

```bash
git clone https://github.com/gemini-cli-extensions/conductor.git
cd conductor
mkdir -p ~/.gemini/config/plugins/ && ln -sfn "$(pwd)" ~/.gemini/config/plugins/conductor
```

For a single project rather than the whole machine, the README creates a local plugin directory and links the clone into it:

```bash
mkdir -p .agents/plugins/
ln -sfn /absolute/path/to/cloned/conductor .agents/plugins/conductor
```

The first real use is the setup command, which runs once per project and drives the interview that produces the context files.

```bash
/conductor:conductor-setup
```

After it completes you should see the conductor/ directory in your repository with product.md, tech-stack.md, workflow.md and the rest. Removal is symmetric: agy plugins uninstall conductor for the CLI install, rm -f on the symlink for either link method, and /plugin remove conductor plus /plugin marketplace remove gemini-cli-extensions/conductor for Claude Code.

## The UX adapter and why the same plugin looks different in each host

Conductor ships a View Layer UX Adapter that changes the interaction style based on the host. In an editor that supports visual dialog elements, the README states that selections, decision interviews and track options are captured as native graphical modal windows, with adapter rules living in rules/. In a plain terminal console such as Claude Code, the same steps become numbered text menus of the form [1] Option A, [2] Option B. The README calls this adaptation zero configuration. That is a fair description of the user-facing behaviour, but it also means the two hosts do not produce identical transcripts of a decision, and the rules/ directory is where the visual variant is defined. If you fork Conductor to change how prompts are presented, that is the directory you are editing, and it is also the part most likely to diverge from upstream as hosts change their plugin APIs.

## Token cost is the honest limitation

The README does not hide this. It carries a note that the spec-driven approach involves reading and analyzing project context, specifications and plans, and that this can lead to increased token consumption, especially in larger projects or during extensive planning and implementation phases. It points at /stats model in compatible clients as the way to check consumption for the current session. Note the qualification: compatible clients. If your client does not expose that command, you are measuring the cost yourself. The second limitation is structural rather than financial. A protocol that requires a spec before implementation is the wrong tool when the task is exploratory, when you do not yet know what you want, or when the change is small enough that writing the spec takes longer than the edit. Conductor's own framing is that it keeps you in the loop by letting you review plans before code is written; that review step is the value, and it is also the friction.

## How Conductor differs from plain agent rules files

The obvious alternative is what most teams already do: a hand-written instruction file such as CLAUDE.md or an equivalent rules document that the agent loads at the start of a session. The difference in approach is lifecycle versus reference. A rules file is static context you maintain by hand; Conductor adds commands that generate and update that context, splits it across product, guidelines, tech stack, workflow and code style guides, and then layers tracks, specs and plans on top per task. The second difference is revert. Conductor advertises a git-aware revert command that operates on logical units of work such as tracks, phases and tasks rather than commit hashes. A rules file gives you nothing here; you are back to git log and git revert by hand. If your team's conventions already fit in a short instructions file and your tasks are small, the extra machinery buys you little. If your tasks span days and multiple agents, the difference between a reference document and a managed lifecycle is the whole point.

## Maintenance, licence and what to verify before adopting

The repository is not archived, and the last push was on 2026-09-01. Recent releases listed are conductor-v0.4.1 and conductor-v0.4.0, both dated 2026-03-11, and conductor-v0.3.1 from 2026-02-19, so the release cadence visible here is roughly monthly across that window. Treat the version number as a signal: 0.x means the command surface and the generated file layout can still change, and the README does not document a migration path between versions or a rollback procedure for a bad setup run. The licence is Apache-2.0, which permits commercial use and modification and includes an explicit patent grant; it also requires that you preserve notices and state significant changes. That is a summary of the identifier, not legal advice, and if you redistribute a modified Conductor inside a product you should have counsel read the NOTICE and attribution requirements. Upgrade cost is low in the sense that the plugin is markdown and rules files, and high in the sense that conductor/ artifacts already committed to your repository will not rewrite themselves when the protocol changes.

## Conclusion

Adopt Conductor if you already run Antigravity or Claude Code and want a reviewable spec and plan in git before an agent edits anything; the generated conductor/ directory and the git-aware revert are the parts worth evaluating. Skip it for one-off scripts or throwaway prototypes, where the setup interview and the extra context reads cost more tokens than the task is worth. Before committing, run /conductor:conductor-setup on a throwaway branch, read conductor/workflow.md and conductor/tech-stack.md to confirm the agent captured your actual conventions, and check whether your host client supports /stats model so you can see what the planning phase costs.

## FAQ

### How do I use Conductor with Claude Code?

Register the marketplace repository and install the plugin from inside a Claude Code session with the /plugin marketplace add and /plugin install commands shown in the README, then run /conductor:conductor-setup once per project.

### How do I install Conductor in Antigravity?

The README's end-user path is a single command, agy plugins install https://github.com/gemini-cli-extensions/conductor. Contributors can instead clone the repository and symlink it into ~/.gemini/config/plugins/conductor for live edits.

### How do I install Conductor?

Installation depends on the host: the agy plugins install command for Antigravity, or the /plugin marketplace add and /plugin install pair for Claude Code. The README also describes workspace-level isolation by linking a clone into .agents/plugins/.

### How do I use Conductor on a project?

Run /conductor:conductor-setup once to generate the conductor/ context files, then /conductor:conductor-new-track for each feature or bug fix, which produces a spec and a plan for you to review before implementation.

## Sources

- [gemini-cli-extensions/conductor on GitHub](https://github.com/gemini-cli-extensions/conductor)
- [Issues](https://github.com/gemini-cli-extensions/conductor/issues)
- [License: Apache-2.0](https://github.com/gemini-cli-extensions/conductor/blob/main/LICENSE)
- [README](https://github.com/gemini-cli-extensions/conductor/blob/main/README.md)
- [Releases](https://github.com/gemini-cli-extensions/conductor/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/gemini-cli-extensions-conductor