AI Grew Up on Git
This is the overture to AI Grew Up on Git, a series on the Git infrastructure that raised AI and what AI is now doing to it.
A version control system is a machine for deciding who to trust. Git decided, from its first commit, to trust no one: not the network, not the disk, not the person on the other end of a patch. Every file gets hashed. The hash proves nothing about whether the code is good, only that it has not been touched since someone vouched for it. That single paranoid habit is why an operating system kernel could be built by strangers who never met, why a research paper could ship as a repository instead of a method section, why a model with billions of parameters could move from one lab to another with a receipt attached.
Git raised AI. Not as a metaphor: the corpus that trained today’s models is largely code that Git made shareable, the open weights that move through the field travel by GitHub’s own playbook, the reproducibility a paper claims is usually a clone away. The industry runs on infrastructure built for one narrow problem: strangers, working on text, who do not trust each other yet.
Now the strangers writing the code are not strangers in the old sense. Some of them are not people. A pull request can arrive with no one to vouch for it, only a model that predicted the next token. A diff can be too large, too dense, or too fast for the review process it was built to serve. The commit still gets a hash. It is no longer obvious what the hash is proving.
This is the tool that raised an industry, told through the industry now rewriting the tool from the inside.
The Commit Log
Eight commits, in order. The full history lives at the repo.
Trust No One, Hash Everything: A license betrayal in 2005 taught a version control system never to believe the person on the other end.
GitHub Didn’t Invent the Pull Request. It Socialized It.: What GitHub actually invented was a reason for strangers to want to collaborate at all.
The GitHub of Weights: Hugging Face copied a stranger-trust playbook and aimed it at the one file Git was never built to hold.
The Paper You Could Run: Machine learning turned a paper you read into a repository you clone.
What $7.5 Billion Actually Bought: Microsoft’s 2018 purchase came with a line item nobody itemized until years later.
The File That Refuses to Diff: Git’s entire value rests on showing exactly what changed, and one kind of file quietly breaks that promise.
The Author Is Not a Person: A signature used to mean a person vouched for the change, and that assumption is the one now up for renewal.
What Version Control Controls: Twenty years of hashes and commits were never a verdict on whether the code was good.
Five Checkouts
If you have typed git commit more times than you can count and never once asked why the tool insists on a hash, a message, and a parent pointer instead of just saving the file, this series answers that question as it goes. By the end you will have handled init, diff, branch, merge, tag, and rebase for reasons you actually understand, not just muscle memory.
If you care less about Git itself than about what happens when gigabytes of model weights meet a tool built for text files, Parts 3, 4, and 6 follow that collision directly: how Hugging Face rebuilt GitHub’s playbook for the one artifact Git cannot hold, how a paper became something you clone instead of something you read, and why the diff, Git’s most basic promise, quietly stops working on a model checkpoint.
If you want to know what the money bought, Part 5 is the receipt: Microsoft paid seven and a half billion dollars for GitHub in 2018, and three years later the deal turned out to hold something nobody had priced into it at the time.
If you are less interested in the tooling than in the question of who answers for a change nobody signed, Parts 7 and 8 take that on directly: a commit still gets a hash, a pull request still gets a review, but the assumption underneath both, that a person is on the other end, is the one now being rebuilt in real time.
And if you have never really learned Git at all, every part still works as your entry point. The commands arrive only after the story has shown you why they exist, so by the time you type your first git init, you already know what problem it solves. Git’s job was never to record that the code was good. It was to prove nothing had been touched since someone said it was fine, and eight parts from now you will know exactly what that proof is worth now that the someone might not be a person at all.
The last entry in the log does not resolve the tension it names. A hash can still prove nothing was touched. It has never been able to prove who did the touching, or whether they needed to be trusted at all. Twenty years in, that gap finally has a name. It does not yet have an answer.
AI Grew Up on Git: the infrastructure that raised AI, and the cradle it is now taking apart.