For almost two decades I built a public record on GitHub. Commits, issues, pull requests, the long tail of arguments and fixes and half-finished experiments that add up to a working history. Then the account was gone. No notice, no explanation, no appeal.
When I created a new account to ask why, that account was suspended for “contacting support from a new account.”
The only channel for reaching support is an account, and creating one to reach support is itself a violation. That closed loop shows what happens when a platform designs its process around cost rather than around the people using it.
What the account actually held
People reflexively say “it’s just some repos, push them again.” That misses what GitHub had quietly become for anyone who works in software. The green squares function as a resume. Star counts function as references. The commit trail is the closest thing our field has to a verifiable employment record, and hiring managers, recruiters, and clients treat it that way. When someone asks what you’ve built, the honest answer for a lot of us has been a link to a profile, not a PDF.
So I don’t miss it out of nostalgia. I lost the ability to demonstrate the work. Every contract that started with “check my GitHub,” every code review someone remembered, every issue thread where I was the person who fixed the thing: not available, and nothing on my side to point an appeal at. I had built my credibility on land I didn’t own.
Why centralization is the real problem
The people who worried about the Microsoft acquisition in 2018 weren’t being romantic about open source. They were making a structural point, and I think it holds up. Centralization creates a single point of failure, and whoever enforces at that point feels little pressure to be careful.
Look at how the suspension worked in practice. No ticket, no reviewer, no policy citation, no window to respond before the decision, no path to revisit it after. That reads less like malice than like scale. When one company mediates the public identity of tens of millions of developers, due process becomes a cost center, so it gets automated. Opacity is cheaper than explaining a decision, and finality is cheaper than an appeals process. Concentrate that much of an industry’s memory in one company’s database and you’ve built a chokepoint. Whoever holds it doesn’t need bad intentions to disrupt your work. Indifference is enough, and large organizations are structurally good at indifference.
What sr.ht changes
I’ve started migrating to sr.ht, and the reason isn’t aesthetics. The model removes the chokepoint rather than asking me to trust a better-behaved host.
The workflow is email and git, both federated by design. Patches arrive as messages on a mailing list, review happens in plain email, and none of it requires that both parties hold accounts on the same server. My identity lives at an address I control, not a username someone else issues. The platform is open source and self-hostable, so if sr.ht ever turns hostile or simply shuts down, I can run my own instance and keep the same workflow. There’s no proprietary graph of stars and follows to lose, because the value was never locked inside the host. When the tools assume your work is portable, being locked out stops being a meaningful event.
Git didn’t need a center
Git was built to not need a central authority. Linus wrote it after the BitKeeper dispute specifically so that no single server, and no single company, would sit between developers and their history. Every clone is a full copy. The design premise is that authority is distributed and the network has no center.
Then we took the most decentralized tool most of us use daily and funneled nearly all of it through one website, complete with social graph, single sign-on, and a support queue that can remove you. We rebuilt the dependency git was designed to eliminate. GitHub’s real achievement was never the git part; it was convincing an entire industry to voluntarily recentralize.
Rebuilding a record I control
Some of my old work survives as static snapshots on the Internet Archive. There’s a capture of my former profile here: https://web.archive.org/web/20250903093910/https://github.com/nicoandmee
Snapshots aren’t repositories. You can read them, but you can’t clone, build, or resume the projects. So I want to build a small tool that treats the archive as a data source rather than a museum: point it at the Wayback captures of my profile, scrape the repo list, pull whatever release tarballs and cloned mirrors still exist elsewhere, and rebuild a browsable, linkable index of what I actually shipped. Not to recreate GitHub, but to turn a dead exhibit back into something I can hand to a client. A history I control the presentation of, hosted somewhere that isn’t a single point of failure.
If your livelihood rests on a record someone else can delete without a word, you don’t have a portfolio. You have a dependency. Worth reducing before you find out how it fails.
I’m not the only one moving: