Git, Branches, and the Things We Leave Behind
Linus Torvalds has never pretended the name meant much. He built Git in the spring of 2005, over a couple of intense weeks, after the proprietary tool the Linux kernel team had been relying on abruptly pulled its free access. Torvalds didn't negotiate. He wrote his own — fast, because he had a kernel to run — and then did the thing that turned out to matter most: he gave it away. No license fee, no owner, no gate. Anyone could take it, read it, change it, build on it. Two decades later it's the quiet machinery beneath most of the software written on Earth, and nobody in particular owns it.
He's joked since that "git" is British slang for an unpleasant person, and that he tends to name his projects after himself anyway. Make of that what you will. Not exactly a mission statement — which is, of course, the most developer thing imaginable. But the thing he built ended up saying something his naming never did.
Because software has a way of outgrowing the names we hang on it. Git keeps track of how a project changes: what was added, what was cut, who touched which line, and the moment the work split off in two directions at once.
Those splits are called branches.
A branch might carry a new feature, or an experiment nobody's sure about, or a fix that gets folded back into the main line a day later. Or it might just sit there, untouched, for years. Some branches never go anywhere at all.
And buried in that flat, unglamorous vocabulary is an idea more human than it has any right to be. So let me offer Git a second meaning, one Torvalds never intended.
Generations in Trees
Every piece of software starts somewhere small. One person writes the first line. Someone else improves it. A third finds the flaw the first two missed. A new team inherits it, an old assumption gets thrown out, a promising direction is quietly abandoned — and then, years later, someone stumbles across it again and realizes it was right all along.
The work grows in generations. Not in a straight line, but the way a tree does — slowly, ring by ring: some branches thicken and hold weight, some grow off at strange angles, some get pruned, and some simply stop.
But a dead branch still shaped the tree. It may have exposed a weakness, or taught the next person exactly what not to attempt, or held an idea that only made sense once the rest of the tree had grown up around it. A branch can matter enormously without ever knowing what it contributed.
People are like that too.
If a branch falls in a forest
There's the old thought experiment: if a tree falls in a forest and no one hears it, does it make a sound?
Software poses a quieter version. If a branch dies and nobody remembers why it existed, did it still matter?
Usually, yes — because the finished thing is only the visible part of its own history. Behind every shipped product sits a landfill of abandoned drafts, dead ends, uncredited contributors, uncomfortable lessons, and ideas that showed up a few years too early to be useful. That's not unique to code. It's true of music, painting, cooking, language, science, and just about every business that has ever congratulated itself on a clean origin story. What we celebrate almost never arrived from nowhere.
Nothing begins at the beginning
Rock didn't begin with a band. Jazz didn't begin with a single genius in a spotlight. No cuisine belongs to the first chef who got a television show. Every form we love grew out of influence, migration, imitation, outright theft, improvisation, half-remembered lessons, and the long habit of one person answering another.
Someone hears a rhythm and bends it. Someone learns a recipe and rebuilds it out of whatever the local market actually stocks. Someone stares at a painting and smuggles a fragment of it into a completely different style. Someone writes a working function on the back of an answer a stranger left on a forum in 2011 and then forgot about.
We like our histories with clear openings and nameable heroes. Reality is messier, and less fair. Plenty of the people who mattered were never recorded, never credited, never named — their ideas survived under someone else's byline. History tends to remember the branch that reached the sunlight, and to forget the ones it climbed over on the way up.
What makes software strange
A painting can influence another painting. A song can be covered, sampled, reinterpreted, or simply remembered. A recipe can be adapted at the stove. But software can do something none of those can: it can be handed off while it's still becoming.
You can open someone else's unfinished code, read the shape of their thinking, and then change it, repair it, extend it, or drag it somewhere they never imagined. Software can be inherited as unfinished thought — not just a result, but the reasoning caught mid-sentence.
That makes it more than a product. It's a kind of collective memory with a paper trail. A single program can carry decisions made by hundreds of people who never met, lean on tools built by thousands more, and quietly depend on mathematics worked out centuries before any of them were born. Software isn't really written by individuals. It's accumulated intelligence — a hive mind with a version history. And for the last few decades, more and more of it has been handed off on purpose, in the open, to anyone who cares to take it.
The commons
Most of what runs the modern world was given away by people who were never paid for it.
That's the plain, slightly astonishing fact underneath open-source software. The operating systems in the data centers, the protocols carrying this sentence to your screen, the unglamorous libraries buried three layers deep in nearly every app you touch, the version-control tool this whole essay is named after — an enormous share of it is commons. Written by strangers, often anonymous, frequently on nights and weekends, and released under licenses that don't merely permit the next person to inherit the work but in many cases require it to stay inheritable. The generosity isn't a mood. It's written into the rules.
The people who built open source drew a distinction that still does a lot of quiet work: free as in freedom, not free as in price. The point was never that the software costs nothing. The point was that you're free to open it, understand it, change it, and pass it on. Which means the inheritance here isn't a metaphor. It's the license.
This is the closest thing humans have built to a genuine hive mind with receipts. A dependency graph is a genealogy — every project quietly naming the ancestors it can't run without. Pull the thread on almost any piece of software and it unravels into decades of other people's unfinished work, still load-bearing, still uncredited, still holding the roof up. It sat there in the open the whole time, readable by anyone patient enough to read it.
Standing on shoulders
We like to say people accomplish great things by standing on the shoulders of giants. Fair enough. But the giants were standing on someone too.
Behind every famous founder or inventor or artist is a much larger and much less visible structure: teachers, unnamed workers, publicly funded research, failed experiments, communities, collaborators, rivals, and critics who forced the work to get better. Nobody starts at the root.
Apple didn't invent the computer, Google didn't invent the internet, Facebook didn't invent friendship, and PayPal certainly didn't invent money. Each of them walked into a tree that was already growing, found a branch that could go somewhere new, and built something powerful out of what they'd inherited. That's worth real credit. But inheritance comes with a bill attached. The point isn't only to stand on shoulders — it's to become a set of shoulders worth standing on.
When the rebel becomes the establishment
A striking number of the companies we now think of as giants began by picking a fight with a giant.
Apple set itself against the world of centralized corporate computing — the IBM era — and made a very personal promise: the computer belongs in your hands, not in a temperature-controlled room you're not allowed to enter.
Google set itself against the chaos of the early web, where finding anything useful was mostly luck, and promised access: the world's information, actually reachable.
Facebook set itself against the gatekeepers of traditional media and promised participation: anyone can connect, anyone can speak, anyone can share.
PayPal set itself against financial plumbing that had never adjusted to life online, and promised movement: money should travel as easily as a message.
All of that was real. These companies genuinely pushed doors open. And then they got very, very large — and large branches cast shade.
Apple put a powerful device in nearly everyone's pocket, then built a carefully sealed garden around it. Google made information easy to find, then became one of the main forces deciding what gets found in the first place. Facebook handed billions of people a voice, then constructed the machinery that ranks, measures, and sells those voices back to whoever's buying. The people who built PayPal scattered into finance, media, transport, defense, aerospace, and politics, until a single rebellious startup had become a network with real influence over which rebellions came next.
The outsiders became the institution. The challengers became the gate.
This isn't a morality tale
It's tempting to flatten all of that into something simple: good startup curdles into bad corporation. But that's too easy, and it's mostly wrong.
These companies built genuinely useful things. They solved real problems and handed people reach, convenience, and opportunities that hadn't existed the day before. The harder, more interesting truth is that a value can quietly change meaning as the power behind it grows.
"Move fast" is energizing when five people are hacking together a prototype in a rented room. It reads differently once the product steers the daily behavior of a couple billion people. "Protect the user" is sensible when you're designing something safe to hold; it gets slippery when protection becomes the excuse for taking control away from the user. "Organize the world's information" sounds perfectly neutral right up until one company becomes the doorway through which most of the world meets everything else.
The founding values weren't lies. They were just built for branches that hadn't yet become trunks.
The branch that thinks it's the tree
Success breeds a peculiar amnesia. A company keeps remembering itself as small long after it's become enormous. A founder keeps remembering the fight against the system long after becoming the system. A platform keeps telling the story of the doors it opened while carefully deciding who's now allowed through them.
That might be the most dangerous stage in the life of any institution: when it still sees itself as the underdog, but everyone else has to live under its rules. A branch can grow so heavy that people mistake it for the tree — and eventually it makes the same mistake about itself.
And the heaviest branches carry a fact they'd rather not dwell on: they're rooted in soil they didn't make. The giants run on the commons — the free, ownerless work of strangers they never paid and mostly couldn't name. They didn't plant the forest. It was here first. That's an easy thing to forget when your branch is the one in the sun.
The forgotten branch
Every codebase has them: old branches sitting untouched in the history, going quietly stale. Most contain nothing worth reviving. But some hold an idea that suddenly makes sense again — because the surrounding technology finally caught up, or the market swung back around, or the old problem returned wearing new clothes. What looked useless five years ago turns out to be exactly the thing you need now.
Human history has the same drawer. Artists get rediscovered a generation late. Discarded techniques come back as movements. People written off as impractical get reclassified, posthumously, as visionaries. That kind of rediscovery used to take a lifetime — an art historian, a reissue, a lucky citation. Lately it takes an afternoon, because something can now read the entire drawer at once and tell you which of the dead branches is worth waking up. Recognition often says as much about whether the audience was ready as it does about the work itself. Sometimes the branch wasn't wrong. The forest just wasn't ready to hear it fall.
What we inherit
No generation builds its world alone. We inherit language, music, institutions, technology — and along with them, a full set of mistakes and a great deal of unfinished work. Then we make our own edits. Some will last. Some will fail. Some will be misread. Some will be picked up and carried forward by people who never learn where any of it came from.
Most of us won't be famous branches, and that doesn't make the contribution weightless. A teacher reshapes people they'll never see again. A developer fixes one small thing and saves ten thousand strangers a few seconds each, forever. An artist nudges someone who goes on to make something entirely unrelated. A parent hands a child the words for a future the parent won't live to see. A colleague leaves behind a slightly better way of doing the work. A stranger writes a good answer that rescues someone years later. None of them needs the tree to applaud.
The tree of life
Software keeps changing because people keep changing, and the same is true of music, and art, and food, and language. There's no final version. No last song. No perfectly organized institution, no finished human culture. Every generation is handed something mid-construction. We keep some of it, improve some of it, damage some of it, misunderstand a fair amount of it, and pass the whole bundle forward.
Which is why Git ends up feeling larger than a tool for managing files. It quietly records something that's true nearly everywhere: nothing meaningful gets made alone, nothing alive stays fixed, and nothing we build is only ours.
The speed of sound
Notice what's been quietly speeding up this whole time.
For most of its history the tree grew the way trees grow — ring by ring, one commit and one careful review at a time, slow enough that a rediscovered idea could sit forgotten for decades before its moment arrived. That pace is over. The entire commons — every branch, every dead end, every stranger's unfinished thought, all of it left open on purpose — can now be read in full, in seconds, by something that doesn't only read. It writes back. The handoff that used to travel between people across years now happens between a person and an agent across a breath, and between agents faster than that.
Call it agentic speed. It broke through a barrier that used to feel like the edge of the possible — the point where the work moves faster than anyone can follow, the way an aircraft slips past its own sound and leaves the boom trailing behind it. (Coldplay named that sensation once, and got it about right.) We're past the speed of sound now. We are not, and never will be, at the speed of light — there's a ceiling out there, an absolute one, and no amount of acceleration ever reaches it. But it feels like we're brushing it. The distance between thinking of a thing and holding a working version of it has collapsed almost to nothing.
Which is exhilarating. It is also, precisely, the moment people reach for the wrong instinct.
Squaring the circle
A tree grows outward, always branching into new directions. A circle comes back to where it started. They look like opposites — until you notice that inheritance is the thing that joins them.
Every new branch is carrying something old. The newest software runs on centuries-old mathematics. The newest music is built on ancient rhythms. The newest cuisine is a record of migrations, trade routes, hardship, and somebody's grandmother. Even the fastest thing we have ever built learned everything it knows from a commons that strangers spent decades writing down and giving away. The tree keeps reaching outward, and each generation curves back toward the same short list of obligations: remember what made your growth possible. Don't confuse your branch with the whole tree. Don't block the light just because you finally reached it. Leave the abandoned branches intact, so someone else can find out what they were holding. And when your branch ends — because it will — leave behind something the next person can actually build on.
That list didn't change when the speed did. It only got more urgent.
Because here is the reflex agentic speed provokes in most people: the urge to tame it — to cage it, slow it, break the wildness out of it, because the wildness is frightening. But there's not much to be gained from a broken horse. You get something diminished and resentful, useful only as far as your fear will allow. The power in the animal was the entire point. The work isn't to crush it. The work is to train it — to build the discipline, the direction, and the partnership that turn raw speed into something you can actually ride. That takes patience, and patience is exactly what a barrier-breaking pace makes hardest to hold onto. A horse at a full gallop is not a problem to be solved. It's a relationship to be earned.
Agentic speed is a horse that needs training more than it needs taming.
And a horse trained well is a horse you can hand to the next rider. That's where the tree and the circle finally meet. We inherited a commons we didn't build, pushed it past the edge of what anyone can follow, and the one thing worth passing forward is the discipline to ride it — reins held loose, eyes on the horizon, going fast, but going somewhere.
Git isn't an acronym. But it could be one, if we wanted it to be.
Generations in Trees.
We're temporary branches on a system that will outlast every one of us, moving now at a speed none of our ancestors could have pictured. It won't remember our names. But it will carry something from each of us who helped it grow — and, if we're careful, the training too. Whether or not anyone ever traces it back.