Skip to content

Blog

I Built a Software Factory. My Peak Daily Commit Count Is 100×+ My Pre-AI Average.

My busiest 2026 day had hundreds of times my average daily Bitcore commit count in 2014. Here is what that comparison measures, how I organize agents into a software factory, and how to try one bounded workflow in your repository.

A narrow canal fans into five parallel boat-filled lock lanes before a shared release gate.A narrow canal fans into five parallel boat-filled lock lanes before a shared release gate.
Many agents move work through shared checks; a human controls release.

I used to spend most of my software development time writing the software. Now I spend much more of it deciding what should happen, giving the work a clear shape, and improving the system that checks the result.

I built a software factory: a team of agents that takes issues through implementation, independent review, revision and merge, with human decisions and a separate release process. I can run many of those loops at once. That has changed how much work I can iterate through in a day.

The commit history makes the change visible. On November 14, 2026, I recorded 921 commits excluding merges, including agent work made through my account. In 2014, a productive year when I was building Bitcore at BitPay, I made 494 commits excluding merges in that repository: 1.35 per calendar day across the whole year. My busiest recent day was about 680 times that daily average. That is the comparison behind 100×+ in this headline: a peak 2026 day against a full-year 2014 average, measured in commits.

The distinction matters. My best Bitcore day had 32 commits; peak against peak is about 29×. The 2014 baseline covers one important repository, where most of my work lived that year, rather than everything I did. The current count spans retained live histories and snapshots, including private repositories. I count identical commit hashes once across them. An agent workflow also produces smaller, more frequent checkpoints. These counts describe activity through my account; they do not measure hours saved, defects avoided or value delivered to a customer.

As a conservative check, collapsing every repeated author timestamp brings 921 down to 902, although commits made at the same time can be distinct work. That still leaves the peak hundreds of times the historical daily average.

Even with those limits, this is a very different way to build software. The useful question for a founder or CTO is how the work moves through the factory, and whether that process could help with a real task in your company.

The unit of work is an issue

I start with an outcome and a way to check it. “Improve the website” gives an agent too much room to guess. “Make this page show the correct cover in both themes, preserve the existing URL, and verify direct loads and client navigation” gives it work that can finish.

The issue carries the requirements and discussion. An issues role checks for overlapping work and routes it to the right kind of worker. A coding worker claims the issue under its own identity and works on its own branch. The claim prevents two workers from unknowingly owning the same task.

As the worker makes progress, it tests coherent changes, commits and pushes them. A pull request carries the proposed result. I can follow the path from the request to the changes, the checks, the review and the final revision. When something is wrong, there is a specific piece of work to inspect.

This is where a factory starts to become useful. I can have several issues in progress without personally carrying every implementation detail in my head. The record has to carry enough context for the next agent, or for me, to understand what happened.

Review is a separate job

The coding agent hands the result to a reviewer in a different session. That reviewer reads the issue and its discussion, inspects a named commit, and runs the relevant checks. A requested change goes back to the coding owner. After revising and pushing, the coder identifies the exact new head that is ready for another review.

There is a practical reason for that separation. In one Astrohacker change, 112 tests passed, but the reviewer still found a brittle test. It chose an unpublished edition from the changing post catalog and assumed a particular edition would be there. Publishing that edition or adding a new one could break the test even when the product behaved correctly.

The correction gave the test its own deterministic unpublished fixture. The reviewer caught an assumption that the green test run had preserved. I described the example in Can You Copy a Software Factory?. It is one concrete example of independent review doing useful work, rather than evidence that an agent reviewer will catch every defect.

A review passes a particular revision and target branch. A later push needs another review of the changed result. After a pass, the merge still has to succeed and the linked issue has to close. Then the worker retires its branch and worktree and releases the claim.

That whole loop is the work. Generating the patch is one stage inside it.

I keep the decisions that are mine

An agent can ask for missing information. It can also put an issue on a human hold when a decision belongs to me. A hold pauses work on the linked pull requests and remains in place until I clear it or close the issue. Unanswered discussion also stops a pass and merge until the coding owner responds with a revision or an explanation.

Those gates matter more as the agents get faster. A vague requirement can otherwise turn into several confident implementations of the wrong idea. I want the question brought back to me while it is still a question.

Release is another decision. In the workflow running this site, coding and review finish at merge and retirement. A separately authorized deploy role publishes the merged revision and verifies the release. Passing tests and merging a branch do not themselves authorize a production deployment.

For a company, these are concrete controls: who can decide, what evidence is required, where work pauses, and what authorizes release. They deserve the same attention as the model that writes the code.

How I got here

The change came in stages. Copilot and ChatGPT were already helping me make substantial gains in 2024. Claude Code changed my workflow again in 2025. In 2026, multi-agent harnesses made it practical to organize several workers and independent reviewers around a shared queue.

That is my experience of the progression. A commit history cannot isolate the effect of each tool from the projects I chose, how much I worked, or how I divided changes into commits. It does explain why comparing today only with an already AI-assisted 2024 baseline misses much of the change I lived through.

I have also written about the broader productivity evidence. That article used a different commit-counting method, repository scope and comparison window. Its numbers remain a separate measurement. GitHub’s contribution calendar is another measure again: it mixes kinds of activity and depends on attribution and repository visibility. I am using commits and naming the baseline here so the headline has a specific meaning.

My thesis is that 100× is the floor, not the ceiling for the potential of well-organized agent workflows. That is a belief about where this can go. Establishing a gain in your business requires measuring your outcomes, including the time spent reviewing, the rework and the defects that escape. My commit count cannot promise that result for you.

The factory I run and the product I am building

I am building Astrohacker Factory to make this way of working easier to operate. The repository workflow I have described is already how I organize work in my own projects. The standalone product is in early development and internal use.

It has its own implementation of worker registration, job ownership, GitHub synchronization, separate review work and human control actions. That does not make every rule in my repositories an available hosted feature. Adopting the workflow means deciding what fits your repository, your checks and your authority to merge and release.

For a CTO, I would start with the path a change must take to earn trust. Can someone trace it back to a clear request? Can its checks be repeated? Will another worker challenge the implementation? Does an unresolved human decision reliably stop the work? Can you explain exactly what was merged and what was released?

If those answers are clear, increasing the number of agents has somewhere useful to go.

Try one workflow

Pick one bounded task in a repository you control. Define the result, acceptance checks and limits before a worker starts. Give independent review its own job, decide who can merge, and keep a human decision on release. Then measure the full loop: elapsed time, review effort, revisions and what actually shipped.

That is a pilot we can discuss. If you want to try it in your company, contact me with the repository workflow you want to improve and one task you would use to test it. We can start with that concrete piece of work and see what the factory earns.