Let's be honest. Using AI to code can feel a bit like working with a brilliant intern who has severe short-term memory loss.
You spend time carefully explaining the project, pasting in code snippets, and outlining the tech stack. The AI gets it! It produces some fantastic code. But then you start a new chat session, and poof... it's all gone. You’re back to square one, explaining everything all over again.
That "session-based" approach is the Achilles' heel of most AI coding tools today. The context is temporary, the process isn't repeatable, and what works for you might not work for your teammate.
Well, it looks like some folks at Google have been feeling that same frustration. They just dropped an open-source tool called Conductor, and I think it’s a genuinely different way of thinking about AI-driven development. It’s not just another chatbot that spits out code; it’s a system designed to give your AI a permanent memory, right inside your project.
Moving Past "Throwaway" AI Chats
So, what’s the big idea behind Conductor? It’s pretty simple, and that’s what I love about it.
Instead of relying on temporary chat prompts, Conductor creates a special conductor/ directory inside your code repository. This folder becomes the AI's brain. It’s filled with simple Markdown files that store all the critical project knowledge:
- What’s the product actually for?
- Who are the users?
- What’s our tech stack? (And what’s not allowed?)
- How do we write our tests?
- What are our coding style guides?
Because this "brain" lives in your repo and is version-controlled with Git, the context is persistent. It's shared. Every time you run a command, Gemini reads these files. This means the AI’s behavior is consistent and repeatable for everyone on the team, on any machine. No more "it worked for me!" mysteries.
A Smarter Workflow: Think First, Code Later
Conductor also enforces a little discipline, which, let's face it, we could all use sometimes. It doesn't just jump from your request to writing code. It follows a clear, three-step lifecycle:
- Context: It reads and understands the project rules from the
conductor/folder. - Spec and Plan: It helps you create a detailed specification and a step-by-step plan for the task.
- Implement: Only then does it start executing the plan and writing code.
This deliberate process is a huge shift. It forces both you and the AI to agree on what needs to be done and how it will be done before a single line of code is changed.
Getting It Set Up
Conductor is an extension for the Gemini CLI, so getting it installed is a one-liner in your terminal:
gemini extensions install https://github.com/gemini-cli-extensions/conductor --auto-update
Once that's done, you navigate to your project's directory and kick things off with a simple setup command:
/conductor:setup
This starts an interactive session where Conductor asks you a bunch of questions about your project—the product goals, your tech stack, your team's workflow, and so on. It’s like you’re briefing a new team member.
From your answers, it generates the conductor/ directory and populates it with files like product.md, tech-stack.md, and workflow.md. These files are just plain text. You can edit them, review them in pull requests, and update them as your project evolves. This is your project’s constitution, written down for all to see (including the AI).
"Tracks": Turning Tasks into Concrete Plans
Here’s where it gets really interesting. Conductor introduces a concept called "Tracks" to manage units of work, like a new feature or a bug fix.
You start a new task by creating a track:
/conductor:newTrack "Add dark mode toggle to settings page"
This command doesn't just start a chat. It creates a new folder for that specific track. Inside, you'll find two crucial files: spec.md and plan.md.
spec.md: This is where you (with the AI's help) flesh out the detailed requirements for the task. What are the acceptance criteria? Are there any edge cases to consider?plan.md: This is the AI's step-by-step execution plan. It breaks the work down into phases and individual tasks, like "1. Locate the settings component file. 2. Add a new state variable for the toggle. 3. Implement the UI switch..."
The key here is that the plan is explicit and version-controlled. You review and approve it before the AI starts meddling with your code.
Putting the AI to Work (Safely)
Once you’re happy with the plan, you hand over the reins:
/conductor:implement
The Conductor agent will now read plan.md and start working through the tasks one by one. But it’s not a black box. It’s designed with safety in mind.
It has built-in checkpoints, pausing at the end of major phases to ask for your approval before continuing. This prevents the AI from going off on a tangent and making huge, unreviewed changes. You’re always in the driver’s seat.
It also comes with a few handy commands to keep you in the loop:
/conductor:statusshows you exactly where the agent is in the plan./conductor:reviewhelps you validate the work against the project guidelines./conductor:revertlets you roll back the changes for a specific track, phase, or task. And let's be honest, we've all wished for a smarter undo button than justgit reset. This is it.
It Even Works on Your Messy, Old Projects
One of the best parts about this is that it’s not just for shiny new greenfield projects. Conductor is designed to work on existing "brownfield" codebases.
When you run /conductor:setup in a repo that’s been around for years, it becomes a fantastic exercise in knowledge extraction. It forces your team to finally write down all those unwritten rules and tribal knowledge that only the senior devs know.
Over time, that conductor/ directory becomes a living, breathing document of your system’s architecture and best practices. It’s an incredible onboarding tool for new engineers and ensures that any AI agent contributing to your project is playing by the same rules as the humans.
This is the kind of thoughtful tooling that moves us from just using AI as a clever autocomplete to integrating it as a genuine, disciplined member of the development team. It’s a step towards making AI-assisted coding less about chaotic magic and more about structured, reliable engineering. And I’m all for it.
