Cultivating Trust

Part of the Conquering Entropy series Date: 2026-09-06

When dealing with AI-generated code, the primary challenge isn't the syntax—it's trust. The core of the issue is a series of cascading uncertainties regarding the reliability of our pipeline.

The Trust Chain

The following diagram illustrates the dependencies of trust in a modern AI-augmented workflow:

To navigate this, we must ask ourselves:

• Did the developer actually grasp the ticket, or did they just prompt the agent?
• Will our tests catch a regression before it hits the user?
• Is the CI/CD process robust enough to deploy this safely?
• If the AI-generated logic fails in production, will our monitoring catch it?
• Can we rely on an AI SRE to diagnose and resolve the outage?
• Will the infrastructure (e.g., GitHub) remain online during a crisis?

Because of these variables, establishing a culture of trust within the engineering team is paramount.

---

Encouraging Accountability

I believe in a simple, transparent mandate:

"You are accountable for what you ship."

This means if a PR you authored causes a production outage, you are the one responsible for the fix. If we hold engineers accountable for the outcome, we must grant them the agency to use whatever tools they prefer to achieve that outcome—whether they are "AI-pilled" or traditionalists.

The Reality of Modern Coding

We must acknowledge that AI agents produce massive volumes of code at an unprecedented velocity. While this makes code "cheap" to generate, it increases the risk of codebase degradation.

The Goal: Reasonable Quality We should trust our peers to maintain a "reasonable" standard. We should strive for 100% perfect code $\rightarrow$ This is an impractical obsession. Even before AI, most codebases were a chaotic mess of bugs.

We often operate on a trade-off formula: $\text{Delivery Speed} \propto \frac{1}{\text{Code Quality}} + \text{Technical Debt}$

---

Strategies for the AI Era

To maintain accountability and fight "slop," I recommend the following practices:

1. Clear Coding Guidelines

Establish a firm technology strategy. While humans might skim the docs, AI agents will ingest them and follow them (mostly).

{
  "guideline": "Prefer composition over inheritance",
  "naming_convention": "camelCase",
  "test_requirement": "100% coverage on business logic"
}

2. Deterministic Tooling

Use rigid, automated tools to enforce quality.

3. Enforcing Small PRs

Empower your team to reject any PR that is too large to be effectively reviewed.

• Define clear test scenarios (Human-led).
• Implement the tests (AI-led).
• Keep the diff small and focused.

4. Product Taste & Vision

AI makes it dangerously easy to implement every random feature that comes to mind. Work closely with Product Management to ensure you are building value, not just volume.

• Experimentation: Use AI to rapidly prototype three radically different architectural approaches.
• Selection: Pick the one that best fits the existing system.
• Utility over Elegance: In prototyping, the code quality is secondary to whether the result is actually useful.

---

Context: The Entropy Problem

As part of the broader Conquering Entropy series, it's important to note the current trend. Since the rise of coding agents, our monorepo's line count has skyrocketed.

The current state of affairs:

• PR Volume: $\approx 2\times$ increase.
• Review Burden: Doubled for all engineers.
• The Misconception: Many believe the primary issue is "too much code to review," but the deeper issue is the erosion of trust.