- Published on
4,000 Pull Requests a Month: Are We Watching Software Engineering Change Forever?
NOTE
The 4,000 figure, in one paragraph. On Y Combinator's Lightcone episode of November 14, 2026, a host recalls Lauren Tan's earlier talk (more than 4 million views) in which she was opening about 2,000 pull requests a month, and asks if she is now over 4,000. Garry Tan calls the doubling wild. Later in the same episode, Roman Ugarte states it directly: on the Grokbot core team, Lauren is putting up 4,000 pull requests a month. The show treats that as her personal throughput. It is a spoken claim. The episode never says whether those pull requests were opened or merged, how large they were, or how many lines a person read.
Imagine a software engineer who spends much of the day in Slack, talking through a feature with a colleague, a product manager, and a bot that has a name.
The bot launches a Cursor cloud agent, runs the app on its own machine, and comes back with screenshots and videos. The thread runs to about 200 messages. Lauren Tan says that for that feature she never opened Cursor. She, her colleague Samantha, and a product manager shipped something they were happy with, faster than their longer process.
That scene is from the same Lightcone conversation, with Lauren Tan and Roman Ugarte, the core team that took Grokbot from first code to launch in seven weeks. The pull request count is the headline. The scene is the part that changes how the work is organized.
What the 4,000 number is, and what it leaves out
Treat the number as one engineer's monthly pull request volume, roughly twice a figure she had already talked about in public.
A host puts it to her at 22:35: the earlier presentation was about 2,000 plus pull requests a month, and now she is over 4,000. She does not walk through a spreadsheet. Roman comes back to it near the end, at 52:20, as a description of the Grokbot core team: Lauren is at 4,000 a month, and he expects more engineers to get there.
He also says what happens next, which is the clarification the headline needs. People show up to a product discussion and say they already have a pull request. The team declines some of them. A pile of weekend side projects would make an inconsistent product. The scarce work is agreeing on the roadmap, on what good looks like, and on what great looks like.
Lauren's own public description of pstack points the same direction. She writes that throughput without quality is not the goal, and that the pack is there to help agents write less code of higher quality. A high pull request count and a "write less" rule can sit together when the diffs are small and the checks are strict. They do not sit together if the count is the goal.
So 4,000 is evidence that execution got cheap for one engineer with a strong harness and a large token budget. She says she has the privilege of working at a lab that has given her unlimited tokens, and that she treats the job as exploring what engineering looks like six to twelve months out. It is a poor target for a team that has neither the harness nor the budget. Pull request count still says nothing, by itself, about whether a user needed the change.
The work has moved into the thread
Most teams still run a familiar sequence. Someone writes down a requirement. Engineers discuss an approach, write code, run tests, open a pull request, wait for review, and merge.
Assistants such as Cursor, Claude Code, and GitHub Copilot often sit inside that sequence. The engineer still drives each step. The model helps with the typing.
Lauren describes a different place to stand. Grokbot is her outer loop. The context she used to copy out of Slack and paste into an agent is already where the agent is. Her engineering bots live in Slack because that is where the conversation is. She still drops back into Cursor sometimes. For the feature on screen, she did not.
The bot in that thread is hers, and she calls it Potato. She gives it a link, asks what it would take to support something like the clip, and it spawns a Cursor cloud agent with its own machine. The agent runs the Grokbot app and returns video and screenshots into a public channel, so anyone who cares can join the thread while the feature is still being shaped. Feedback arrives while the loop is short, which is the point she emphasizes.
Garry Tan's 1 percent is a hunch
After watching that thread, Garry Tan calls the workflow a gold standard and guesses that maybe 5 to 10 percent of engineers in some circles, or 1 percent of engineers in the world, work this way. He says it should grow by a hundred times.
That is an informal estimate from the host, at 25:39. It is there to name a gap: the tools already support a multiplayer, agent-driven feature loop, and most engineers still use models as autocomplete or as a chatbot that emits a patch on request.
The engineer in Lauren's version designs, supervises, and improves the system that executes the task. She is still accountable for the result. She is no longer the person who types every step.
Quality lives in the repo, and in a skill pack she can carry
Lauren is clear that this did not appear overnight. Getting agents to a point where she trusts them took investment in skills, architecture, and constraints.
Her name for the portable part is pstack, short for potato stack. She describes it as her set of knives: an opinionated collection of skills, inspired by Garry Tan's Gstack, open sourced in the Cursor plugins repository. On the show she says the internal copy is installed in their repo, and that coworkers invoke it as Lauren mode. The cloud agents her bots spawn get the same skills. The public entry point is /poteto-mode, which routes a task through playbooks for investigation, bug fixes, performance, and verification.
Her rule for where quality should live is specific. If a constraint can be enforced by the type system, a lint rule, or CI, spending tokens to re-argue it in review is waste. She has pulled back from heavy adversarial review skills for that reason. A panel of models can flag issues, and it can also argue for an ideal design of a feature the team plans to delete in two months. Judgment about the product is still a human input. Mechanical rules belong in the codebase, which she calls a form of memory, because memory in the repo is cheaper than memory in the prompt.
The example she draws is from the Grokbot desktop app, which is Electron. Long tasks on the renderer thread make the UI janky, on the order of a frame at 60 fps. They stopped catching that in review. A dependency-graph check forbids the imports that would put heavy work on the renderer, and CI enforces it. She says the app has stayed consistently fast, which is unusual for a codebase that is largely written by agents, because the rule does not depend on someone remembering to look.
She has also reached a point where agents merge some of their own pull requests. The Slack feature was one she did not read line by line. She and the people in the thread looked at the artifacts. She still wants a human in the loop for critical infrastructure, databases, and deploys. Routine product work and maintenance are what she is willing to let the system carry.
The loop that makes the rest possible
Asked for the smallest useful loop, at 40:17, Lauren describes something plain.
Agents can already write code. Often a person is still the one who runs it, which means there is no loop, only a draft and a waiting human. The move is to teach the agent to run the code the way a user would: start the app, take a trace, look at the behaviour, find the break, change the code, and repeat until the behaviour matches the request.
She is careful about what that proves. A closed loop can make the change correct, in the sense that it does the thing you asked. It can still be slow or wasteful. Making "good" the default is the engineer's job: architecture, APIs, static analysis, skills, and the occasional review of the sensitive parts. The loop gets stricter as those are added.
Once that inner loop is reliable, an outer loop can hang off it. An alert fires, an agent reproduces the issue on a machine, uses the same skills, and opens a fix. She describes going one level further, with a project coordinator agent that manages sub-agents, so she is orchestrating the system that orchestrates the work.
Roman's version of trust is slower, and it is the right companion to that story. People still earn access in steps. A useful internal bot starts read-only. Their data bot answers "how many people does this affect?" from the warehouse and cannot take a further action. A procurement bot was a similar first step. Action, and then ownership of an outcome, come after the small version has been seen to behave.
The company around the engineering loop
Grokbot is built so an agent can sit in the tools a company already uses, with its own identity in Slack, its own tools, and a job someone can point at. Roman's hope is that bots join meetings and documents, because the goal is to operate the software a company has, which is a different job from rebuilding that software.
He also names the unsolved part. A bot in a Slack thread does not know who the domain expert is, or who is allowed to decide. It behaves like a new hire with no feel for the room. Permissions, trust, and decision rights are product problems, harness problems, and model problems. They are not solved because the agent can write a pull request.
The same pattern shows up outside engineering in the examples they give. A data bot absorbs the quick analysis questions that were eating a team's week. A customer success team points a shared bot at a firehose of requests, lets it finish the ones it can, and escalates the rest to a named owner. Lauren's 2027 hope goes further: a coworker with a phone number and a card, and an interface closer to intent than a chat box. That is a hope, stated as one. The present tense of the episode is narrower, and more useful: identity, a channel, a small permission, and a visible thread.
The constraint moves to judgment
For years, engineering productivity was discussed as speed of implementation: tickets closed, diffs landed, features delivered. When code generation is cheap, that speed stops being the constraint.
Roman's framing is execution abundance. The questions that remain are whether the problem is the right one, whether the outcome is specified tightly enough for an agent to run at it, whether the architecture lets an agent work without breaking the system, and whether automated checks can tell correctness from a plausible diff. Someone still has to decide that the result is what a user needed.
Architectural judgment, systems thinking, product sense, and technical leadership take more of the job. The engineer builds the environment in which a reliable change can be produced again, then decides which of the resulting pull requests belong in the product.
Lauren's answer to "where should an engineer spend time?" is the inverted pyramid she sketches on the show: most of the investment in the codebase and in static analysis, then rules and skills, then a thin layer of human review. Token spend follows the same shape. Ordinary work stays affordable because the expensive arguments have already been compiled into checks.
What to do with this on Monday
Copy the system at the size of your repo. Leave the monthly pull request target on the podcast.
Turn one repeated review comment into a check the agent cannot talk past. Pick the note you keep leaving: a forbidden import, a missing test around a money path, a query that must be scoped to the current user, a UI state that must have an empty and an error branch. Encode it as a lint rule, a type, a test, or a CI script. Lauren's version was the Electron renderer import ban, enforced by a dependency-graph check. Yours can be smaller. The test of the check is that a future agent fails it without you in the thread.
Make the agent run the product before you read the diff. The smallest loop on the show is write, run, use it like a user, name the failure, fix, repeat. If you are the only one who can see the screen, you are still the test harness. Give the agent a command that boots the app, a path through the flow, and a way to notice the wrong result. Screenshots and a failing test both count. A paragraph of "I think this works" does not.
Write down what you will refuse to merge, before you add another agent. Roman's team already has pull requests waiting at the door of product discussions, and they decline some. Do the same in advance. Keep a human on schema changes, auth, billing, migrations, and anything you cannot undo quickly. For everything else, the spec to hand an agent is the outcome, the constraint, and the check from step 1.
Count something other than pull requests. A useful week is a check that caught a real mistake, a feature a person exercised without you narrating it, and at least one change you closed because it did not fit the product. Four thousand is a story about one engineer's harness. It becomes a vanity metric the moment a team sets it as a goal.
The transition Lauren and Roman are describing is already visible in public: a named bot in the team channel, a skill pack in the repo, agents that merge the routine work, and humans spending the saved attention on what the product is for. The engineers who get value from that shift will be the ones who can build a system they are willing to trust, and who still know which pull request should never land.
Sources: the November 14, 2026 Lightcone episode with Lauren Tan and Roman Ugarte (pull request exchange at 22:35, the Slack feature at 23:18, Garry Tan's adoption guess at 25:39, guardrails and self-merge at 26:02, the self-check loop at 40:17, Roman on the bottleneck at 52:20), and Lauren Tan's pstack readme.