Agentic Engineering: Mental Models and Governance
Dave Kerr discusses the shift from code review to mental model synchronization in AI-assisted engineering. Key insights cover the 'build vs. buy' bias in LLMs, the critical role of Kubernetes for agent governance, and the necessity of evidence-based verification in agentic workflows.
The Shift from Code to Intent
The landscape of software engineering is undergoing a fundamental transformation as AI agents move from auxiliary tools to primary builders. Dave Kerr, creator of Hacker Laws, argues that the critical bottleneck in this new paradigm is no longer the model's capability to generate code, but the team's ability to maintain synchronized mental models of the system. As agents accelerate development, the traditional code review process is becoming less effective for quality control and more vital for cognitive alignment. Engineers must deliberately slow down to ensure that the collective understanding of the architecture matches the reality of the deployed system, preventing the accumulation of technical debt and confusion.
Governance and Infrastructure
A major strategic insight is the repurposing of Kubernetes as the primary substrate for managing AI agents. By treating agents as microservices, organizations can leverage existing infrastructure for resource management, observability, and governance. This approach is particularly valuable in regulated industries where audit trails, role-based access control, and strict permission boundaries are mandatory. The use of YAML-based definitions for agents allows for GitOps workflows, enabling version control and peer review of agent configurations, thereby integrating AI operations into established DevOps practices.
The Build vs. Buy Bias
Kerr highlights a significant behavioral bias in Large Language Models: a tendency to 'build' rather than 'buy.' LLMs often propose complex, custom solutions for problems that have well-established, hardened open-source or commercial solutions. This bias can lead to unnecessary complexity and security vulnerabilities. To mitigate this, engineering teams must enforce architectural constraints that prioritize the use of standard primitives and existing tools, ensuring that agents do not reinvent the wheel for solved problems.
Verification and Security
The verification of agentic work requires a shift from static analysis to evidence-based validation. Unit tests are no longer sufficient proof of correctness. Instead, teams should demand tangible evidence, such as terminal recordings, screenshots, or log files, that demonstrate the agent's actions produced the intended outcome. Furthermore, security remains a critical risk area; agents will implement naive security measures unless explicitly grounded in best practices. Developers must provide specific, rigorous constraints to ensure that generated code meets production security standards, particularly in areas like authentication and encryption.
Conclusion
The future of engineering lies in orchestrating intelligence rather than writing code. Success depends on building robust infrastructure for agent governance, countering model biases through architectural discipline, and establishing new verification protocols that prioritize evidence over assumption. By focusing on mental model synchronization and leveraging existing infrastructure, teams can harness the power of agentic AI while maintaining control, security, and clarity.
Key insights
-
The primary limitation in scaling AI-assisted engineering is the synchronization of team mental models with system reality, not code generation speed. Deliberate slowdowns through spec reviews are necessary to maintain this alignment.
Impact: Prevents architectural drift and ensures that debugging and future development are based on a shared, accurate understanding of the system.
-
LLMs exhibit a strong bias toward building custom solutions rather than using existing open-source or commercial primitives. This 'build' bias can lead to unnecessary complexity and security risks.
Impact: Understanding this bias allows teams to enforce 'buy' decisions, reducing technical debt and leveraging hardened, standard components.
-
Kubernetes is emerging as the ideal infrastructure for managing AI agents, providing necessary governance, observability, and resource management capabilities. Treating agents as microservices enables scalable and auditable deployments.
Impact: Enables regulated industries to adopt agentic AI by integrating it into existing DevOps and security frameworks.
-
Verification of agentic output requires tangible evidence, such as terminal recordings or logs, rather than just passing unit tests. This evidence-based approach provides confidence that the agent's actions match the intended outcome.
Impact: Improves the reliability of AI-generated code by providing a clear audit trail and reducing the need for manual code inspection.
-
AI agents will implement naive security solutions if not explicitly grounded in best practices. Developers must provide specific constraints, such as encryption standards, to ensure production-grade security.
Impact: Mitigates the risk of fundamental security flaws in AI-generated code by enforcing rigorous security standards during the prompt engineering phase.
Action items
-
Implement spec reviews as a deliberate slowdown mechanism to synchronize team mental models with the evolving system architecture. Focus on intent and design rather than line-by-line code inspection.
Impact: Enhances team alignment and reduces the risk of architectural inconsistencies caused by rapid AI-driven development.
-
Establish architectural guidelines that explicitly favor buying or using existing open-source solutions over building custom components. Provide agents with a list of approved primitives to counteract their 'build' bias.
Impact: Reduces technical debt and security vulnerabilities by leveraging hardened, standard tools and avoiding unnecessary reinvention.
-
Adopt Kubernetes as the deployment and governance platform for AI agents. Define agents using YAML configurations to enable GitOps workflows, version control, and audit trails.
Impact: Integrates AI agents into existing DevOps practices, improving observability, security, and scalability in production environments.
-
Require agents to provide tangible evidence of their work, such as terminal recordings, screenshots, or log captures, before considering a task complete. Use this evidence for verification instead of relying solely on unit tests.
Impact: Increases confidence in AI-generated output by providing a clear, visual audit trail of the agent's actions and results.
-
Explicitly ground agents in security best practices by providing specific constraints and examples in prompts. For example, mandate the use of asymmetric encryption for password handling rather than allowing naive symmetric implementations.
Impact: Prevents fundamental security flaws in AI-generated code by ensuring that agents adhere to production-grade security standards.
Quotes
“The limit to how fast you can build and scale is how well you keep your team's mental models in sync with reality”
“I need them to understand the system. That's why the review is there for me. That's why the Passover one person does spec, one person does implementation is there.”
“It's a bloodbath. People are stealing each other's stuff. People are taking great ideas and promoting them as their own.”