Matt Pocock interviews Poteto, creator of the pstack skill library and an engineer at Cursor (now SpaceX AI, previously Meta's React team), about how he shipped ~2,500 PRs to production in a month. His argument: the agent isn't the bottleneck anymore — your environment and your ability to transfer intent are. The practical core is verification (giving agents hands and eyes so they can close their own loop), heavily constrained codebases where bad code is hard to write, and connecting an "outer loop" of external context (Slack, X, email, Linear) to an "inner loop" of coordinator agents that spawn sub-agents. He now lets agents merge their own PRs overnight and reviews by sampling commit history in the morning.
- Poteto rejects the term "software factory" in favor of a Michelin kitchen metaphor: you go from solo cook to chef who organizes the kitchen, prep, and tools, and stays responsible for the final dish even though you no longer cook it yourself.
- Verification is the single most important skill — without the agent being able to run, click through, and debug its own output, you remain the "meat proxy" between the agent and the result, and no real loop exists.
- He extracts the deterministic parts of skills into CLIs and scripts (wrapping Playwright and the Chrome DevTools protocol) so agents don't rebuild the same tooling from scratch each session, saving both context and time, and reserving the agent only for judgment work.
- Environment design beats prompt-stuffing: his team's internal Electron framework ("Dune") uses conventional feature directories and very restrictive lint rules so there's essentially one way to do something, making it hard to write bad code — a reaction to early Grokbot versions that were eight god files of 10,000+ lines.
- Scale comes from connecting the outer loop (Grokbot connectors subscribing to Slack, X, email, Linear for bug reports) to the inner loop (Cursor "projects" coordinator agents that delegate to sub-agents), so agents fetch their own context instead of waiting for him to relay it.
- Not all work should be executed immediately: one routine scans for React anti-patterns and appends them to a document rather than fixing them, so he can spot patterns across the buffer instead of solving bugs one at a time.
- Review happens by sampling after the merge — he scrutinizes the commit history in the morning and, when multiple agents repeat a mistake, fixes the environment (lint rules, constraints, skills) rather than correcting the individual agent.
- On one-way-door changes (data loss, regulated domains) he has no clean answer: it comes down to whether the domain is programmatically verifiable, and he points to agent-oriented languages like Bend that marry code with formal proofs as a possible future.
- Skills are just processes turned into markdown; he recommends mining your own past chat transcripts for the moments you had to intervene and compressing those into skills or lint rules (his pstack "recall" skill does exactly this).
It's the clearest statement of the whole method: trust in agents is downstream of whether they can observe and judge their own output without you in the middle.
Even if you don't use pstack or your skills, I think that the single most important skill that should be in your toolkit is verification... if the agent can't actually see the result of its work, there's no way it can actually iterate.
This is the concrete payoff of the whole setup — full autopilot with fuzzing verifier agents, plus the honest admission that flipping it on the first night was genuinely scary.
I have the equivalent of like more than 10 chiefs of staff, right, each working on a different area... I've gotten to a point where I review the pull request after it's landed.
As the models get really, really good, the bottleneck is no longer the agent — it becomes your ability to express your intent and your goals in a clear way that the agent can understand and actually carry out.
Every time you see a mistake, you step back and think: how do I turn this into a lint rule? How do I make it so that the codebase makes this impossible?
Every chef, when they go to a different restaurant, they bring their knives with them. The tools go with them.