In early 2005, the developers working on the Linux kernel found themselves in an awkward situation. Every day they wrote code that changed the world. Nobody knew who actually owned it.

The previous year had been a mess for their version control. They’d been using BitKeeper, a commercial distributed versioning system provided by Kernel.org — not because developers liked it particularly, but because Linus Torvalds had access to it through a deal with the company’s founder, Andy Tanenbaum (no relation to the operating-system researcher of the same name). The Linux kernel community was small enough that one person’s proprietary tool was better than having no tool at all.

Then in April 2005, Andrew Tridgell — a Perl developer who’d built Samba and the rsync file synchronization utility — started reverse-engineering BitKeeper’s protocol. The company noticed. They pulled Linus’s access. Everything stopped.

I was nineteen years old at the time, working on projects that used Subversion. I had no idea that in roughly one week of my life — a short, furious stretch between April and mid-May — the most important tool in software engineering would be written from scratch and released as free software. I read about it later and found the story absurdly compelling: the most reliable version control system ever built was created as an act of personal vengeance. This seems like an unlikely foundation for something we now call industrial infrastructure.

The Linux kernel development process is a good way to understand why BitKeeper’s absence was catastrophic at that exact moment. The kernel codebase had grown massive. Thousands of patches flowed through the repository each month. Patch queues had become unmanageable. Linus needed a system where developers could work locally, share patches with each other directly, and merge changes without going through a central server the way Subversion required. The problem wasn’t that BitKeeper was bad — it was that it belonged to a company, and companies can revoke access for reasons nobody in the kernel community understood.

Linus had made his feelings about the situation clear in the infamous email where he described BitKeeper’s removal using language that, by modern corporate standards, might get you fired. But writing those words in 2005 was considered acceptable communication within an engineering team. The point wasn’t that he was angry for its own sake — it was that the anger was productive. He wrote a letter to the Linux kernel mailing list explaining what would happen next:

“The whole thing took about a week, including the first public release (yes, I still had some work to do before I pushed it out). But it was a LOT of fun.”

A week. One week to build the tool that would become the standard for almost every software project on Earth. Let that sit with you for a moment. This is the origin story — not something written by a team of engineers in a boardroom, but by one person who was genuinely furious and happened to be one of the best systems thinkers alive.

What makes this story interesting isn’t just the speed of the accomplishment. It’s that Git survived this origin. A tool built in rage could have been rushed, poorly designed, untestable. Instead it was elegant — its data model based on a content-addressed storage system using SHA-1 hashes (the same underlying idea used by CRC databases and Merkle trees). The design decisions made during those seven furious days would influence how over a decade of software was built. Every repository that’s ever tracked changes in Git carries the DNA of someone’s good mood after he’d finally made his point.

The company eventually restored access to Linus, of course. BitKeeper became just another tool in an overpopulated market. But the anger had done something permanent that the apology never could — it created a system so fundamentally sound that every developer building software ever since has used it without thinking about why, and without recognizing whose frustration is embedded at the core of their daily tools.

There’s something quietly absurd about trusting your work to technology built out of resentment. The version control system that powers GitHub, GitLab, and the majority of projects you depend on was created by somebody having a really bad week. That’s not really different from how most useful things in technology get made, I suppose — but it’s remarkable how often we forget the emotions behind the tools we treat as objective infrastructure. The kernel developers who wrote millions of lines of code under Git didn’t know that Linus was furious when he built it. They probably don’t care. But if you notice, once you’ve noticed it, you never unnotice it.