Imagine starting a new chat session with an AI coding assistant. You spend the first ten minutes pasting your file structure, explaining why you chose a specific library, and reminding the model that your authentication logic lives in a custom middleware. Halfway through the task, the AI hallucinates a function that does not exist or suggests a refactor that violates your core architecture. This cycle of repetitive prompting and corrective steering is the invisible tax developers pay for the stateless nature of current LLMs. The frustration stems from a fundamental gap: the AI knows the language, but it does not truly know your project.

The Architecture of Persistent Context

To bridge this gap, a new approach called Context-Driven Development (CDD) has emerged through a tool called Conductor. Released in preview on December 17, 2025, Conductor shifts the burden of memory from the ephemeral chat window to the project repository itself. Instead of relying on the AI to remember previous instructions, Conductor treats project context as a set of version-controlled markdown files. This shift has resonated deeply with the developer community, as evidenced by the tool's GitHub repository reaching 3,600 stars and 284 forks shortly after launch. By April 2026, the methodology was further validated through Google Codelab, which demonstrated how to use Conductor for greenfield projects.

The core of CDD is a three-layer architectural hierarchy: Context, Track, and Implementation. The Context layer defines the global constants of the project, such as the overall direction, the chosen tech stack, and specific coding styles. The Track layer breaks the project down into manageable units, such as a specific feature request or a bug fix, acting as a guardrail to prevent the AI from drifting into irrelevant areas of the codebase. Finally, the Implementation layer is where the actual code is written, strictly adhering to the definitions established in the previous two layers.

In a practical workflow, this manifests as a linear progression: Context Construction $\rightarrow$ Feature Specification (Spec) $ ightarrow$ Implementation Plan (Plan) $ ightarrow$ Code Execution. A developer first establishes the project context, then creates a `spec.md` file to define requirements and scope. From there, a `plan.md` file is generated, containing a detailed checklist of steps. The AI then executes the code by checking off these boxes one by one, creating a distinct Git commit for every completed task. This ensures that the AI never guesses the path forward; it simply follows a map that the developer has approved.

To implement this system, developers first set up the Gemini CLI environment by running the following command in their terminal:

npm install -g @google/gemini-cli

After configuring the Google API key or completing Vertex AI authentication, the project must be initialized as a Git repository to support the commit-based tracking system:

git init

Once the environment is ready, Conductor is installed globally:

npm install -g @google/conductor

From within a Gemini CLI session, the developer triggers the initialization process using `/conductor:setup`. Conductor then analyzes the existing codebase or conducts a user interview for new projects to automatically generate six core context artifacts, including `product.md` for project goals, `tech-stack.md` for allowed libraries and patterns, and `workflow.md`. These files are stored in a dedicated `conductor/` directory, ensuring that every team member and every AI session shares the exact same mental model of the project. The tool is designed to be efficient, respecting `.gitignore` and `.geminiignore` patterns to avoid wasting tokens on directories like `node_modules` or `__pycache__`.

From Stateless Guesswork to Managed Artifacts

Traditional AI coding is fundamentally stateless. Once a session ends or the context window overflows, the reasoning behind a specific architectural choice vanishes. A Google Cloud developer famously compared this behavior to a cowboy: the AI acts impulsively, making plausible-sounding guesses about the architecture that the developer must then painstakingly dismantle and correct. This creates a paradox where the tool meant to increase velocity actually introduces a new form of technical debt in the form of AI-generated hallucinations.

Conductor replaces this volatility with the concept of managed artifacts. By anchoring the project's identity in markdown files, the AI agent is forced to read the coding standards and product goals every time it is invoked. Because these files live in Git, the context evolves alongside the code. If a technical decision changes, the developer updates the `tech-stack.md` file, and the AI immediately adopts the new rule across all future tasks. This transforms the AI from an unpredictable collaborator into a deterministic executor.

This control is further tightened through a human-in-the-loop mechanism. Before any code is written via the `/conductor:implement` command, the developer must review and manually edit the `plan.md` file. If the AI's proposed path is too broad or logically flawed, the developer corrects the text of the plan. This prevents the costly mistake of discovering a directional error only after the AI has rewritten a dozen files. The process is governed by six primary commands: `setup`, `newTrack`, `implement`, `status`, `revert`, and `review`.

To start a new feature, the developer uses `/conductor:newTrack [feature_name]`, which generates `spec.md`, `plan.md`, and `status.md`. As the AI works through the implementation, it updates the status of tasks in the plan from `[ ]` (pending) to `[~]` (in progress) and finally to `[x]` (completed). This granular tracking allows developers to pinpoint exactly where a mistake occurred and roll back to a specific task-level commit without losing the entire session's progress.

This methodology culminates in the principle of Proof over Promise. In many AI workflows, the model claims a task is finished, and the developer trusts it until the code fails during runtime. Conductor flips this. Even if the AI claims a phase is complete, the workflow requires the developer to execute the code and manually verify the result before the AI is permitted to move to the next phase of the plan. The evidence of working code is the only currency that allows the project to advance.

When the `conductor/` directory is committed to the repository, the onboarding process for new human developers also changes. Instead of spending days reading outdated documentation or asking senior engineers about the project structure, a new hire can simply use the existing context artifacts to get the AI to explain the system to them. The tool does not just manage the AI; it documents the project in a way that is machine-readable and human-verifiable.

Ultimately, the productivity of AI-assisted engineering is not a function of the model's raw intelligence, but of the level of control the developer maintains over the process. By freezing context into physical files, Conductor ensures that the AI operates on evidence rather than intuition.