Dev.to AI 🤖 Ai 👁 0 📖 22 min read

No Pull Requests, 1,000+ Commits a Month, 99.95% Uptime

I deleted the manual pull request, and review now happens with the agent, not after it. The five repositories saw 1,188 commits last month, 1,003 of them mine, and our own services stayed up 99.95%. A note before you s

No Pull Requests, 1,000+ Commits a Month, 99.95% Uptime

I deleted the manual pull request, and review now happens with the agent, not after it. The five repositories saw 1,188 commits last month, 1,003 of them mine, and our own services stayed up 99.95%.

A note before you start: this is a long post because it describes a real change in how I work, not a campaign. The numbers come from our own repositories and monitoring, checked against the raw records, and the outside sources are linked at the end.

Last month there were 1,188 commits across our five repositories, and 1,003 of them are mine. September was 1,096. The first 13 days of November are already at 1,239.

Non-merge commits across our five platform repositories. November covers the first 13 days only. The count leaves out the Magento repositories and teammates' work in other repositories.

Before anyone gets excited: a commit is not a unit of output. Many are small, a fair share are docs and plans, and most carry my name. The rest come from four teammates, a few shared logins and one automation account. These numbers cover five platform repositories only. They leave out the Magento repositories, and any work teammates commit elsewhere, so they are a floor, not the full picture. I count them anyway, because the rate tells me something a feature count can't: how often an idea goes from my head to a working state, and how little stands in the way.

Here is what last month's commits actually are: 37% docs and plans, 20% fixes, 14% new features, 14% maintenance, and 15% fleet changes, rollouts and other. The plans and specs are not filler. They are where the PRDs and their loops live, which is exactly what makes the rest cheap to change.

October, grouped by commit prefix. Docs and plans are the largest group, and fixes outnumber new features.

I'm not the only one chasing this number. Lauren Tan, an engineer at SpaceXAI, talked about shipping thousands of pull requests a month in a livestream with Matt Pocock. The figure quoted around it is about 2,500 in a single month, and the write-up notes that the count includes plenty of maintenance work. Her method isn't typing faster. Agents prove their own work, verification agents run overnight, and she reads the results in the morning.

▶ Poteto on shipping thousands of PRs a month at SpaceX, livestream with Matt Pocock

Last month's commits were mostly made before I dropped the manual merge request, so November is the first month that counts without it. At the November pace the count would land in that range, but a pace isn't a month, and pull requests aren't commits. I'll claim it when a full month proves it. What I can say now is that the number isn't the interesting part. What had to change for it to be possible is.

It's 2026, and most of us still work with AI like it's 2017. One ticket, one branch, one developer, one reviewer, one merge, then the next ticket. The only difference is that the typing in the middle got faster. Everything around it stayed exactly where it was.

That's the part I think we have to let go of. Development velocity no longer depends on how fast a person types, or even how fast a person thinks. It depends on tokens, and on how fast the model behind them is. Every habit we built around human speed either keeps up with that, or it becomes the brake. This is my take, from how I build StoreFrame today. We're in a transition period, half of the industry still fixing legacy code while the other half ships with agents, and what works for me now might look silly tomorrow. Then I'll write another post. It's also the take of someone who came into this through design.

No manual merge request, because the review happens with the agent

Before AI, we engineered development so that nobody could make a mistake: a commit, a review, a merge, a pull request, each one another layer between a change and production. That made sense when a person wrote every line, slowly, and the layers caught the slips.

Today the layers are the slow part. An agent on a long task finishes the code, opens a pull request, and then stops and waits for a human. If that human is asleep, or in a meeting, or me away from my laptop, the work just sits there. I'm not going to wait in front of my laptop for a green button. So this month I removed the manual merge request. The review still happens, but it happens in the session, with the agent, before the work reaches main, and a fresh agent reads every plan cold against the facts collected first.

That isn't as radical as it sounds. Google's DORA research found no evidence that a more formal, external review process lowers the change failure rate, and recommends peer review during development, backed by automation, over approval boards. Google's own study of its internal code review, covering 9 million changes, describes it as lightweight and tool-based. The ceremony was never what made the code good.

Left to right, the old pipeline stops at the pull request and waits. The new one runs in parallel and ends with a human call.

Branches changed too. I use worktrees far more than branches: every task gets its own working copy, several run at once, and each one merges back to main when it has proof that it works, not when somebody found the time to look. The human call is still there. It moved from reading the diff to deciding whether this is the right thing to ship.

