One engineer shipped 2,000 PRs a month to production. Verification is the key.

Lauren Tan, an engineer at SpaceXAI, has revealed her highly efficient agent workflow in a recent guide called pstack. Using this method, she has managed to ship an astonishing 2,000 pull requests (PRs) per month with a high degree of confidence. This is an incredible feat, with one engineer completing nearly 100 PRs daily. While such productivity is impressive, what truly stands out is not just the sheer volume of code generated, but the actual impact these changes have in production.

Central to Tan's workflow is the verification process, which she regards as the "critical infrastructure" that keeps her agent running smoothly. Verification involves an agent checking its own work and continuing until the task is completed. This skill is crucial because an agent lacking verification abilities would slow down the entire loop, waiting for human intervention to review every change manually.

To achieve this level of verification, Tan's workflow relies on a rich runtime capable of driving, inspecting, and providing structured answers for an agent. For individual applications, this runtime could be the application itself, started on demand. However, for systems composed of dozens or hundreds of services, such a runtime does not exist by default. Building a runtime that can support hundreds of parallel agents is a significant challenge.

Verification's importance is backed by strong mathematical reasoning. An agent that can verify its own output can continue working until the task is complete, while an agent incapable of providing a diff or waiting would become the bottleneck. Handing off every change for manual review would be impractical, as it would leave the reviewer with only a few minutes per PR during a full working month.

Therefore, a verification layer that operates independently of human involvement and in parallel with the agent's work becomes essential.

Tan's approach involves creating a command line interface (CLI) and a feature map for the application. This setup enables an agent to start the application, navigate it, inspect its state, and retrieve structured JSON results. Each agent receives its own complete copy of the application, allowing for end-to-end testing of any changes. She strongly advocates building custom debugging tools or even choosing a different technology stack to gain unfair advantages and extreme productivity in software development.

However, this approach hinges on the application being able to fit within a single process. While this works for simpler applications, it becomes challenging for complex, distributed systems involving multiple services, databases, and third-party APIs. In such cases, the verification process needs to account for the interactions between various components, making it significantly more complex.

For teams dealing with intricate distributed applications, the current runtime solutions fall short. Starting a full system from a CLI takes time, and the verification loop quickly becomes impractical when dealing with hundreds of agents working in parallel. Local runtimes with mocks may offer some benefits in terms of cost and parallel execution, but they lack fidelity, as they fail to capture real-time dependencies accurately.

This results in verification errors that only surface after the merge, rendering the verification process ineffective.

The key to a successful verification system lies in balancing the need for realism with the cost constraints. A full copy of the stack per change provides fidelity and isolation but becomes unsustainable as the number of services and concurrent changes increases. On the other hand, shared staging environments offer cost efficiency but sacrifice the necessary isolation required for accurate verification.

In conclusion, Tan's agent workflow and the emphasis on verification demonstrate the importance of building efficient, self-checking systems capable of delivering high-quality code at scale. While real-time verification can significantly boost productivity, it requires a robust runtime infrastructure that can support hundreds of parallel agents while maintaining fidelity and isolation.

Finding the right balance between cost, feasibility, and performance remains a challenging yet critical task for modern software development teams.