Agents increase the number of pull requests, so software factories need brakes that raise quality before human review.
2
Automated review should run in its own context, apply repository-specific coding standards, and commit fixes instead of adding more comments for a human to process.
3
Human review should improve the system that produces code, with retrospectives turning repeated problems into checks, standards, and better agent guidance.
Summary
Matt Pocock argues that AI coding agents make it easy to create pull requests, while making it only slightly easier to create pull requests worth reviewing. More agent-driven work therefore needs brakes: deterministic checks, automated review, and human review. Tests, linting, type checking, and other checks are cheap, but they can lie through tautological tests, excessive mocking, or tests that inspect implementation details. Pocock recommends designing code around deep modules so agents test stable interfaces. He also separates implementation from review. One agent makes the code work, while a second reviewer applies coding standards from a dedicated file and commits fixes. Human-friendly pull requests should explain risk, reversibility, blast radius, and the change itself with diagrams or pseudocode. Finally, retrospectives should turn repeated review comments into automated checks, coding standards, navigation pointers, and better agent workflows.
Software factories need brakes as agents increase throughput
Pocock describes a software factory where agents initiate work, classifiers turn reports into fixes or reproductions, and deterministic systems trigger further tasks. This increases the amount of code moving through the system. Without controls, the result is a "slop cannon" of poor pull requests that nobody can review. He proposes three brakes: automated checks, automated review, and human review. The first two reduce the amount of work that reaches a person, so human review can become faster even while the organization processes more changes.
Automated checks are cheap, but green CI does not prove readiness
Linting, tests, type checking, and code-quality metrics run consistently and mainly cost CPU cycles, so Pocock says teams can add many of them. They still fail to capture every serious problem. A test can simply repeat the implementation, such as expecting a character-limit constant to equal 280. Another test inspected source order instead of rendering the UI. Mocking can also remove the error modes that matter in production. These checks may pass while testing structure or fake behavior rather than the actual contract.
Deep modules give agents better interfaces to test
Pocock recommends designing code around deep modules, an idea he attributes to John Ousterhout's A Philosophy of Software Design. A deep module hides substantial behavior behind a small interface. That gives tests a stable boundary and reduces their dependence on internal structure. Shallow modules expose many small operations, which encourages structure-sensitive tests. His code-base design skill identifies opportunities to reduce duplication and create deeper, more testable modules. He also uses terms such as locality, leverage, and seam to give teams a shared language for discussing design.
Implementation and code review should use separate agent contexts
The implementation agent already has to explore the repository, edit files, run checks, and debug failures. Adding every coding standard to that same context overloads it. Pocock instead uses a review skill that receives the diff and reads a repository file called coding standards.md. The reviewer explores enough surrounding code to understand the change, then checks it against those standards. Because it does not implement or debug the feature, its context has room for more standards. The implementer makes the code work; the reviewer makes it good.
Repository-specific automated review is better than generic review services
Pocock says generic review agents are difficult to make useful. A broad reviewer produces false positives, while a narrowly targeted one fails to fit other languages or repositories. He recommends building a team's own coding standards over time and using them in an internal reviewer. That reviewer should usually commit fixes rather than write a long list of suggestions. Comments can remain for questions, but the default output should be a cleaner artifact for the human reviewer. This avoids making the human read and triage another stream of verbose feedback.
A useful pull request makes risk and intent easy to judge
Pocock's PR skill is designed to focus human attention where it matters. A change can be a two-way door if it is easy to revert, or a one-way door if it can cause data loss, an expensive migration, or an irreversible side effect. The PR should also state its blast radius, since a small code change can still affect many users. For understanding intent, Pocock recommends pseudocode, Mermaid diagrams, UML, and simple visual summaries. These help a reviewer see what changed and why without reading every implementation detail first.
Retrospectives turn repeated review problems into better automation
Pocock says a reviewer should never have to write the same comment twice. His retro skill can inspect an agent session, a pull request and its session, or a week's worth of pull requests and reviews. It suggests new automated checks and updates to coding standards.md. It can also find missing navigation pointers in agents.md, inefficient tool use, and bloated steering files or skills. The aim is to make each human review improve the process that creates the next change, so recurring problems move out of manual review and into the development system.