Software people have, over twenty years, built a quietly radical way of working together. They call it version control. From the inside it looks mundane — commits, branches, pull requests, merges. From the outside it should look extraordinary, because no other discipline has solved the problems it solves.
Multiple people changing the same artifact at the same time, without overwriting each other. Every change attributed, dated, and reversible. Disagreements resolved in writing, in public, with the proposed change visible alongside the critique. A history you can walk backwards through to ask when did this decision get made, and why.
Most organizations operate without any of this. Strategy lives in a deck someone updated last Tuesday. Process lives in a Confluence page nobody has read since onboarding. The “current version” of the operating plan is whatever the most senior person said in the most recent meeting. There is no diff. There is no history. There is no merge.
This isn’t a tooling problem. It’s a model problem.
The commit. A commit is a small, named, attributed change to a shared artifact. Most organizations have no equivalent. Decisions happen in conversation and dissolve into Slack. A week later nobody remembers whether it was decided, suggested, or merely floated. The commit makes the change exist as an object — something that can be pointed at, referenced, and revisited.
The branch. A branch is permission to try something without destabilizing the main thing. Organizations are usually terrible at this. Either the experiment contaminates the operation, or the operation suffocates the experiment. Branching is the explicit acknowledgment that this work is provisional, and here is where the line is drawn between provisional and committed.
The pull request. This is the underrated one. A pull request is a proposed change, made visible to everyone affected, open for critique, and merged only when reviewed. It separates having an idea from changing the system. Most organizations collapse those two — the loudest person in the room is functionally pushing to main. Pull requests slow the proposer down on purpose, and that slowness is the feature.
The merge. And then: integration. The change is absorbed into the trunk, the history records who did what and why, and the system moves on. The organization equivalent — the moment a decision becomes the new default — is almost always invisible. People later disagree about whether it ever happened.
The reason this matters now is that AI makes the absence of version control acute. When everyone on a team can generate strategy memos, market analyses, and process drafts at near-zero cost, the bottleneck shifts from production to integration. Which version is current? Who changed what? On what basis? Against what alternative?
Without a model for this, AI doesn’t accelerate the organization. It floods it.
The software industry didn’t get faster by working harder. It got faster by inventing the merge. Most organizations are still pre-merge — and most AI rollouts are landing in that pre-merge soil and then wondering why nothing grows.