Dan Vega outlines Boris Cherny's five steps of AI adoption, emphasizing that progress requires specific guardrails rather than just more AI agents or complex prompts.
Many engineers experience 'social media-driven development,' feeling pressured by claims of tenfold productivity increases from AI, but Dan Vega reassures that individuals are on their own unique adoption path.
He references Boris Cherny, the creator of Claude Code, who has identified five distinct steps to AI adoption, providing a structured approach to understanding and navigating this journey.
In this phase, engineers manually transfer code from browser-based chat windows to their Integrated Development Environment (IDE), acting as the 'transport layer' for the AI's output.
Step 2 involves an engineer orchestrating five to ten AI agents concurrently, though the specific number is less important than the degree of autonomy involved.
This stage utilizes tools like work trees or Git checkout for context switching, allowing agents to perform tasks in isolation.
The system incorporates self-verification mechanisms, including automated tests, linting, and security scans, shifting the primary bottleneck from code writing to reviewing multiple output streams.
During this process, the AI cannot access the codebase, run tests, or verify its own work, leading to a laborious back-and-forth for tasks such as creating new API endpoints or service methods, where the developer acts as the sole 'transport layer' and arbiter of correctness.
This stage focuses on feature planning using agent modes and iterative execution, establishing an interactive loop between the developer and the agent.
Verification remains a crucial human responsibility, with the developer retaining manual review authority over the AI's output to ensure quality and correctness.
Claude Code is utilized to analyze the existing codebase and generate a comprehensive plan for this new feature, with the human developer serving as the manual reviewer in the loop, validating each step of the AI's proposed solution.
Scaling the use of AI agents from two to five or ten quickly creates a bottleneck, as the human developer remains the sole verification point for every AI output.
This manual review process, where the developer is the primary verification loop, limits the efficiency gains from AI, as there is only one human available to oversee all agent activities.
Trusting agents without careful human oversight at this stage poses a significant risk, potentially leading to the introduction of bugs into the codebase.
The issue stemmed from the AI's use of a SQL 'like' comparison instead of a more precise matching method, highlighting that AI-generated code, even when seemingly functional, requires rigorous smoke testing.
This incident underscores the insufficiency of relying solely on AI to write its own tests, as external human validation remains essential for uncovering subtle yet critical flaws.
This looks like it's working but we had to go through and kind of take a look at things... somehow this bookmark is coming up as well and that's because it includes Java in the tag JavaScript.
To enable more advanced parallel work, the verification loop must be moved from the developer's mind into the repository, serving as a critical guardrail.
This involves using Testcontainers to execute tests against a real PostgreSQL production database and explicitly addressing edge cases, such as ensuring tag searches match whole tags to prevent false positives.
The 'definition of done' for any change in `claude.md` is tied to successfully passing the `mvnw verify` command, with a firm refusal to weaken or disable tests for the sake of achieving a passing state.
A common misconception is that an AI agent writing its own tests constitutes a valid gate; however, true gates must be fundamentally independent of the change being judged.
This independence is achieved through contract tests against real infrastructure, such as HTTP and PostgreSQL, which prevent reliance on mocks and ensure genuine validation.
Furthermore, an independent reviewer agent should verify changes, and continuous integration/continuous delivery (CI/CD) pipelines serve as an unbypassable floor before any production deployment.
This stage incorporates auto-permissions, allowing agents to perform non-dangerous edits without needing manual approval for every single change, thereby shifting from human-eyeballed diffs to reliable, automated quality gates.
I used to run parallel agents all the time, but until I put gates in place, I was really at step one with a whole bunch of extra tabs open.
Sub-agents are deployed to manage parallel tasks and prevent interference within the work tree, ensuring that each change is handled distinctly.
A crucial 'definition of done' dictates that no branch merges occur without a successful automated code review pass, performed by a separate agent that did not author the original change.
Work integration is only permitted after the change has been successfully landed in the target branch, maintaining a high standard of code quality and integrity.
This file serves as a simple checklist: once a task is completed, it is checked off, preventing redundant work and providing a clear overview of remaining items.
We have a list of things that we want to accomplish and when you're done go ahead and check it off so we don't run it again.
As repositories become more intelligent through robust internal instructions and automated gates, the complexity of prompts significantly decreases.
System instructions embedded within the repository define the 'definition of done,' reducing reliance on manual prompt crafting for each task.
This shift directs focus towards defining clear specifications and quality gates rather than writing granular, step-by-step instructions for the AI.
Supervised autonomy, Step 3, is measured not by the number of agents but by whether tasks can progress without the developer's active presence.
This stage involves establishing loops, routines, and scheduled tasks that operate independently, allowing work to happen even when the human is not actively involved.
The transition to Step 3 signifies a shift from the developer initiating every task to enabling fully independent work cycles, effectively removing the human from the immediate workflow.
Utilizing Claude Code with 'auto mode,' the speaker demonstrated how an AI agent can process a sequential list of tasks by working through items in a `to-do.md` file and checking them off upon completion.
Throughout this autonomous loop, all pre-established safety gates and automated adversarial review processes remained active, ensuring continuous quality control.
This demonstration effectively illustrated how the human can be removed from the immediate workflow, enabling asynchronous task completion and showcasing true supervised autonomy.
True scale at Step 3 is defined by the developer's absence from the workflow, rather than simply increasing the number of AI agents running concurrently.
Although the demonstrated autonomous loop took 26 minutes to complete, the primary objective was successful outcome delivery, with speed considered a secondary optimization that could be achieved through parallel agents and work trees.
The developer's current position on this adoption journey dictates the next guardrail required, emphasizing that there is no 'right or wrong' step to be on, as progress is often constrained by available tools or existing knowledge.
Answers come from the transcript, with the exact spot cited.
Want the next article from Dan Vega?
When Dan Vega publishes, we'll write it up like the one you just read and email it to you.
No new videos from this channel in the last 7 days.
