Paul Everitt on the Shift to Agentic Engineering

The Core Thesis: From Vibe Coding to Agentic Engineering

Software engineering is currently experiencing a productivity paradox: while AI allows for a massive increase in code output, this has not yet translated into durable organizational value. The industry is currently in a phase of "vibe coding"—essentially hoping that AI-generated code works—which often leads to quality degradation and a focus on short-term profit margins through layoffs rather than long-term innovation.

To solve this, the industry must shift toward agentic engineering. This is the practice of building "the thing that builds the thing." Instead of using AI to replace the human coder, agentic engineering focuses on building the systems, scaffolding, and guardrails that augment humans and ensure AI agents operate within a rigorous engineering discipline.

The Productivity Paradox and Organizational Failure

Despite the availability of powerful AI tools (the "god box"), many organizations are failing to realize systemic value. Paul Everitt highlights several critical points of failure:

• The Coding Bottleneck Fallacy: Citing Nobel Prize winner Daron Acemoglu and Grady Booch, Everitt notes that coding itself was never the primary bottleneck in software engineering. Speeding up code generation only solves a small fraction of the engineering process.
• Quality and Trust Issues: There is a significant gap in trust, with only 3% of developers reporting high confidence in the accuracy of generated results. This creates a risk of "Challenger-style" disasters where agents push faulty code directly into production without human oversight.
• The "Token Maxing" Problem: Employees may game the system to increase token usage or output metrics, leading to a disconnect between management's perception of AI success and the actual experience of engineers.
• Misaligned Incentives: Many companies are using AI as a justification for "mega layoffs" to boost stock prices rather than using the technology to create products that were previously impossible to build.

Defining Agentic Engineering in Practice

Agentic engineering is not about the act of writing code, but about the design of the systems that manage AI agents. It moves the engineer's role from a manual builder to a systems architect. Key practical components include:

Evaluation and Testing

• Evals over "Clicky Buttons": Engineering requires objective measurement. Developers must implement rigorous evaluations to determine if an agent is generating high-quality code within a specific budget and number of turns.
• Red-Green Testing for Agents: By writing a broken test first, engineers can define exactly what "success" looks like. The agent then mimics the engineer's testing style and works toward a defined green state, reducing the time spent "wandering" through the codebase.

Tooling and Infrastructure

• Secure Sandboxing: Agents should not simply grep through a codebase; they should generate and run specific tool code in secure, low-latency sandboxes (e.g., using Rust-based subsets of Python like Monty) to solve problems.
• Harness Engineering: Everitt emphasizes that "if you don't own your harness, you don't own your memory." Owning the orchestration and execution environment is critical for maintaining control over the agent's behavior.

System Design and Modularity

• Agent-Centric Architecture: Large, legacy codebases may need to be reorganized. Modularity in an agentic world looks different, requiring structures that support parallel sub-agents and highly specialized context engineering.
• QA Agents: Instead of humans being the bottleneck for quality assurance, engineers should build QA agents that collect their own instrumentation via browser or dev tools protocols to prep work for human review.

The Call to Arms: Reclaiming the Engineering Discipline

Everitt argues that the software community must reclaim the definition of "engineering" as a rigorous science and practice. He challenges developers to move beyond the current hype cycle and establish agentic design patterns—a set of standardized, reusable architectural patterns for building AI-driven systems.

The goal is to shift the leadership narrative from "more code, fewer people" to "innovation through augmentation." By focusing on systems design and the discipline of engineering, developers can ensure that AI is used to build magnificent new solutions rather than simply squeezing profit margins.