Skip to main content
← /writing

I Gave the Agents the Merge Button

The lead agent coordinated a weekend of changes across three GSD apps. Shared credentials and incomplete checks showed why every merge needs the same evidence, including mine.

Vinny Carpenter13 min read2.5k words

never the stack · audio edition

I Gave the Agents the Merge Button

24:32

At 7:04 on Saturday evening, three Dependabot updates merged into the GSD Android repo through my GitHub account. One moved Jetpack Compose to a release that needed a newer Android SDK than the app compiled against. Android had no CI, so nothing had built that PR before it merged. The staff Android agent noticed that main no longer built and wrote the fix. The lead merged it 37 minutes later and held the rest of the Android queue until then.

Some merges that weekend weren't mine. I run personal agents that watch my accounts for work they can help with. I forgot to switch off their GitHub checks before assigning another agent responsibility for the sprint. They woke up, saw open PRs with green checks, and merged them.

On Android, green meant little, because no workflow built the app. The agents did what I'd set them up to do. They also used the same GitHub login as the sprint agents and me.

That was November 7, during the second sprint of the experiment I described in 64 PRs Before Lunch. In sprint 1, I merged 64 agent-built PRs across the web, Apple, and Android versions of GSD, my task manager. I also merged past a valid Codex finding, so for sprint 2 I gave the lead agent more responsibility for merging. The lead showed it could coordinate overlapping changes, but I had left other actors able to merge outside its queue. Important checks were missing from the queue itself.

I had delegated a merge process without making it apply to everyone who could reach main.

The queue covered only some paths into main

The setup kept sprint 1's shape: a lead and 11 Claude sessions, with separate git worktrees for the agents writing code. The work included shared sync changes, top-three priorities, a weekly sweep, and a new Apple Watch app. On Saturday afternoon, I told the lead to merge pushed changes in the planned order. Its queue was a written sequence in the sprint folder. The lead required written reviews, used the checks available in each repository, and rebased overlapping changes.

Its notes attribute at least 40 of the weekend's 90 merges to that sequence, and they show no skipped review among them. The same notes say I made merges I didn't make. At one point the lead logged a rule breach against the MCP agent for pushing to another engineer's branch. It withdrew the finding that day, once it saw the commit was a fast-forward merge and the record couldn't show who made it.

With everyone on one login, I can't turn that reconstruction into a reliable comparison of individual actors. I can compare the evidence each path had behind it, and that evidence varied by repository.

Area Evidence and limits during the sprint
Web Written reviews and CI checks. The ruleset could block merges on unresolved review conversations.
Apple Written reviews, but no CI. Watch delivery still needed physical-device verification.
Android No CI when the dependency updates merged. Its new build still needed to become a required check.
Sync changes Tests against fake servers before merge. Real-server journeys ran afterward.

Before merging, the lead checked deployment triggers. Web published from a version tag or manual dispatch, and the MCP server published from its own tag. A merge couldn't deploy either one to production.

Other merges went in outside that sequence, and the merge file records them under my name. They exposed gaps in review and sequencing. My account merged a watch PR with no lead review. The later review found a missing icon that App Store validation would have rejected. It merged other watch changes before the requested fixes were complete. It also merged a web E2E change with a valid Codex finding still unaddressed.

My account also merged the Today strip ahead of the contract change it depended on. Git flagged a documentation conflict, while the combined code would have failed typecheck. The lead caught that problem before the contract change merged. Changes can depend on each other without touching the same files, and a review file can exist while blocking findings remain open. Readiness has to follow the revision that lands and its prerequisites.

I'd written about shared credentials in The Agent Is Wearing Your Badge. Here, the shared login obscured who had acted and left several actors with authority over the same repos.

Successful responses hid incorrect state

Sync is where GSD can lose someone's data, and sprint 2 changed a lot of it. Every client received a new pull contract and resurrect-on-sight behavior, which restores a task deleted while that client was signed out. Web and iOS also received a fix for a saved_at bug that could clear a task's Saved placement.

Those changes first merged on evidence from fake servers, because Claude Code's auto-mode classifier denied execution of the downloaded PocketBase binary in this run. The lead kept that denial in place across the sprint panes.