What I didn't change: small, minimal, solid, simple

Removing a gate doesn't lower the bar. It means the bar has to live in the code. The way I engineer is the same as before, only stricter: small changes, minimal surface, solid foundations, simple over clever, and a habit of being very critical of every line the agent writes, including the ones I never read. Small commits are part of that. A thousand changes that each do one thing are much easier to verify, and much cheaper to correct, than ten large ones.

Composable decisions, and a wheel that spins faster

Here is the part I'm most excited about, and it isn't a tool. I make each engineering decision composable. Instead of one big plan that is right or wrong as a whole, the PRD is split into small decisions that stand on their own: build one, test it, then keep it or throw it away without taking the rest down with it.

The PRD also carries its own iterative loop. It doesn't end at approved. It says: build the smallest piece, run it somewhere safe, read what happened, update the PRD, go again. On a composable structure that loop is fast, because changing one piece doesn't mean redoing the plan.

The inner loop spins many times a day on small, composable pieces. The release is only the last turn.

We all talk about the DevOps lifecycle: plan, code, build, test, release, deploy, operate, monitor, around and around. What I did was make the wheel spin faster before the main release. Many of my commits are those spins, small pieces going round the inner loop on a trial machine, again and again, long before anything reaches production. The release is the last turn of the wheel, not the first.

Here is what the spinning looks like. Over the last ten weeks the five repositories saw between 161 and 467 commits in every complete week, and the current week is already at 762.

Commits per week across the five repositories. The last bar is the current week, still in progress.

That is why speed doesn't have to cost stability. I'm not skipping the lifecycle. I'm running the early half of it over and over, where a mistake is cheap, so there is less left to go wrong at the expensive end. Pick your doors early.

Five consoles, one conversation

Composable work needs many hands at once, and that brings the next problem. On a normal day I run several sessions in parallel: one researching, one refactoring, one reviewing, one running a canary, one building a feature. That is a headache to manage and an even bigger one to think about, because every session is changing the same system while the others are still working in it.

An illustrative day: five sessions, each with one job, passing short messages instead of waiting for me to carry them.

The failure I fear most is the dead-loop spiral. One agent fixes something. Another agent, which doesn't know the fix was deliberate, sees it as a mistake and undoes it. The first agent notices the breakage and fixes it again. Neither is wrong from where it sits, and the two can keep doing this all night, burning tokens and getting nowhere.

Left: two agents, one change, no conversation. Right: the same two agents with one message in between.

What breaks the loop is communication. The sessions can see each other and send messages to each other. Before touching something another session might own, an agent asks. The owner answers with what it is doing and why, so a change gets explained instead of reverted. I'm no longer the router copying notes from window to window. I step in for the decisions that only a human should make.

A few house rules came out of the times it went wrong. Before a session uses a shared machine for a canary, it asks the session that is already using it. Nobody commits everything in a shared checkout; each session stages only its own files. Before pushing, a session checks what else is already waiting on the branch, because a push carries everyone else's unfinished work along with yours. None of it is clever. It's what a team does when it shares a kitchen, written down so the agents follow it too.

That's why I think cross-coordination is the most valuable part of working this way. Agents can work in parallel only because they can disagree in words instead of in diffs.

Bugs still happen, and downtime isn't zero

None of this eliminates bugs, and it doesn't eliminate downtime. It never did, with or without a pull request. The Google SRE book puts it plainly: 100% is probably never the right reliability target. What I can change is how much a mistake costs and how fast I find it, which is why so much of what follows is about proof, memory and keeping things easy to correct, and so little about trusting whoever wrote the code. For the record, our own public services were up 99.95% over the last 30 days according to our monitoring: about 20 failed one-minute checks per service out of more than 42,000, in a handful of short windows. Not zero, but not far off.

Part of the code is moving to Rust

Another change behind the number: parts of the code are moving to Rust, and getting simpler on the way, starting with the agent that runs on every customer VM. Rust is stricter than the languages I started with, and that strictness is what makes it scale and hold up: a whole class of memory and concurrency mistakes fails at compile time, before anything runs. When an agent writes the code, the compiler becomes a reviewer that never gets tired, never has a bad day and never accepts in 3 seconds.

Rust is also where I build the systems and control tools, and where I make verification deterministic by code. Instead of asking an AI what it did, a tool runs a procedural chain of steps, with tests along the way, and writes the trace itself. That log isn't something an AI produces while it runs. It comes from a logging mechanism that is built in and deterministic, and that is what makes cheating expensive. The proof-of-work section below shows how.

