Series
Git Good
The dramatic, human, occasionally absurd story of how version control conquered the world.
Git is the most widely used software tool in the world that almost nobody understands. This series tells its story through the people, accidents, feuds and design decisions that shaped it. Not a tutorial: no terminal, no follow-along. Made for a walk or a drive.
Start here
Princeton's records office officially bans the suffix "final" from file names because it's cursed—and your computer's shame folder proves them right.
Season 1 · How Git Won
From filing cabinets to a two-week hack project that runs the world.
22 episodes · 7h 8m
Chronological: from the code librarians of the 1970s and the copy-paste era, through CVS, the Linux kernel crisis and the two weeks that produced Git, to GitHub and a seven and a half billion dollar acquisition.
In the 1980s, programmers filled folders with files named "project final version two John's edits"—until one wrong character in the wrong copy nearly crashed an airplane, sparking a two-decade hunt for a better way to track code.
Dick Grune's 1986 solution to tracking code changes across teams—a server in a closet—worked until the hard drive failed and three months of work from forty developers vanished with it.
In March 2005, Andrew Morton was processing hundreds of kernel patches daily by email—and the system was about to break.
On April 3, 2005, Linus Torvalds spent a Sunday building Git—and within two weeks, he'd created the version control system that would power modern software development.
Linus Torvalds named Git—the tool that runs modern software development—after a British insult, and documented the joke in the official README for all eternity.
When you clone a Git repository, you don't get a working copy—you get everything: every commit, every branch, every piece of history, making your machine a complete peer indistinguishable from the original.
Git's revolutionary branching made branches a forty-one-byte pointer instead of an expensive server operation, transforming how teams collaborate and igniting decades of debate about the best workflow.
Alice rewrites a billing function Tuesday; Bob refactors the same code Wednesday—now Git can't auto-merge and someone must untangle two developers' competing intentions.
Git developers have feuded for 15 years over whether history should show what actually happened or what you wish had happened—and it all comes down to one command: rebase.
In October 2007, two Ruby developers sketched GitHub on napkins at a San Francisco sports bar, unaware they were about to make Git accessible to millions and reshape how software gets built.
On June 4, 2018, Microsoft announced it would buy GitHub for $7.5 billion—the company that once called Linux a "cancer" now owned the platform where 28 million developers stored the world's open source code.
In 2014, a grid of colored squares on GitHub quietly became your professional resume, and nobody asked for permission.
Junio Hamano, Git's maintainer, runs one of the most disciplined workflows in open source—but almost nobody outside the kernel community knows about it, and the gap between what teams plan and what they actually do on Tuesday afternoons when the build breaks is where the real arguments start.
When you delete a branch with hundreds of lines of code, Git's reflog remembers every commit you made—even after they vanish from git log.
On May 30, 2011, Linus Torvalds released Linux 3.0 with no major changes—just a number bump that made headlines worldwide and exposed what version numbers really promise.
Somewhere in the last 7,000 commits, your production kernel broke—Git can find it in minutes using binary search instead of hours of manual testing.
On April 3, 2005, Linus Torvalds created Git—but within weeks, Matt Mackall built Mercurial in Python, and two other developers launched competing version control systems from the same crisis: here's why only one survived.
Microsoft's Windows repository is 300 gigabytes with 3.5 million files—git status takes minutes, cloning takes half a day, but engineers found ways to make it work.
On March 29, 2024, engineer Andres Freund noticed SSH logins were half a second slower than normal—and uncovered a deliberate backdoor hidden inside a compression library trusted by millions.
GitHub hosts 200 million pull requests and a billion issues—but what happens to all that context if Microsoft's servers go dark tomorrow?
Junio C Hamano has reviewed every patch going into Git for twenty years—since Linus Torvalds handed him the project in July 2005—yet almost nobody knows his name.
Linus Torvalds woke up angry on a Sunday morning in April 2005 and built Git in two weeks—the version control system that would become invisible infrastructure underneath nearly every piece of software on Earth.
Season 2 · The World Git Made
Git won. Now what?
22 episodes · 7h 46m
Present-tense. What Git's victory actually produced: the wall that keeps beginners out, the platforms that concentrated power, the trust model that can be exploited, the metrics that gamify contribution, the AI hollowing out authorship, and the money that doesn't reach the people holding it all together.
On average, developers encounter Git's "fatal" error messages 15 million times a day—cryptic red text that explains nothing, using vocabulary most people have never seen before.
A solo developer at midnight commits code with a message typed in two seconds—Git init, add, commit, push—five commands between them and losing everything they built.
Scott Chacon built GitHub to fix Git's interface—now he's raising $17 million to replace how developers think about code changes entirely.
Michael Fagan's 1976 IBM paper on code inspections created a formal process that shapes how software teams review code today—but most developers have never heard his name.
In 2008, Google released Android's 8.5 million lines of Subversion code to the public, sparking a migration that would define how teams manage code forever—all because of an invisible force called social gravity.
A junior developer force pushes to the wrong branch and loses two weeks of work—until she discovers the one Git command that saves every disaster.
When you push code, a hidden factory springs to life: servers clone your repo, run tests, scan for vulnerabilities, and decide your fate with a green check or red X—but few developers know what's actually happening behind that icon.
Google, Meta, and Microsoft all use monorepos—but the real battle isn't about Git, it's about whether your engineering teams can see each other's code.
In 2017, novelist Jessi Shakarian solved her two-ending problem using Git—a tool designed for Linux kernel developers—because branching matched how writers already think.
Halon Entertainment runs two version control systems—Git for engineers, Perforce for artists—because binary files like 3D models and textures expose Git's fundamental limits.
An AWS credential accidentally pushed to GitHub was exploited by bots within four minutes—part of a two-year campaign that turned exposed developer keys into a cryptocurrency mining operation across 474 cloud instances.
Git's "blame" command shows who wrote every line of code—but the name reveals how software culture turns debugging tools into witch hunts.
At the Linux Foundation, someone committed code as Linus Torvalds—and nobody noticed for two and a half years.
John Resig's 2014 rule to commit code every day before midnight inspired thousands of developers to chase the GitHub green square—but obsessing over a heat map designed as decoration has turned a productivity trick into a measure of worth that machines now exploit.
When GitHub added a Fork button in 2009, they designed it for collaboration—but five projects discovered it could become the ultimate weapon against corporate control.
When Microsoft bought GitHub in 2018, 13,000 projects fled to GitLab in one hour—revealing that 100 million developers' entire professional lives depend on a single corporation's platform.
On January 5th, 2022, thousands of software projects worldwide suddenly started printing "liberty liberty liberty" in an infinite loop—and the culprit was a burned-out maintainer who had decided to sabotage his own code.
In February 2026, a security researcher discovered 21 vulnerabilities in Huntarr, a self-hosted media tool with thousands of users—but the real scandal was hidden in the Git history: AI-generated commits with vague messages like "Update" masking a developer who claimed cybersecurity expertise while their code exposed API keys and passwords.
Veracode tested 100+ AI code generators in 2025 and found 45% failed security tests, yet 80% of developers believe AI code is as secure as their own—a canyon between confidence and reality.
In December 2021, the Log4j vulnerability threatened half the internet—and the developer who fixed it had exactly three GitHub Sponsors paying them anything at all.
On a Tuesday in early 2026, a developer's name appeared on a production commit that refactored authentication across fourteen files—except the developer didn't write it: an AI agent did, the AI reviewed it, and the pipeline deployed it, leaving only metadata to hint at what actually happened.
On April 7th, 2025, Git turned twenty years old with no cake, no livestream, and barely a mention—yet billions of commits flow through it daily, making it the invisible infrastructure that powers nearly every device on Earth.
Extras
A Swedish developer with 32 Git repos discovered 4 had zero backups and half contained uncommitted work—until an AI audit revealed how solo developers actually use version control.