We Ran Seven Coding Agents in Parallel. Then We Went Back to One.
Between October 26 and November 4 our main branch took 1,283 commits, and 129 of them were merges. Between November 5 and November 15 it took 269 commits. Zero merges. That second number is not a slump. It is the result of a decision I did not want to make, and that I now think was right. I build Since, which tracks the packages, AI models, APIs and runtimes your code depends on and opens the fix…
Between October 26 and November 4, the main branch experienced 1,283 commits, with 129 of those being merges. From November 5 to November 15, there were 269 commits, none of which were merges. This second number is not a slump, but rather the result of a decision that was initially resisted but ultimately deemed correct. Since is a tool that monitors packages, AI models, APIs, and runtimes your code depends on and opens the fix pull request when one of them changes.
The code is primarily written by coding agents, with the author taking on the roles of planning, reviewing, and arguing with them. At one point, multiple coding agents were running simultaneously. This setup involved splitting a significant portion of the product into streams, each with its own worktree, branch, test database, and shared specifications.
The plan aimed to scale by giving each stream its dedicated resources and a defined merge process. However, during the initial launch on October 26, an independent reviewer found three critical issues: functions residing in files assigned to other streams, agents attempting to edit the same code from different lanes, and overlapping schema blocks.
Recognizing the problem, a read-only critic was suggested to review the parallel plan before the streams commenced. Unfortunately, the team decided to create better plans and continue with parallel execution. This approach led to multiple QA rounds, each introducing new findings that required further investigation and bug fixing.
In one instance, six parallel fix lanes and an integration merge were completed within nine minutes, with all six merges occurring simultaneously. Despite the efficiency, the surrounding bug fixes were not properly coordinated, leading to inaccuracies in the final codebase. Eventually, the author realized that parallel building was not accurate enough, as it produced code that was locally correct but globally incorrect.
The process was accurate locally but failed to provide a comprehensive view of the entire codebase. The author then switched to a sequential approach, building one step at a time in order, committing the changes, and moving on to the next step. The first period, from October 26 to November 4, consisted of commit-intensive activities such as rebuilding the product, stream merges, integration fixes, and post-integration bug fixes.
The second period, from November 5 to November 15, focused on a single change, its tests, and the subsequent changes. The commits on the main branch during this period totaled 269, with no merges. The author emphasizes that the accuracy of the code is not affected by the number of commits but rather by the quality of the build process.
They highlight two instances where the parallel building process fell short: a commit with a failing test that bypassed the test runner's output and a pipe that incorrectly reported the exit status of the test command. To address this issue, the author recommends sending the runner's output to a file, reading the runner's own exit code, and committing only on a zero exit status.
Written by urgent.news from Dev.to's reporting — not their text. Machine-written — may contain errors; check the original before relying on it.