What Is "Software Is Made Between Commits"?
A commit is the formal checkpoint in version controlβthe moment a developer saves their work to a shared repository with a message like "Fixed login bug" or "Added database migration." These commits form the visible record of software development. But "software is made between commits" refers to the observation that the actual creation, problem-solving, and innovation happens in the unmeasured space between these recorded moments. This includes several distinct types of work: experimentation with approaches that ultimately get discarded, pairing sessions where two developers discuss architecture before writing code, code reviews that completely reshape how a feature works before it's committed, whiteboard sessions that map out database schemas, debugging marathons that reveal fundamental design flaws, and the countless iterations of local development before anything is ready to share. None of this appears in commit logs. A developer might spend eight hours identifying that a performance bottleneck stems from N+1 database queries, spend another four hours testing solutions locally, then commit the final fix in a single line. The commit message says "Optimize query performance"βbut the actual software making happened in those twelve hours of investigation.Why Everyone Is Talking About It Right Now
The phrase gained significant traction starting in 2025-2026 as development teams confronted a fundamental measurement problem. Productivity metrics based solely on commit frequency, pull request volume, and deployment velocity were creating perverse incentives. Engineering managers could see that developers were shipping code faster, but quality metricsβbug reports, regression incidents, technical debt accumulationβwere climbing. The disconnect became impossible to ignore. Simultaneously, the rise of distributed development practices, asynchronous collaboration, and remote-first teams meant that the visible artifacts of work (commits, pull requests) represented an increasingly smaller fraction of actual development effort. A developer working across six time zones might spend weeks in Slack discussions, documentation reviews, and architectural refinements that precede any code being written. Traditional monitoring tools captured none of this. The trend accelerated as organizations began publishing postmortem analyses of failed projects and realized a common pattern: metrics suggested the work was proceeding smoothly, but the actual development process was fragmented and inefficient. This disconnect between what version control systems recorded and what actually happened in development fundamentally changed how teams think about measuring progress.How It Works
Understanding how software is made between commits requires examining a concrete example. Consider a team building a real-time notification system. The final commit might show a new microservice with 300 lines of code, along with supporting infrastructure configuration. But here's what happened between the previous commit and this one:- Three engineers spent two hours in a design review debating whether to use message queues or WebSockets, examining trade-offs around latency, scalability, and operational complexity
- One engineer spent an afternoon prototyping both approaches locally, discovering that WebSocket connections would require architectural changes to their existing load balancer
- The team revisited the design decision with this new constraint; a wiki was updated documenting the reasoning
- A junior engineer drafted the feature while the lead engineer reviewed intermediate progress across four async code review sessions, each suggesting structural changes
- Performance testing revealed the initial implementation created memory leaks under sustained load; three days of debugging identified subtle event listener cleanup issues
- Documentation was written, then rewritten after QA pointed out missing edge cases
- A final optimization pass reduced latency by 40%
- Finally, the polished code was committed
Compared to What Came Before
Traditional software development measurement relied almost entirely on observable outputs: shipped features, closed tickets, merged pull requests. This made sense when development was primarily synchronousβa team in one office, working on one codebase, with clear handoffs between day shifts. Before the phrase "software is made between commits" became common, the industry had already noticed problems with pure productivity metrics, but lacked a unified framework for understanding why. Organizations tried solutions like individual contributor surveys, time-tracking software, and structured stand-ups, but these felt invasive and often inaccurate. The phrase crystallized something teams already sensed: the gap between what the metrics showed and what was actually happening.The best software is built in the spaces between formal recordsβin the conversations, experiments, and refinements that never make it into git logs.Previous thinking treated commits as the primary unit of work. Current understanding treats commits as merely the documentation of work that happened in collaboration, debate, iteration, and problem-solving.