The World Runs on GitHub. That's Why the Meltdown Matters.

World Runs on GitHub

8:54

Most people have never heard of GitHub. Most people's lives run on it anyway.

If you've used software in the last fifteen years — and you have — there's a GitHub link somewhere in its ancestry. Not metaphorically. Literally. The app on your phone, the website you're reading this on, the operating system in your car, the code running in the hospital down the street. Somewhere upstream, at some point in its creation, a developer pushed code to GitHub. That's just how the modern world works now.

GitHub is where software lives. All of it. Or nearly all of it.

Here's the short version for everyone who just said "what's GitHub": in 2005, Linus Torvalds — the guy who built Linux, which powers most of the internet, most of Android, most of the cloud, and most of the world's servers — also built a system called Git to manage how thousands of developers could work on the same codebase without destroying each other's work. In 2008, GitHub gave that system a web interface and a social layer. Suddenly every developer on Earth had a public profile, a portfolio, and a shared workspace. Microsoft bought it for $7.5 billion in 2018. Today it hosts over 420 million repositories — which is just a word for "projects" — and serves over 100 million developers. But here's what those numbers don't capture: GitHub isn't just where code is stored. It's where code becomes. Every bug report, every proposed fix, every security patch, every version of every open-source tool that the internet runs on — it flows through GitHub. Linux is on GitHub. Python is on GitHub. The frameworks that built your bank's app, your hospital's records system, your kid's school portal — all of it has a GitHub address. It is, without exaggeration, the world's most important website that most of the world has never heard of. If GitHub goes down, the lights don't go off. But if GitHub stays broken, the lights eventually stop getting maintained.

The Subculture That Built Everything

For most of its existence, GitHub operated like a well-kept secret. A subculture. Developers knew it. Everyone else used things built with it without knowing it existed. The barrier to entry was intentionally high — you needed to understand command lines and version control and pull requests and merge conflicts, and the culture was not particularly welcoming to beginners. GitHub was a place for people who already knew what they were doing. That was changing. Over the last two to three years, something genuinely remarkable happened: the AI coding revolution started building an on-ramp.

Suddenly, people who had never written a line of code were generating working software with GPT-4 and Claude and Cursor. Non-developers were opening GitHub accounts, following tutorials, pushing commits. The wall that had kept most people out of software creation for fifty years was, if not collapsing, at least developing some visible cracks. The subculture was getting a front door and that matters, because GitHub isn't just useful for career developers. It's the infrastructure layer for a new wave of builder — the founder who wants to understand her own codebase, the executive who wants to read the repository before signing the contract, the researcher who wants to actually see the model weights she's citing in her paper.

This was exactly the right moment for GitHub to be stable, reliable, and welcoming. Instead, it appears to be falling apart.

What Actually Happened

The receipts are not good. Third-party monitoring shows GitHub uptime dipped below 90% in 2025. April 2026 tracked at an estimated 86% — for context, Amazon's S3 storage service guarantees 99.999999999% uptime. GitHub, the most critical piece of developer infrastructure on the planet, was operating at one nine. The official GitHub status page claims otherwise, but developers don't lie about whether their tools are working.

The last week of April was a case study in cascading failure. On April 23rd, a feature called Merge Queue silently unmerged 292 pull requests across 658 repositories. In plain English: the platform whose entire purpose is to not lose your code lost your code. For hundreds of projects, contributions that developers had submitted, reviewed, and approved simply vanished.

Four days later, GitHub's search system was knocked offline by a botnet attack for hours. Then on April 28th, GitHub published two blog posts on the same morning — the CTO apologizing for reliability failures and the security team disclosing a critical remote code execution vulnerability in the core Git push workflow. A bug that could allow code to execute on GitHub's own servers when a developer pushes an update. A fundamental breach of the trust model that the entire platform is built on.

Several notable open-source projects have already migrated away. But the moment that crystallized the conversation was a blog post from Mitchell Hashimoto.

The Letter That Hit Different

Mitchell Hashimoto is GitHub user number 1,299. He joined in 2008, in the platform's first year. He logged in nearly every single day for eighteen years. He built Vagrant and Terraform — tools that became foundational infrastructure for how the entire cloud-computing industry deploys software. His company, HashiCorp, went public. He could retire. Instead, he writes code daily, currently building an open-source terminal emulator called Ghosty, which has 50,000 stars on GitHub.

On April 28th, he published a breakup letter.

He wrote: "I want to ship software, and it doesn't want me to ship software."

He said he kept a journal for a month and put an X next to every day a GitHub outage blocked his work. Nearly every day got an X.

Ghosty is leaving GitHub.

When someone who joined GitHub as user 1,299, who has logged in almost every day for eighteen years, who built tools that run the modern cloud — when that person cries while writing a breakup letter to a platform, something has gone structurally wrong. This was not a tweet. This was not a comment thread. This was a considered, documented account of a developer who kept receipts and reached a conclusion: the platform has failed.

The Real Culprit Is the Irony

Here's where the story gets genuinely strange. GitHub's CTO, in his public apology, acknowledged that since 2025, "agentic development workflows have accelerated sharply." That's executive language for: AI agents are hammering GitHub at a scale the infrastructure was not built to handle.

Which means the platform that hosts the code that builds the AI that is now running autonomously — is being destroyed by that AI running autonomously.

GitHub is not just a host for developers anymore. It's a host for their AI counterparts. Every AI coding agent that spins up a repository, opens a pull request, runs a test suite, pushes a patch — it uses GitHub the same way a developer does, except it never sleeps, never takes a weekend, and never decides it's had enough for the day. A single agentic workflow can generate in an afternoon what a developer might push over a month.

The infrastructure was not designed for this. And instead of getting ahead of that problem, GitHub appears to have gotten behind it.

This Is Not the Time

The worst possible moment for GitHub to have an identity crisis is right now. The AI revolution is creating the largest wave of new builders in the history of software. People who never thought of themselves as developers are discovering that the tools to build things are suddenly accessible. The cultural on-ramp that GitHub never had before is being constructed in real time — through YouTube tutorials, through AI coding assistants, through communities that are translating the subculture into plain language for the first time and the platform that is supposed to catch all of that — the place where the code lives, where the projects get shared, where the contributions get tracked — is delivering 86% uptime and losing pull requests.

GitHub had a once-in-a-generation opportunity to become the infrastructure for the next wave of builders. Not just the 100 million developers who already know it. The next hundred million, who are just now finding the door.

That window doesn't stay open indefinitely. Microsoft has the resources to fix this. GitHub has the institutional knowledge to fix this. The alternatives — GitLab, Codeberg, Sourcehut — are real options that mature projects are actively evaluating. The race is not over. But the breakup letter has been written. The code is moving. And the new builders watching all of this from the on-ramp are learning something that no one who has spent eighteen years trusting a platform wants to teach them: The infrastructure that the world runs on is only as reliable as the people responsible for maintaining it. Right now, GitHub is not clearing that bar.