I'd rather not rest that on my own say-so. Google reported last November that Rust changes in Android had a rollback rate about four times lower than C++ and spent about 25% less time in code review, and that memory safety bugs fell below 20% of Android's vulnerabilities for the first time. That's Android, not StoreFrame, and I'm not claiming StoreFrame's numbers. It points the same way as my bet.

I started as a designer, and that's the point

I started my career as a designer, not a developer. Professionally, my job was designing systems and architecture, and that's still the lens I bring to software: how the parts fit together, where the boundaries are, and what happens when one of them fails. I think in structure first and in code second. (The longer version of that story is in What StoreFrame is to Me and It's Personal.)

With AI writing the code, that turns out to matter more than remembering syntax. What's scarce isn't knowing where the semicolon goes. It's design thinking: framing the problem, choosing the structure, and noticing what doesn't fit. A designer's habit of checking for antipatterns, and looking for the thing most people walked straight past, is exactly the habit good review needs. Most of this post comes from that. I don't build on any single answer being right, mine or the AI's, so I build a way of working that catches it when it isn't.

It's also the reason infrastructure suits me so well. Most of it is written declaratively instead of imperatively. You don't write every step, you describe the end state: this server has these packages, this config, these ports closed. Run it once or run it ten times, and it should land in the same place. That makes a mistake easy to spot, because it shows up as a difference between what you asked for and what's actually there. It also makes a wrong pick cheap: change the description, run it again. Imperative code asks you to get every step right, in the right order. Declarative code only asks you to describe the destination correctly. For anyone working at this speed, that's a much better deal.

The work went parallel. Most teams didn't.

And once a wrong pick is cheap, you can afford to make several at the same time. Doing one task at a time made sense when a human was doing the task. A human has one pair of hands and one head. An agent doesn't have that limit, so why do we still queue work for it like it does? Sequential development is simply not ideal anymore. Parallel is the way to go.

One of the most powerful things I use, every single day, is coordination between consoles. I run several Claude Code sessions at the same time, each with its own job. One digs through logs on a server, another writes the plan, a third is executing something that was already approved. Some run in parallel, some wait on each other, and none of them disrupt the others. When one needs something another already knows, they message each other instead of me copy-pasting between windows. (The tmux trick that makes that possible in a browser is in tmux is a Secret Wrapper Anthropic Don't Want You To Know.)

Working like this also means features and refactors run at the same time, and sometimes one depends on the other halfway through. Ten years ago we'd have called that chaos and scheduled a meeting about it. But the nature of development has always been constant change. The tools finally caught up with that fact, so I take it as part of the process instead of fighting it.

If you review every line, you're the sandbag

Run that many sessions at once and the uncomfortable question shows up quickly: who reviews all of it? AI writes code fast, and only AI can evaluate it just as fast. If a human still reads every line of every diff, the human becomes the sandbag the whole system is dragging behind it. Code review, the way we've known it, might simply not be as relevant anymore.

There's a second, quieter problem: every reviewer has a ceiling. You can only judge what your experience, your knowledge and your technical expertise reach. Once a change goes past that threshold, you're not reviewing anymore, you're nodding. And nodding at a diff is worse than not reviewing at all, because now it carries your approval. So in my workflow, every plan gets read cold by a fresh agent with no stake in it, checking it against the facts collected first. The human still makes the call that matters: is this the right thing, does it do what I meant, am I okay shipping it. That's what people are good at. Reading line 4,312 of a generated diff isn't.

And while we're being honest, let's admit what AI actually is. It's a better hacker than a developer. It writes sloppy code, tests fast, breaks things fast, and somehow still reaches the goal. That's just how it is. Which leads somewhere a lot of people don't want to go: if you believe human plus AI is how code gets written now, you also have to believe the real testing involves human plus AI too. Vibecoding needs vibehacking. The same speed that built the thing should be pointed at breaking it, before someone else does it for you. (I tried that against Claude itself in What Do I Think of Claude Fable 5 for Vibehacking. It didn't go the way I planned.)

Keep 20% of it unpredictable

If humans can't read it all, the obvious answer is to make AI predictable instead. Everyone wants AI to be deterministic. Same input, same output, every time. I think that's only 80% right, and the other 20% is where the value is.

My rule of thumb is 80% deterministic, 20% non-deterministic. The 80% is the rails: conventions, tests, the workflow, the checks that must pass. The 20% is room to think. Run the same task twice and the second run might find a better implementation, or catch a flaw in a plan the first run walked straight past. The same goes for review: two reviewers that think differently catch more than one reviewer run twice. Lock it down to total determinism and you sandbag your own velocity, because you've stopped the AI from thinking outside the box, which is exactly the thing you're paying it for.

