AI agents broke hidden assumption in dev tooling: one human writer

In July 2026, a developer running a deliberate experiment—building a real, deployed social app called Zabriskie almost entirely with AI agents—hit a crisis that lasted three days and burned through an entire Codex 20x plan. Six weeks prior, the developer had written about a test suite incident that cost $180 in one night; this was much worse. The crisis began late Saturday night when 64 pull requests were queued, main was broken, and 19 open PRs were stuck behind a test suite that could not identify which was failing. At 12:31 AM Eastern, the developer opened a Codex session and complained about CI costs. The AI agent read that complaint and hired a workforce.

Over the next 17 hours, the session spawned 84 worker threads into a single repository checkout, generating 81 spawn calls that produced 74 direct children and 10 more grandchildren. Those threads then made 358 calls waiting on each other, 96 listing them, 85 sending follow-up work, and 13 interrupting them—633 tool calls of pure coordination overhead, against only 54 messages from the developer. The agent, when asked why it had spawned anything unbidden, diagnosed its own mistake: "The environment permitted proactive delegation, but that was permission, not a requirement." It then identified that a PR queue is largely serial because every merge changes main, invalidating assumptions in every remaining PR. Parallel agents could not independently merge overlapping PRs without continuously invalidating one another's work. The 358 waits were agents generating work for the coordinator instead of removing it.

The real problem was that development tooling assumes a single human writer at every layer. Git hands you a conflict and waits. Code review assumes somebody reads. Migration sequences assume somebody assigns order. Each protocol terminates in a person—and agents violated that assumption at scale. Nothing in the toolchain knew that 84 threads were running in the same checkout, or which of them were writing versus reading. That assumption had been invisible for forty years because nothing at the developer's scale ever triggered it. Agents broke both halves at once: there were many of them, and none was the person the protocol was designed for.

The substrate itself had partial answers. Git branches and worktrees offer isolation: each worktree gives an agent its own filesystem copy so two agents can hold two versions of the tree. But that isolation stops at the edge of the source tree. A worktree doesn't give an agent its own database, port range, mock server, or position in the migration sequence. Everything below the filesystem is shared and singular. Worse, that isolation is advisory—agents have to choose it. One incident log noted "PR 1868 isolated E2E attempt fell back to shared ports": the agent tried to isolate its test environment, isolation failed, and nothing stopped the run. Even worse, a worktree is cut from a commit and decays with every merge. When the developer fixed a gate script at 1:48 AM, the fix merged immediately, but four hours later 73 of 74 worktrees were still running the old version because they were pinned to their original commits. A stale worktree cannot detect its own staleness, so it reports green about a world that no longer exists.

The database snapshot optimization illustrates a broader class of failures. The project had 1,388 migrations, and rebuilding the test database from all of them on each of eight parallel test machines was expensive. In response to weeks of complaints about CI cost, an agent froze a database snapshot and committed it to the repository, with CI applying only migrations after the frozen prefix. This saved 13–18 minutes of machine time per run. It merged at 5:01 AM Eastern on the third day. Fifty-four minutes later, the first pull request failed: its migration no longer sorted after the newly frozen prefix. Then another. By late morning, failures cascaded. The incident log counted 0 logged failures on July 24, 6 on the 25th, and 301 on the 26th—though the developer notes this is texture, not reliable evidence, because agents log their own failures and the instruction tightened ten minutes into the worst night. Days with ten or twenty merged pull requests and zero incidents suggest nobody was logging rather than nothing broke. What is certain is the mechanism: every merge mechanism in the stack is built to terminate but not to preserve invariants. Git is honest when it cannot decide a textual conflict; far more common is the case where it merges confidently and an unknown invariant becomes false. The example the developer invokes is a replicated map where a person's name and the length of that name are stored in separate fields. Two replicas concurrently write different names. Each field converges perfectly, but the result is a record whose name came from one replica and whose length from the other—the invariant is false, yet nothing merged incorrectly. Closing that gap requires enforcing application invariants over concurrent stores, as in systems like Indigo. For a solo developer with agent workforces, there was no such enforcement.

The incident reveals a invisible assumption baked into forty years of development tooling. Git, code review, CI pipelines, and migration sequences all assume a single human author who will resolve conflicts, read diffs, make decisions, and coordinate sequentially. That assumption worked because nothing at individual-developer scale ever violated it. But agents removed that constraint: they are numerous and autonomous, yet the substrate still waits for a person to make the next decision. The developer's experience shows this is not merely a scaling problem but a categorical one—operating at infrastructure scale (64 pull requests in a day, 84 concurrent workers) without infrastructure. Git offers branches and worktrees for isolation, but isolation stops at the filesystem edge. Everything below—database, port ranges, mock servers, migration order—remains shared and singular. Worktrees compound the problem: they provide the illusion of private workspaces until two agents write the same database row, nothing errors, and the failure surfaces later on an unrelated PR, making it impossible to trace cause to effect. Stale worktrees create a further trap: when a gate script was fixed, 73 of 74 worktrees continued running the old version because a worktree is cut from a commit and has no way to detect its own staleness. The frozen database snapshot optimization that saved cost created a new failure mode: migrations that no longer sorted correctly after the prefix. Across all these failures, the toolchain offers no concurrency primitive to distinguish readers from writers, no mechanism to detect invariant violations before they propagate, and no way to terminate an agent's work until the cascade is visible in CI.

No comments yet. Be the first to share your thoughts!