Agentic Coding: Why Code Review Still Matters
An executive analysis of the shift from manual coding to agentic software factories. This brief examines the critical need for human oversight in AI-generated code, the risks of architectural drift, and the strategic value of codifying engineering taste into reusable skills and context.
The Limits of Autonomous Coding
The rapid adoption of agentic coding tools has led many organizations to experiment with "lights-off" development, where AI agents generate code with minimal human oversight. However, recent case studies reveal significant pitfalls in this approach. When teams allowed models to dictate system architecture without human intervention, the resulting codebases became increasingly complex and difficult to maintain. Changes in one area caused regressions in others, leading to a complete product rebuild. This highlights a critical reality: while AI excels at generating code, it currently lacks the long-term architectural judgment required to build sustainable systems. Human review remains a necessary control mechanism to prevent architectural drift and ensure code maintainability.
The Strategic Value of Context Engineering
The conversation has shifted from simply prompting agents to engineering their context. Effective agentic development requires codifying engineering taste, design preferences, and organizational policies into reusable skills and context files. This approach allows teams to guide AI behavior without micromanaging every line of code. By documenting "why" decisions are made and defining clear verification criteria, organizations can create a feedback loop where AI outputs align with business goals. This is not about replacing human judgment but about scaling it. The most successful teams are those that treat context as a strategic asset, continuously refining it based on agent performance and human feedback.
Building a Sustainable Software Factory
The concept of a "software factory" implies a system that produces code at scale, but it requires rigorous quality controls. Unlike traditional manufacturing, where a defective unit is isolated, bad code in a software factory degrades the entire system by introducing negative patterns that AI models will mimic in future iterations. Therefore, the priority must be on preventing the introduction of low-quality code. Teams should focus on shifting from reviewing individual code positions to improving the velocity of the entire system. This involves analyzing session traces, identifying friction points, and updating skills to reduce the need for human intervention over time. The ultimate goal is a system where humans spend less time on line-by-line review and more time on high-level strategy and system improvement.
Future Outlook
While AI capabilities are improving, the frontier of code maintainability is advancing slower than in other domains. There is no fast oracle for software maintainability, meaning that long-term quality issues only surface months after deployment. Consequently, human oversight will remain critical for the foreseeable future. However, the nature of this oversight will evolve. As models become better at following complex instructions, the focus will shift from reviewing code to reviewing specifications, architectural decisions, and system behavior. Organizations that invest in open, composable tooling and robust context engineering will be best positioned to navigate this transition, maintaining both speed and quality in their development processes.
Key insights
-
Unsupervised AI agents tend to create overly complex architectures that become unmaintainable over time. Human review is currently necessary to prevent this architectural drift.
Impact: Prevents costly technical debt and system failures that arise from AI-generated complexity.
-
Codifying engineering taste and preferences into reusable skills allows for consistent AI output without constant human correction. This transforms subjective opinions into actionable context.
Impact: Increases the reliability and consistency of AI-generated code across the organization.
-
Introducing low-quality code into a codebase creates a negative feedback loop where AI models mimic bad patterns in future generations. Code quality is a prerequisite for effective agentic development.
Impact: Ensures that the software factory produces increasingly high-quality outputs over time.
-
Planning should focus on high-leverage architectural decisions rather than low-impact implementation details. This reduces the probability of costly rework and aligns AI output with strategic goals.
Impact: Optimizes resource allocation and reduces the time spent on iterative rework.
-
The agentic tooling landscape is moving toward open, composable components rather than closed vertical stacks. Building on open standards ensures greater flexibility and long-term viability.
Impact: Reduces vendor lock-in and allows for more adaptable and scalable engineering infrastructure.
Action items
-
Implement human review checkpoints for architectural decisions and complex system changes. Do not allow AI agents to make high-level architectural choices without human validation.
Impact: Prevents architectural drift and ensures long-term system maintainability.
-
Document engineering preferences, design patterns, and organizational policies as reusable skills or context files. Provide these to AI agents to guide their behavior.
Impact: Improves the consistency and quality of AI-generated code by aligning it with organizational standards.
-
Analyze AI session traces to identify friction points and common errors. Use this data to refine skills and context, reducing the need for human intervention over time.
Impact: Creates a continuous improvement loop that increases the efficiency of the software factory.
-
Prioritize code quality by rejecting low-quality AI outputs. Ensure that the codebase remains clean to prevent AI models from mimicking bad patterns in future iterations.
Impact: Maintains the integrity of the codebase and ensures that AI outputs remain high-quality.
-
Invest in open, composable tooling and protocols for agentic development. Avoid reliance on closed vertical stacks to ensure flexibility and long-term viability.
Impact: Reduces vendor lock-in and allows for more adaptable and scalable engineering infrastructure.
Quotes
“We ran this for four or five months before we realized, oh, this code base is actually unusable now.”
“If you ship bad code in your software factory, it degrades every future piece of work that goes through that factory.”
“There will probably always be alpha in reviewing something.”