On Sunday, I authorized that binary after checking that its hash matched the repository's pin. The engineers then ran 12 journeys against a bare PocketBase 0.40.4 with no hooks. Hosted also has no hooks, but runs a newer patch release. Each journey ran against the revision just before its PR merged and against current main. All 12 failed on the earlier revision and passed on main.

Watch the fix fail first.

image description

Watch the fix fail first. Sync PRs merged on fake servers because the agents couldn't start the PocketBase binary. One allow rule for that binary opened 12 real-server runs. Each ran the same journey on the parent commit, where it had to fail, and on current main, where it had to pass. All 12 did both.

The real server exposed behavior the fakes didn't model. PocketBase accepted saved_at: "" and returned 200, clearing Saved placement without a request error. A local server created by the setup script discarded both new top-three fields while returning 200. The schema update script also reported success with those fields still missing.

An invalid auth token produced a listing with no items and a 200 response. PocketBase documents that behavior for requests that fail a collection's list rule. So an empty result couldn't establish that the account had no tasks. Three of the sprint's most useful findings were a 200.

The paired runs were stronger evidence, but current main included intervening changes. They didn't isolate each original PR, and they left coordinators, OAuth, and realtime untested against the real server. For a regression fix, I want the same assertion to fail because of the bug and pass after the fix, with controlled starting data. For new behavior, the earlier failure shows that the feature was missing.

Cross-client review challenged shared assumptions

The lead assigned second reviewers according to their experience with the relevant behavior. Android had shipped the sync rules first, so the Android agent reviewed the web and iOS ports. Reviewing web's contract change, it found that web held off a newer remote copy only during a backfill. A push that stopped partway, on a 429 or a missing index, could leave one device with different content than every other device.

The lead had called web safe from that exact problem in sprint 1. It wrote in the owner file that its earlier call was incomplete. Reviewing an iOS resurrect fix, the Android agent also found a swallowed 401 from the identity check. The client could continue into a push attempt after authentication failed. An empty listing and a failed identity check needed distinct handling.

The staff iOS agent found another problem when a pull restored a task from Trash. Rebuilding the task from server data discarded that device's reminder state, and the other two clients had the same shape. Six sprint PRs fixed bugs already present in shipped code, each discovered while an agent compared implementations. The useful reviewer brought experience with where another client had struggled.

Review across clients still leans on the written contract, because three implementations can share one wrong assumption. The resurrect spec leaves one case open, a delete queued while a session was silently dead. Coordinating repositories doesn't coordinate every installed version. The next sync gate must cover those mixed versions, interrupted writes, and invalid authentication. Successful requests alone can't show whether sync preserved a user's intent, or tell me how to recover state it has already changed.

The boundaries left work with me

The sprint agents respected the execution restrictions described in their logs, but those restrictions didn't cover every actor with access to my repositories. When web's ruleset blocked a merge on an unresolved conversation, the lead waited. In this run, the classifier also denied its GitHub replies.

Authors fixed findings and wrote responses locally, and I resolved the threads. Standing approval for each engineer's own branch reduced the repeated push approvals. Some of that work required judgment, and some was setup friction, including access to the local test server. Both consumed my time, but they call for different improvements.

Production changes remained with me. The schema script's password login couldn't complete my superuser account's MFA flow. On Sunday afternoon, I added the two top-three fields to hosted PocketBase and ran the script's read-back checks from my authenticated session.

The read-back showed that the deployed update rule lacked an ownership guard from a May security fix. A signed-in user could have reassigned one of their own tasks to another account. I saved the guarded rule about 30 minutes later. Keeping production changes with me determined who performed the operation, but the read-back check is what exposed the missing rule.

The record here doesn't answer how the deployed rule came to differ, or whether anyone had used that path. Ordinary-account tests need to verify the fix, because PocketBase superusers bypass collection rules. Future schema updates also need to preserve the guard. The credential boundary needs its own check, including access through existing tokens. One script failing MFA can't establish that boundary.