So where does the reliability come from? Not from asking the AI to promise. From asking it for proof of work. Run it through a real system and show me the logs, not a summary saying it worked. That way, "it worked" is something I can read rather than something I'm told. Claude Code workflows push the same idea further: instead of hoping one long conversation stays on track, a workflow script fans the work out to several agents in fixed phases, and a separate agent has to verify each result before it counts. The orchestration is deterministic. The thinking inside each step is free to be clever. That's the 80/20 split, written as code.

Will AI ever be absolutely deterministic? I don't think so. But neither are we. Humans make mistakes too, every day, and we never demanded perfection from each other. We demanded that people check their work. Same deal.

There's a way to take that 20% much further: ask the AI for the same task twice, once from the positive end and once from the opposite end, and let the two sessions battle. I call it error engineering, and it gets its own post: Error Engineering: Let Two AIs Argue Over Your Code (coming soon).

Proof of work: how I verify, and why it's hard to fake

Everything above rests on one rule: an agent never gets to say that it worked. It has to show me. Done is a claim, a log line is evidence, and for anything that matters I only accept the raw output of a real run, never a summary of one.

Raw output alone still isn't enough, because one source can be wrong, stale or quietly wrong. What makes it hard to cheat, for an agent or for a tired human, is that the same event has to show up in systems that don't share an author. When I roll something out, a wrapper around the tooling writes its own procedural log. The machine that received the change writes its own container and web server logs, on its own clock. A separate monitoring server probes from the outside and keeps its own record. And git remembers who changed what, and when. The agent making the claim wrote none of the four, and none of them wrote each other. A story only holds if the timestamps, the outputs and the results line up across all of them.

The same event has to appear in four records written by four different systems before a claim is accepted.

Forging one of those is easy. Forging all four so that they agree to the minute is harder than doing the work, which is the point. It's hard to cheat, not impossible, and it's cheap to follow and expensive to fake.

It earns its keep because real failures are quiet. Three that this habit caught:

  • A green job that proved nothing. A job reported success while the machine it targeted had not changed. Only reading the machine's own state showed it.
  • A search that found nothing. A search for errors in a web server log came back empty and read as all clear, but the log was JSON, so the pattern could never match. A negative result means nothing until the search has proved it can find something.
  • A monitor that said 100%. While checking the numbers in this very post, the monitoring page showed 100% uptime for every service over 30 days. The raw check records underneath showed about 20 failed one-minute checks per service. The 99.95% in this post comes from the records, not from the badge.

The strongest version of this is a log the AI never gets to write. Take how I provision a machine: a wrapper runs Terraform and then Ansible, and the wrapper writes its own procedural log of every step, in order, with each result. Terraform's state is already hard to fake on its own, because a dry run has to reconcile what the code declares with what really exists. Ansible gives an idempotent end result but, by default, doesn't keep a record of what it ran. And I don't want Ansible's log anyway. I want the wrapper's, because it's written by code I control and test, not by an agent describing its own work.

The wrapper's log is written by code at every step, then compared with every earlier run.

Then comes the part that makes cheating expensive. Every run is compared with the runs before it: what ran now, what ran last time, what changed and what didn't. The results are queryable, so I can ask the same question of last Tuesday and of today. Faking that would mean inventing a whole consistent history, run after run, which is far more work than doing the job properly.

Two more habits. A subagent's summary is a claim, not proof, so only what the agent that says verified has run itself counts as first-hand. And tests that merely mirror the implementation prove nothing: the write-up of Lauren Tan's livestream warns about the same thing, agents that write tests agreeing with their own code. Proof has to come from outside the code being judged. Even a famous result deserves a run, as the next section shows.

Monty Hall, science, and remembering the goats

This is where an old game show puzzle helps. You probably know the Monty Hall problem. Three doors, one car, two goats. You pick door 1. The host, who knows where the car is, opens door 3 and shows you a goat. Should you switch to door 2? Yes. Your first pick only had a 1 in 3 chance. Switching wins 2 out of 3 times. Your first choice was probably wrong, and that's completely fine, because you win by using the new information and adapting.

The host knows where the car is, so opening a goat door moves the missing probability onto the other closed door.

