Google just released Gemini Conductor.

Conductor is a Gemini CLI extension

built around something Google calls

contextdriven development. It's designed

to reduce hallucinations and cut down

the painful back and forth with your LLM

that burns tokens. Gemini Conductor

works only inside the Gemini CLI. In

simple terms, it helps the model

actually understand your codebase

context before it starts generating

code. Now, why does this even matter?

Because most of us are not building tiny

demo apps. We're working on large,

messy, real world code bases. Google

calls these brownfield projects,

existing systems with history, tech

debt, and real users. And this is

exactly where most AI coding tools start

to break. But you're probably wondering,

don't AI coding agents already know how

to read the repo and understand it? And

yes, that's true. AI coding agents can

scan files, search symbols, and pull

context. But it's not perfect. As your

project grows, it becomes impossible for

any model to consistently load the right

information at the right time. And that

leads to two real problems. First, the

model often doesn't know which context

actually matters for a given prompt. And

second, even when you do create context

files, keeping them up to date as the

repo evolves is a constant losing

battle. This is where things start to

fall apart at scale. By the way, I

forgot to introduce myself. I help

developers turn AI into real workflows.

So, sub and like. It really helps me

provide more value for you. So, how does

Gemini conductor actually work? Once you

install Gemini CLI and add the conductor

extension, you can type /conductor and

you'll see five new commands. Let's

quickly walk through them. Status shows

the current state of the project based

on Gemini conductors context files.

Setup. This is the initial configuration

step where conductor learns how your

project is structured. Revert rolls

things back. Nothing fancy here, but

very useful when experimenting. New

track used when you start working on a

new feature. Implement. This is where

the actual coding happens. after you

already have a clear plan. Let's see it

in action. For this demo, I'll use

alldev neededs.com, a website that

provides free tools for developers.

Because we're working on an existing

project, we start with the setup

command. This is the step where Gemini

Conductor does a deep analysis of the

repository and builds the context it

will use for all future development.

Let's run it and see what happens. At

this point, Gemini starts scanning the

repo and then asks a series of

questions. These questions are

important. It's trying to understand how

you think about the project, the

architecture, the priorities, and what

actually matters. So during this phase,

take the time to answer everything

carefully. The better your answers here,

the better conductor will behave later.

Think of this as configuring your AI

teammate before you let it touch the

code. Once the setup is complete, you'll

notice a new folder in your repo called

conductor. What's inside it? But before

that, let me ask you something. Ever

been vibe coding? Everything feels great

until you hit a real bug and nothing the

AI suggests works. You're not alone.

That's why we opened our school

community to help you become a real

software developer in the AI era. You

get support from senior devs, weekly

Q&As, and tutorials that help you

understand what you're building. $1 a

month for the first 50. Lock it. Now,

let's get back to the video, and I'll

see you inside. The names pretty much

say it all. First, we have a file that

describes the project itself. This gives

Gemini a highlevel understanding of what

this system is and why it exists. Next,

there are product guidelines for future

development. For example, it documents

existing UI components. So, Gemini

checks what already exists before

creating new ones. Then we have the text

stack file. In the case of old needs,

this clearly states that we're using

TypeScript with React, Tailwind, and

Shed CN. We also get a workflow file.

This captures how the project is

actually built and maintained. For

example, requiring 80% test coverage

before changes are considered complete.

There's also a setup state file. This is

used internally by conductor to track

whether setup was completed

successfully. And finally, we have code

style guides. These define coding

conventions for each language in the

repository. So, generated code actually

matches your existing standards. And

that's it. At this point, the initial

setup is done and Gemini Conductor is

officially ready to work on the project.

Now, let's build a new feature. For

that, we'll use the new track command.

So, I run the new track command and

paste a short description of the feature

I want to build. In this case, I want to

add a new URL and HTML encoder/deoder.

Just like during setup, Gemini Conductor

starts asking clarifying questions. This

time, it's focused on the feature

itself, what it does, edge cases, and

how it should fit into the existing

product. Based on my answers, Conductor

creates a clear implementation plan.

Once that's done, you'll see a new

folder under tracks. This folder

contains the full plan for the feature

separate from the rest of the project

context. At this point, nothing is coded

yet. Only after I review and approve the

plan, I move to the next step and run

the implement command. And that's when

the actual code generation begins. After

a few iterations, our feature is

developed. Next, Gemini CLI asks what

you want to do with the current plan.

You can either archive it or delete it.

Archiving is usually the right choice,

especially if you want to keep a record

of how the feature was designed. Now,

let's quickly talk about pricing. Gemini

Conductor is a Gemini CLI extension, so

there's no separate cost for using it.

You only pay for the tokens you consume

while working with it. As for

installation, it's straightforward. Just

head to the official website. You can

install it using npm or homebrew. After

that, you'll need to run a single

command to enable Conductor. You'll find

that command in the official Gemini

Conductor repository. Gemini Conductor

is a great tool, but the real impact

comes from your workflows. In this

video, I'll show you how I debug with

AI. So, don't miss that. Until we meet

again, build workflows, not chaos.