Let the Agents Cook. Make Them Prove It.
I had to read that number twice: 2,500 pull requests merged in a single month. 🤯 When I came across Lauren Tan (poteto)‘s account of what she’d been building, and then watched her conversation with Matt Pocock about the setup behind it, I was amazed, since I’ve been increasingly fascinated by agentic workflows myself but had never seen anyone push the idea quite this far (and it made me wonder whether we’re getting a glimpse of what our job will look like in a few years).
PR counts have never told me much about quality on their own (more on that later), so what caught my attention was how deliberately she approached the problem of keeping quality up while increasing throughput, and if agents can help us ship more and make the software more reliable, I’m absolutely here for it.
what makes that much autonomy possible?
An agent can produce a plausible implementation remarkably quickly these days, but seeing something work in a chat window is quite different from knowing it’s safe to merge into a codebase other people depend on, since a change can pass its own tests and still break a neighboring feature or quietly make something harder to maintain.
Lauren combines Grok Bot, Cursor projects and cloud agents with pstack, a collection of engineering playbooks that spells out how agents should investigate, implement, test, review and ship changes. The part worth studying isn’t the exact toolchain but the separation of responsibilities. In the full-autopilot playbook, for instance, an agent owns an individual PR while separate verifiers check the committed revision against the actual behavior, and the merge needs a clean verdict on that exact patch (a material change invalidates the earlier verification, which I think is the key detail, because evidence about one version of the code tells you nothing about the next).
The pstack README also puts code quality ahead of sheer output, which is what makes the case for parallelism credible in the first place: you build a process that catches mistakes, learn which kinds of work it handles reliably, and only then let more agents run on their own.
learning to trust without becoming careless
The more autonomy I want to give an agent, the more I need to know the conditions under which I can actually trust its work. An LLM’s confidence is a fairly terrible substitute for a test result (and asking it to “be careful” isn’t a boundary), so I’d much prefer to give it an explicit definition of done, the right permissions for the task, a safe place to work and a way to roll back without dragging everything else down with it.
I learned this the hard way when my agent installed malware on my server 😅, and since then I care a lot more about the environment around an agent than about the agent itself. The pstack guide to unattended runs describes a sensible progression for this: figure out how a task should be verified while you’re still supervising it, make those checks repeatable, look at how the agent fails and only then extend its independence. There’s no magical moment when an agent becomes trustworthy forever, since trust is earned for a particular task under particular constraints and has to be reconsidered when either one changes.
🔒 Autonomy becomes much easier to grant when verification is part of the workflow itself, rather than something we hope to find time for after the agent finishes.
what happens to the engineer?
I lead a web engineering team and still build a lot myself, so on a typical day I’m already jumping between implementation details, architecture, prioritization and product decisions (sometimes within the same hour), and I can see that mix becoming normal even for engineers who don’t manage anyone. You start thinking like an orchestrator: which work can safely run in parallel, where dependencies make that a terrible idea, what evidence would convince you a change is correct, and when to stop working on a feature altogether.
There’s a product-management side to those questions, but I don’t think that makes engineers interchangeable with PMs, because defining meaningful constraints, spotting subtle failures and deciding how to split up a system all still need deep technical understanding. In Agentic Engineering Is Not a Vibe I wrote about moving from writing implementations to owning architecture and correctness, and Lauren’s workflow made me think about the step after that, when we start designing the processes that produce and verify whole sequences of changes (a skill I suspect we’ll all have to learn rather than assume we already have).
maybe good code needs a new definition
Lauren made another point in a recent post on X that stuck with me: we’ve spent a lot of time worrying about the imperfect code AI might introduce, but our codebases were hardly pristine before agents arrived. Quality has always been contextual (sometimes you accept a compromise because you need to learn from real users first, or because fixing an unlikely failure costs more than the failure would), and deciding where to spend the effort is part of the job.
She proposes a deliberately demanding ideal of code that is correct, bug-free and efficient to run, while admitting how expensive all of that has traditionally been. I wouldn’t read it as a universal checklist (correctness depends on a specification, and hardly any evolving app can honestly claim to be bug-free), but it leads to a question I really like: what if agents made reliability cheap enough that some of the compromises we used to accept no longer made sense? If implementing changes gets cheaper, we might finally have time for the awkward edge cases and the overcomplicated design we’d always meant to simplify, as long as we spend that capacity deliberately instead of filling it with more work just because we can.
Bend, and making some guarantees explicit
That’s why I’ve been so fascinated by Bend 2, a young programming language that aims for fast execution while also letting you state formal properties and check proofs about them. Natural language is convenient because I can describe an intention without spelling out every detail, but that same flexibility hides assumptions I didn’t know I was making, so Bend adds a LAWS.bend file for invariants and a PROOF.bend with proofs that the implementation respects them (its README has examples like preserving a balance invariant or preventing invalid game states).
Imagine asking an agent to improve a transaction system. “Make sure the transaction logic remains correct” is a perfectly understandable request between people who share context, but it gives an independent verifier almost nothing to work with, whereas a law saying the relevant balances must always sum to zero, plus a machine-checkable proof obligation, pins down one precise part of what correctness means.
The game demo is a lovely illustration of this. An agent is asked to add wraparound movement to a game whose law says the player must never be able to win, which is exactly the kind of innocent-looking feature that can open a path to the winning state, and with the invariant enforced the checker doesn’t have to take the agent’s word for it. Bend calls the idea AGENTS.md backed by proof, and I think it’s a really compelling direction.
what a proof can’t tell you
I don’t want my enthusiasm for formal methods to turn into a promise they can’t keep, though. A proof shows that a property follows from the specification and assumptions it was checked against, but it can’t tell you whether that property captures everything users expect, or whether you asked the right question in the first place. A requirement can be perfectly formalized and still be incomplete. Worse, if an agent is allowed to rewrite the rules whenever they become inconvenient, the entire exercise risks becoming rather elaborate theater.
Bend is also very open about being young, since its docs describe an optional --verdict path using a proven kernel while acknowledging that other compiler components and the translation into that kernel aren’t fully proved, and that the ecosystem still has big gaps. So it’s an intriguing architectural direction rather than something I’d recommend for production systems today. And even at its best, a proof won’t tell you that a user flow is intuitive or that the feature was worth building (which are exactly the parts of the job I hope we get more time for).
a codebase that remembers why
So much of what we know about a codebase lives in old PRs, conversations, half-maintained docs and whichever engineer still remembers why that awkward abstraction exists (I run into this constantly when helping people find their way around existing systems). An agent can’t infer that history from the current code alone, so if we want it to make more decisions on its own, the constraints and the reasoning behind them have to be easier to find.
I like how pstack approaches repeated corrections: instead of telling an agent over and over not to make the same mistake, you encode the lesson somewhere enforceable, like a type that makes an invalid state unrepresentable, a regression test that preserves something we learned painfully, or a formal invariant that protects an important property. None of that replaces judgment, but it makes judgment available to the next engineer or agent who touches the code (and to the humans maintaining it, which is a nice side effect).
activity isn’t progress
Which brings me back to those 2,500 PRs. I wouldn’t want any team to turn that number into a target, because PR counts have never told us much about quality or impact, and agents make it easier than ever to generate activity that looks great on a dashboard. What I’d actually want to know is whether useful changes reach users sooner, whether defects get rarer or easier to catch, and whether the code stays understandable as it evolves. The 2025 DORA research treats AI as an amplifier of the engineering environment around it, and a team with poor feedback loops doesn’t get good ones just by producing changes faster.
the kind of engineering I’d like to do more of
I find the prediction that developers will simply become PMs supervising a fleet of bots a bit too simplistic, partly because it ignores how much engineering goes into deciding whether work is correct and partly because it makes the future sound pretty boring. 😅 What I can imagine instead is a role where we still understand systems deeply but spend more of our attention on defining problems, choosing which guarantees matter and evaluating the outcomes.
The part I don’t have a neat answer for is education. Much of the judgment I rely on came from implementing things, debugging failures and watching reasonable-looking choices turn into problems a few months later, so how do newer engineers build that intuition if agents do more and more of the implementing? Supervising a process isn’t enough if you can’t recognize when it’s confidently producing the wrong thing, and I suspect working with agents responsibly will mean knowing when not to delegate, especially while you’re still learning how the underlying system works.
Anyhow, what stays with me from Lauren’s setup and from tools like Bend is the idea that engineering could become more ambitious and more disciplined at the same time. I’d love to spend less time on repetitive implementation and get better at saying what a system is supposed to do, what it must never do and why any of it matters to the people using it. ✨
things worth reading (and watching)
- Lauren Tan’s post about shipping 2,500 PRs, the original throughput milestone.
- Lauren on “Good Code”, human slop and the new craft of software engineering, her October 2026 reflections on quality, cost, iteration and what agents might change.
- Lauren Tan with Matt Pocock, a walkthrough of her agentic engineering workflow.
- Lauren on verification, her perspective on why verification precedes autonomy.
- Lauren on supervising agents, a deeper look at the changing engineering role.
- pstack on GitHub, especially the full-autopilot playbook and overnight guide.
- Bend 2 on GitHub, including the
LAWS.bendexample and its documented limitations. - DORA 2025 research, on AI as an amplifier of engineering systems.