How one person merges 551 pull requests in a week
Last week I merged 551 pull requests. One every 18 minutes, day and night.
I didn’t write most of that code. Agents did.
I’m building them to do my job. It’s working.
This is how it runs, what it costs, and what’s left for me to do.
I check this panel when I wake up. It shows what needs me. The rest moved while I slept.
The factory’s panel, with example data. The red line on each bar is that account’s ceiling.
What I use
Most posts about agents don’t name anything. Here are the names.
Claude Code does most of the building. Codex, Cursor, Amp and Grok get work too. OpenRouter gives me every other model.
I pay for three Claude Max plans at $200 a month each and one Codex plan at $200. Cursor, SuperGrok and OpenRouter are extra. That’s $800 a month before the small ones. I will need more. The work is split across the plans.
The servers are rented from Hetzner, Contabo and DigitalOcean. The agents share one with 12 cores and 47 GB of memory.
Ubicloud runs my GitHub runners. Boat.dev gives me sandboxes and short-lived machines for tests and other heavy jobs.
I watch the agents in herdr, T3 Code and cmux, inside Ghostty. On my phone I use Termius.
When I edit by hand, I use Zed or Cursor, on a MacBook or a Linux desktop running Omarchy. Chrome and Zen for browsing.
GitHub holds the pull requests. Doppler holds the secrets. Coolify and Render run the apps. PlanetScale runs the databases.
Vimcal for the calendar. Superhuman for email. I still have a day job.
I have 309 skills saved. A skill is a page of instructions for one kind of job. Most are switched off. Each project loads only the ones it needs.
The ones I use most come from Pstack. architect makes the agent sketch a thing before building it. arena runs the same task several times and keeps the best parts of each try. interrogate gets several models to attack a change. reflect reads back over the work and fixes the instructions that caused a mistake.
All of this sits inside what I call the software factory. It has a board of tasks, a set of rules, and a button that says Stop everything.
It builds tools and platforms for Painter Marketing Pros, where I run technology. It also builds itself.
I’m the only person using it. One of the agents interviewed me for this post. 24 questions, multiple choice. I did as I was told.
How a task goes
- I write what I want, why, and how we’ll know it’s done.
- The agent asks me questions. It can’t plan until it has asked about the choices only I can make.
- One agent plans and builds, in its own copy of the code.
- A second agent reviews it. They go back and forth until the problems are fixed.
- The builder shows me it works.
- The change goes to staging, a private copy of the product. It reaches real users when I say so.
I’m at the start and at the end. The middle used to be my whole job.
Proof
An agent saying “done” means nothing. I ask for proof.
Proof is a screenshot or a recording of the thing being used. Or a test that failed before the fix and passes after it. Or a second agent, one that didn’t write the code, saying the work is good.
I read the reviewer’s report. I don’t read most of the code.
How hard I look depends on what the change touches. New wording or a moved button goes through on the reviewer’s word. Anything near money, logins or customer data gets two reviewers, a third check, and me.
It also depends on history. On a new project I check everything. After a clean run I check less. If one change has to be undone, I check everything again.
Three catches from this month.
An agent wrote a script to tighten who can read our stored files. The script changed the rules, then tested itself. Its practice run was clean. The reviewer rejected it twice. A broken test link would have counted as a pass. So would an empty folder. If the connection dropped right after the change, it would have crashed before telling me how to undo it. It would have reported success without checking anything. I would have believed it.
An automated check flagged a change with two words, “audit integrity”, and no detail. The reviewer was told to explain it or say it couldn’t. It found a saved change with no audit record, and an audit record for a change that had been undone. The problem was in every audited record in the system. It had been there before the new code.
An agent was asked to delete unused database columns in the same release that stopped using them. The lead agent checked the live version. It still read those columns. During the deploy, customer records would have stopped loading. It became two releases.
The agents are wrong too. The one that runs the others told me two things that weren’t true. Another agent read the data and said so.
The limit
One day I had several projects running at once. Agents were starting other agents. Nothing was counting.
By evening, 98% of that plan’s week was used.
Nothing broke. The work was good. I was just building a lot.
Code is cheap now. Usage is the limit.
About half of that usage was review. Every pull request had four reviewers and a fifth agent checking the four.
So I changed it. The best model builds. A cheaper model reviews. One reviewer per pull request. Before a big batch, the agent tells me the cost. There is a cap on how many run at once. Each plan has a limit. When it’s hit, the work waits.
The rules
Each rule exists because something went wrong.
The agent that built it can’t approve it.
Agents can look at the live product. They can’t change it unless I say yes, and my yes lasts one session.
A script blocks any merge that isn’t going to staging. I don’t trust instructions for this. I trust the script.
A test has to be able to fail. If it passes when the thing is broken, it’s useless.
If code can make the decision, code makes it. I ask an agent only when it needs judgment.
No agent does these four things alone. Change the live product. Approve its own work. Make a business decision. Spend money or send something to a customer.
The last rule is my favourite. “Done” is wrong if anything was skipped and not mentioned.
What’s left for me
Writing code was never the hard part. It was the slow part.
What’s left is deciding what to build, saying it clearly, and checking the result.
That’s management. I manage agents now.
If you run a company, write your rules down before you buy a tool. What an agent can never do. What counts as proof. Who says yes.
The tools will change in six months. The rules won’t.
My goal is to automate myself out of a job. Last week the agents merged 551 pull requests. I approved things and answered questions.
It’s going disturbingly well.