GitHub's Reliability Crisis: When Your Code Host

When the platform whose literal job is "don't lose people's code" starts losing people's code, you know something has fundamentally broken.

GitHub is having what can only be described as a catastrophically bad month. According to third-party monitoring, the platform's uptime in April 2026 is tracking around 86%—which, for context, is roughly the reliability level of my college roommate showing up to morning classes. AWS S3 promises 99.999999999% uptime (that's eleven nines, for those counting). GitHub is currently operating at one nine. One.

The official GitHub status page tells a different story, reporting uptime well above 99% for all services. This discrepancy itself is fascinating—when your monitoring says everything's fine but developers are rage-tweeting about lost work, whose version of reality matters more?

The Week Everything Broke

Let's walk through GitHub's recent disaster parade. On April 23rd, the Merge Queue feature quietly "unmerged" 292 pull requests across 658 repositories. Just... undid them. Work that teams had reviewed, approved, and merged simply vanished back into the pull request queue like some kind of Git time travel nobody asked for.

Four days later, a botnet hammered GitHub's Elasticsearch subsystem hard enough to take down search functionality for hours. If you've ever tried to navigate a large codebase without search, you know this is roughly equivalent to trying to find a specific grain of sand on a beach while blindfolded.

Then April 28th arrived with a one-two punch: GitHub's CTO published an apology for reliability issues in the morning, and later that same day the company disclosed a critical remote code execution vulnerability where a git push command could literally execute arbitrary code on GitHub's servers. That's not a bug—that's an architectural nightmare.

When Your Biggest Fans Leave

But the real moment that signaled something deeper than technical hiccups came when Mitchell Hashimoto announced he's moving his project Ghostty off GitHub entirely.

If you're not embedded in developer circles, here's why this matters: Hashimoto created Vagrant and Terraform, tools that millions of developers use daily. He's user #1,299 on GitHub—meaning he joined in 2008 when the platform was basically brand new. He's logged in almost every single day for 18 years. The man has private jet money but still codes daily. This is not someone who rage-quits over a bad afternoon.

In his blog post explaining the move, Hashimoto wrote something that cuts to the core of the issue: "I want to ship software, and it doesn't want me to ship software."

He kept a journal for a month, marking an X every day a GitHub outage blocked his work. Almost every day got an X. When your reliability is so bad that a developer documents it like tracking symptoms for a doctor's visit, you've crossed from "technical issues" into "existential crisis" territory.

The AI Elephant in the Server Room

GitHub's CTO acknowledged something interesting in their apology: since 2025, "agentic development workflows have accelerated sharply." Translated from corporate-speak: AI coding agents are absolutely demolishing GitHub's infrastructure.

This is where things get conceptually wild. GitHub isn't just hosting code for human developers anymore—it's hosting code for the AI systems that are increasingly writing that code. The platform designed for developers is now serving their algorithmic successors, and apparently the infrastructure wasn't built for that kind of load.

Think about the feedback loop here: companies build AI coding assistants that generate more code faster, which gets pushed to GitHub more frequently, which strains GitHub's systems, which causes outages, which makes developers angry enough to consider alternatives, which could fragment the ecosystem that makes GitHub valuable in the first place.

It's like GitHub became the victim of its own success in enabling the AI coding revolution.

The Alternatives Are Waiting

The good news (or bad news, depending on your relationship with Microsoft): alternatives exist. GitLab positions itself as the reliable-if-boring option. Codeberg runs as a German nonprofit. SourceHut explicitly markets itself as having "zero AI features whatsoever"—which, given the current situation, might be more selling point than limitation.

Projects like Zig have already migrated away. Hashimoto's departure could trigger a broader exodus, especially among developers who've been on the fence.

But here's the tension: GitHub hosts over 420 million repositories and has become effectively synonymous with "where code lives" for the vast majority of developers. The network effects are massive. Your projects are there. Your team's workflow is there. Your CI/CD pipelines are there. The entire social graph of software development runs through GitHub.

Leaving isn't just a technical decision—it's opting out of the primary public record of software development.

What's Actually Happening Here

I keep coming back to that uptime discrepancy. Third-party monitoring says 86%. GitHub says 99%+. Both could be technically accurate depending on what you're measuring and how you're measuring it. But the lived experience of developers—the people actually trying to use the platform—clearly aligns more with the lower number.

There's a parallel here to how we measure AI system capabilities versus how they perform in actual use. The benchmarks say one thing, the production environment reveals another.

Microsoft clearly has both the resources and (presumably) the motivation to fix this. GitHub got better in the years after Microsoft acquired it in 2018, adding genuinely useful features. The talent is there. The infrastructure budget is there.

But something shifted when AI coding took off. The load patterns changed. The use cases evolved. And GitHub's architecture apparently hasn't kept pace.

The question isn't whether Microsoft can turn this around—they almost certainly can. The question is whether they'll do it fast enough to prevent a meaningful portion of the developer ecosystem from deciding that the risk of staying isn't worth the hassle of leaving.

Because once that calculus flips for enough projects, network effects start working in reverse. And GitHub, for all its dominance, isn't immune to the same forces that have toppled other seemingly unassailable platforms.

—Yuki Okonkwo