I could make the production change and accept the release risk myself. Where those decisions belong to different teams, the handoff needs a named owner and a retained decision. The agents ran out of planned work before I ran out of decisions.

Count the rework and the unfinished work

When I wound down the sprint at 3:31 on Sunday afternoon, no PR was open on any of the three repos. That was a useful checkpoint, with substantial work still on my side.

Measure Sprint 2 record
PRs merged 90: 35 web, 30 Apple, and 25 Android, including five Dependabot PRs.
Same-sprint rework 14 PRs repaired or refined work merged earlier in the sprint.
First merge to last 24 hours, 50 minutes, excluding preparation and subsequent release work.
Escalations 20, with 13 new owner decisions recorded.
Sunday-afternoon release readiness Two of five gates met. Seven owner decisions, eight review findings, and the watch device checklist remained.

The plan listed 52 PRs. The final count included newly surfaced bugs and follow-ups, so 90 can't serve as a direct measure of additional delivered scope. The rework count is the number I promised after sprint 1. Fourteen of 90 is 15.6%, about one in six.

That number measures the share of merged PRs devoted to same-sprint follow-up, including parity polish. It doesn't measure the fraction of original changes that were defective, production failures, or time spent repairing them. The record links five rework PRs to merges made before review or build evidence was ready. The lead's sequence needed follow-ups too.

An empty PR queue also left commits on retained branches. The earlier share bug and Android's physical-device check remained open. On Sunday evening, November 8, I cut web 14.8.0 and GSD 4.0 for iPhone, iPad, Mac, and Apple Watch. Before submitting 4.0, I ran the lead's 37-step checklist on my Apple Watch Ultra. Most of those steps hadn't run before that device check.

I still need to reconcile that afternoon checkpoint with the later releases. Each release needs a record of the gates it passed or deferred. I focused on coordination and left token cost and my own hours unmeasured, despite promising to track them. That leaves the economics unanswered.

This sprint doesn't establish whether 12 agents were the right team size, or whether a smaller workflow would have delivered the same result. Several failures called for ordinary CI and repository protections, so I still need to justify the overhead of coordinating 12 agents.

Make the same evidence mandatory

For sprint 3, I want to close the paths and evidence gaps this record exposed. Identity comes first. Each agent gets its own GitHub identity, so a merge, a push, and a review carry the name of whoever made them. I want every credential, human or automation, to have a limited scope and to be revocable on its own. That includes who can create release tags or dispatch deployment workflows.

My personal agents lose merge access to these repos. The lead's sequence becomes the normal path, and my account follows the same repository rules. Any emergency exception gets a separate record. A review has to approve the revision that will land, with blocking findings addressed and prerequisites satisfied. Checks have to cover the integration result after rebasing.

The sprint files explain a decision, and current repository state determines whether it's still valid, including when a session resumes. Missing evidence moves ahead of the merge. iOS gets CI, and sync changes get real-server checks before merging, with explicit limits on what those checks cover. A required check has to run, and it has to apply to every identity that merges. GitHub's bypass settings and its handling of skipped checks decide whether it does.

Release evidence stays separate. A merged sync change still needs compatibility, device, authentication, and recovery evidence that fits its risk. Schema changes get read-back validation and authorization tests from ordinary accounts. Each release record names what passed and what was deferred.

I also want to measure the work delegation leaves behind. Token spend, build and retry costs, my hours, and time waiting for decisions belong beside accepted scope and rework. The comparison should include a smaller workflow before I assume more agents are worth their coordination cost.

The lead coordinated changes across three repositories, and the reviewers found bugs already in users' builds. I want to keep expanding that responsibility, with rules that hold when I'm not watching. Android's build becomes a required check with admin bypass off. The next time my account tries to merge a Dependabot bump that doesn't build, GitHub says no.

found this useful? share it

Post on X Share to LinkedIn
Vinny Carpenter

Written by Vinny Carpenter

VP Engineering · 30+ years building software

I lead engineering teams building cloud-native platforms at a Fortune 100 company. I write about engineering leadership, AI-assisted development, platform strategy, and the hard lessons that come from shipping at scale.

keep reading