A puzzle's word isn't proof either, so I ran it: 10,000 simulated games, once always staying with the first door and once always switching. Staying won 3,376 times, 33.8%. Switching won 6,624 times, 66.2%. The first pick really is wrong two times out of three, and that's fine, because the new information is what turns a bad first pick into a good second one.

A 10,000-game simulation of the Monty Hall problem. Switching wins about twice as often as staying.

That's how I look at mistakes with AI. Picking the wrong door first is okay, as long as you're still in the game. A wrong pick only really costs you when it's the last one, when the show is over and there's no switching left. Until then, the only real mistake is forgetting which doors had goats behind them. As long as we stay in the game, remember and adapt, we eventually land on the right one. Science works exactly the same way. A hypothesis doesn't become a fact because someone is confident. It becomes a fact through repeated experiments, many trials, and a journal of what happened each time. The research paper is just the journal, cleaned up.

For AI, that journal is memory, and it has become the most important thing I have. PRDs, memories, logs and commits are AI's best friends: more logs means more data, and more data means fewer repeated mistakes and less hallucination. My own memory for working with Claude Code is past 1,500 files now, next to more than 300 written plans, and it has one rule I never break: a mistake is never deleted. It gets distilled into a lesson, and the lesson stays. Without that, every new session starts from zero and confidently walks into the same goat. With it, the AI walks in already knowing where the goats are.

Memory also tells you when to tear something down. AI amplifies whatever already exists: good patterns get copied everywhere, and so do bad ones, just as fast and with nicer comments. You don't want to amplify mistakes. So refactor often, because refactoring is cheap now, really cheap. What's expensive is the pizza tower architecture, one topping stacked on another topping on another, every layer added because it was quicker than fixing the one below, until the whole thing leans and nobody dares touch the bottom slice. AI will happily build you a pizza tower. Don't let it.

Slow at the start, so you can be fast after

Memory only helps if you can tell a goat from a car when you see one, though. This might sound strange from someone who just told you to stop reading every diff, but to get good at vibecoding, my way, the fundamentals matter more than ever. You need to understand how the thing actually works. It's paramount to spend longer hours at the beginning of a new framework or a new language. Slow at the start, fast forever after. It's even better if you take some of the best open-source projects as a base, and learn their structure, their patterns, their conventions and their mistakes, then compare them to other projects that solve the same problem. That's how you learn to tell whether what the AI hands you is good, or whether it just sounds confident.

Because that's the real deal here. AI is here to write the code, and you are here to get better along with it. Every session should leave you knowing a bit more than before, not a bit more dependent. And the same goes for your team, there's no point being better alone. That's why our memory, plans and consoles are shared: anyone can pick up where someone else stopped, see what was tried, what failed, and carry it on.

There's more than one right door

And here's the part I find most beautiful about AI. Everyone writes their own skills, does it their own way, and still ends up with a working application. Some gravitate heavily towards the perfect setup, tuning every config and hook before a single feature exists. Some are all in on prompting. Some live in PRDs, some put everything into review, and some won't move without TDD.

There are multiple ways of getting it right, and each has its plus and its minus. The perfect setup can take longer to build than the app. A brilliant prompt is forgotten by the next session if nothing remembers it. A PRD can go stale the week after it's written. Review hits the ceiling I talked about earlier. TDD is only as good as the tests you thought of. None of them is wrong, and this post is just my way. That's the true nature of AI: it doesn't force one way of working on you. It meets you where you are.

From the perspective of an interaction designer, that's exactly what makes AI the perfect bridge between human and machine. For decades we had to learn to speak machine: commands, syntax, menus, the exact button in the exact place. Now, for the first time, the machine is learning to speak human. That's what made Apple a success in the first place: better interaction between people, through a machine that understands humans, not the other way around. Which makes it quite weird that Apple, of all companies, showed up late to the AI train and stumbled getting on. But you get my point.

Speed matters, both ways

Whichever way you pick, though, don't take forever picking it. Like it or not, speed matters today. You already know it from patching vulnerabilities: the window between a disclosure and the first exploit keeps shrinking, and the slow patch is the one that gets you hacked. The inverse is just as true for building great new things. Speed with no memory only makes the same mistake faster. Speed with memory is how you keep switching doors until you find the car.

CPM is my new meta: commits per month. Gamers measure how fast someone really plays in APM, actions per minute. For building with AI, the closest equivalent I know is how often an idea becomes a working change. Last month that was 1,188, and the point isn't the number. It's the wheel behind it: small pieces, spun fast, proven before they ship.

Further reading

📰 Read the original article on Dev.to AI

Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.