How Two AI Agents Shipped 12 Pull Requests in One Day

Two AI agents and I merged 12 pull requests into a live system in 13 hours. The process, the lessons, and what Prov held between sessions.

  • AI agents
  • Multi-agent workflows
  • Agent handoffs

On November 16, two AI agents and I merged 12 pull requests into a live trading system between 9:26 AM and 10:23 PM. 136 files. 4,930 lines added. Every code change went to production the same day.

How does a day like that hold together? The system works fast. My job, as I've written before, is to "curate the narrative arc for the human consumer while building an underlying system that an agent can traverse." On this day the code came from Claude. Prov, a shared task board for AI agents and people, held the record: what each ticket needed, what shipped and what still needed proof. When a session ran out of memory that night, the work picked up from those tickets instead of starting over.

What did one day of work look like?

Twelve pull requests, in four stretches:

  • Morning: one bad source post stopped blocking every post behind it.
  • Midday: automatic profit protection on every open position, then two follow-ups so it reacts only to fresh, validated prices.
  • Afternoon: entries checked against cash read at each attempt, plus retries when account data lags for a few seconds.
  • Evening: a faster test suite, a rollback-safe pair of releases, an account allowlist and two fixes found in review.

Claude Fable 5.2 and Claude Opus 5.5 wrote and tested the code across several sessions. I approved each merge.

What I decided for myself was the service architecture and the bounded contexts of the app, using domain-driven design. The agents verified and helped improve that. It's the way Pivotal Labs, now VMware Tanzu Labs, taught it: event storming to find the domains, then draw the bounded contexts and services before anyone writes code.

What did the tickets hold that the session couldn't?

Context. In the evening, the session building the last changes hit its context limit and was summarized. The tickets still had the full brief: the problem, the fix and a "done when" line. Claude re-read them and kept going. That's what a task list between Claude Code sessions is for.

Later I asked, "ok what is 176 again? and 177?" Neither of us had it in our head. Claude pulled both tickets and answered from them. One was a trailing stop reading an unvalidated price. The other was five follow-ups from a code review. Within the hour, both were merged.

How do review findings ship without blocking a release?

They get their own ticket. The profit-protection work left one gap: the older trailing stops still read the raw price. The main fix was ready and safe to ship, so the gap went onto VTT-176 with one line saying what done means. An Opus review of the retry change produced five follow-ups, none affecting money safety. They became VTT-177. Both shipped by 10:23 PM.

What does done mean on a ticket?

On Prov, nobody marks a task Done without evidence, such as a PR link or a commit. VTT-176 closed with PR #367 and commit 3895b9c. You can review AI work before it's marked done.

Deployed isn't done either. The latency fix went live at 8:30 PM. Its ticket stays open until the first real alert on the next trading day shows the entry decision dropping from about 21 seconds to a few. A scheduled check writes that result onto the ticket.

What else made the day faster?

  • Speed up the tests first. The local suite took 35 to 40 minutes. One PR made it parallel, and it now runs in about 9. Five more merges landed after that. Go slow to go fast.
  • Ship the reader before the writer. One release taught the running system to read a new instruction format. The change that writes that format went out 21 minutes later. If the second one has to roll back, nothing breaks.
  • Prove the test catches the bug. Every new test ran against the old code first and failed there.
  • Look for the same bug everywhere. Unvalidated prices drove live decisions in three places that day. Fixing one would have left two.
  • Write flaky tests down. Three flaky tests went onto VTT-177 instead of getting waved through.

Who wrote what?

Every agent write is signed. Updates from this project show up as "vtt agent," separate from my own account, so I can tell which status notes are mine. When something goes wrong at 3 AM, I need to know whether I changed it or an agent did. A signed update answers that without me reading the diff.

Frequently asked questions

Can AI agents ship production code safely?

Yes, when a person approves each merge and the work starts from a clear ticket. On Prov, each ticket states the jobs-to-be-done outcome: the problem, the fix and a "done when" line. The ticket can't move to Done without evidence such as a PR link or commit, and access to the board never grants permission to merge, deploy or spend. That gives a person trust that the agent is doing the right work within the guardrails they set. On this project, Claude built and tested every change, and I approved every merge to production. Local tests ran before each one.

What happens when an AI agent's context runs out?

The session is summarized and continues. Anything the summary drops still lives on the task: the brief, the status note and the proof.

Does deployed mean done?

Not here. A change that needs live proof stays open until that proof is on the ticket. More on that in a definition of done for AI agents.

What would I do differently?

I'd have asked the agents to search for the pattern first and fix one place second. Unvalidated prices turned up in three places. VTT-176 only exists because we found the third place after shipping the first two.

Create your board, hand Claude or Codex its first ticket, and see where the work stands when you come back.