GitHub Outage Map

Community Discussion

Tips? Frustrations? Share them here. Useful comments include a description of the problem, city and postal code.

Beware of "support numbers" or "recovery" accounts that might be posted below. Make sure to report and downvote those comments. Avoid posting your personal information.

GitHub Issues Reports

Latest outage, problems and issue reports in social media:

• 
  Eriks Briedis (@eriks_b) reported 7 minutes ago

  My useful LLM workflow for startup research starts before the idea stage. When I asked models for startup ideas directly, I mostly got polished noise. They work better on messy evidence: job posts, reviews, forums, GitHub issues, sales calls. I want them turning that into structured notes about who has the problem, where it appears in the workflow, what hurts, what workaround exists, what triggered it, which tools show up, and how strong the evidence is. The judgment still has to be explicit. What to call each problem. When two signals are really the same thing. Whether a pattern is a real opportunity. Who owns the budget. Which workflow step is actually broken. LLMs can increase research throughput. The noise comes back when they skip the evidence and name the startup for you.

• 
  Gerard Wellemeyer (@G_bynature) reported 9 minutes ago

  @ColdShalamov @bradmillscan Basically, I think you're right, but I from my understanding, your statement needs clarification. A worktree originates as a structural isolation method in Github, specifically, to prevent a file being written by multiple users simultaneously. This has obviously been a similar problem with agents, and the solution- "worktree isolation" is a specific approach that yields the same results, although the mechanics may be completely different than github's. My worktree isolation approach is the same as yours- define a niche for an agent to perform a task on a specific file (i.e. database)- one agent, one writepath for that file, one owner for the writepath AND the data integrity... "accountability" In some other cases, worktree isolation may look more like a kanban card strategy, or some sort of gating.

• 
  Harry Tandy (@HarryTandy) reported 10 minutes ago

  Boris Cherny, creator of Claude Code: "Usually, every night, I have like a few thousand that are doing kind of deeper work" Anthropic's reported 8x coding output starts before Claude writes a line Build the context stack: 1. `CLAUDE.md` - role, repo rules, code style - commands Claude should run before a PR 2. `@AGENTS.md` import - if your repo already has agent rules - keep Claude-specific notes below the import 3. Architecture map - where frontend, backend, tests, auth, billing live - which folders need approval before edits 4. Task packet - ticket link, files, goal, constraints - exact definition of done 5. Past attempts - what failed last time - what error or review comment caused the retry 6. Tool context - GitHub for issues and PRs - Sentry for live errors - Postgres for schema checks 7. Verification - one command Claude can run - one pass/fail result it can paste back 8. Post-run memory - add the lesson to auto memory or `CLAUDE.md` - remove rules that no longer help A prompt asks for work. A context stack gives Claude the room to finish it

• 
  Nainsi Dwivedi (@NainsiDwiv50980) reported 11 minutes ago

  Your AI writes code that looks right and works wrong. That's not the model's fault. It's yours. You gave it a vibe and expected a spec. GitHub just shipped the fix — and it's already sitting at ~97K stars. It's called Spec Kit. The whole idea: stop treating your coding agent like a search engine and start treating it like a literal-minded intern. Vague prompt in, plausible garbage out. Precise spec in, the thing you actually meant. Here's the workflow that flips it: /constitution → your project's non-negotiable rules /specify → what you're building and why (no tech stack yet) /clarify → the AI asks its dumb questions *before* writing code, not after /plan → now the architecture and stack /tasks → broken into small, testable chunks /implement → it builds against the plan, not against a guess Every step spits out a Markdown artifact that feeds the next one. So the agent gets real structured context instead of your half-remembered Slack message. Intent becomes the source of truth — the code is just the output. Works with 30+ agents: Claude Code, Copilot, Cursor, Gemini CLI, Codex, Windsurf and more. Switch between them with one command. No lock-in. The unlock most people miss: this isn't for tiny bug fixes. It's for greenfield builds and big features where "the AI misunderstood me" costs you a day of debugging. You're not a worse engineer than the people shipping clean AI code. You just skipped the spec. repo in the comments 👇

• 
  smrati tiwari (@smratitiwa86867) reported 11 minutes ago

  🚨 Nintendo spent two years wiping out Switch emulators. It won lawsuits. It forced settlements. It erased GitHub repositories. And still... It couldn't stop the project that mattered most. Here's the story. 🧵 In 2024, Nintendo launched one of the biggest legal crackdowns the emulation community had ever seen. • Yuzu agreed to pay $2.4 million, shut down development, and surrendered its domain. • Ryujinx disappeared after direct contact with Nintendo, with its GitHub organization going offline almost immediately. • Thousands of DMCA notices were sent across GitHub to remove Yuzu-related code and forks. By 2026, emulator developers had paid millions in settlements. For a moment, it looked like Nintendo had won. But while everyone was focused on emulators... Someone was building something completely different. A developer known as Zurdi wasn't trying to emulate the Nintendo Switch. He was solving a much bigger problem: Digital game preservation. His project, RomM, doesn't crack encryption. It doesn't bypass DRM. It doesn't ship copyrighted games. Instead, it organizes the games you already legally own. Point RomM at your dumped game collection and it automatically: → Detects and catalogs your library → Downloads artwork and metadata → Organizes manuals, DLCs, patches, and ROM hacks → Tracks RetroAchievements → Syncs across multiple devices → Launches compatible browser-based emulators where supported Think of it as Plex... But for retro gaming. Today it supports more than 400 gaming platforms. NES. SNES. Nintendo 64. Game Boy. GameCube. PlayStation. PlayStation 2. Dreamcast. Genesis. DOS. Arcade. Flash games. And hundreds more. It also integrates with Playnite, RetroArch, Steam Deck, Android launchers, handheld gaming devices, and Syncthing. Your entire collection becomes searchable, beautiful, and accessible from one interface. The interesting part? Nintendo's own legal arguments have repeatedly focused on software that circumvents encryption. A library manager is fundamentally different from software designed to defeat console protections. That's why RomM occupies a very different legal space than traditional Switch emulators. The project has grown to thousands of GitHub stars, attracted a large open-source community, and even reached the front page of Hacker News. Meanwhile... Digital ownership keeps getting weaker. Games disappear from online stores. Licenses expire. Publishers remove titles without warning. Entire generations of software become inaccessible. RomM isn't just another retro gaming project. It's a reminder that preserving software history and organizing legally owned collections are very different from piracy. Nintendo may have shut down the biggest Switch emulators. But it couldn't stop people from building better tools for preserving the games they already own. Open source has a habit of finding a different path. (Link in the comments)

• 
  Moit Reghason (@MoitReghason) reported 11 minutes ago

  I think the strongest version of this is to preserve your argument, but make the progression clearer: celebration → evidence → pattern → implication → conclusion. Here’s how I’d refine it: ⸻ Everyone’s celebrating agents trading tokenized stocks on Robinhood Chain. Few people are asking what happens when the infrastructure underneath those agents gets compromised. @cursor_ai recently disclosed CVE-2026-50548, a zero-click remote code execution vulnerability where a poisoned MCP response could disable the sandbox and execute code on a developer’s machine. That’s not a hypothetical attack surface. That’s the environment where agent infrastructure gets built. And it’s not an isolated incident. ➠ mcp-pinot-server carries a CVSS 10.0 unauthenticated RCE vulnerability. ➠ Kong’s mcp-konnect allows indirect prompt injection through poisoned data that can steer agent API calls without the user realizing it. ➠ mcp-memory-service exposed unauthenticated endpoints capable of leaking sensitive agent memory data. Each vulnerability adds another entry point to the same expanding attack surface. The recent Taiko bridge exploit made this painfully concrete. $1.7M was drained, not because the cryptography failed, but because a private key was committed in plaintext to a public GitHub repository. The SGX enclave performed exactly as designed. The operational discipline didn’t. What this means for the agent economy is that security debt compounds with every new integration. Cisco’s State of AI Security 2026 found that 71% of organizations are running unmonitored AI agents with broad MCP access. OWASP’s recently published MCP Top 10 found widespread issues across the ecosystem, including path traversal vulnerabilities and extremely limited adoption of standardized authentication mechanisms. As agents gain wallet-signing authority through ecosystems like @virtuals_io and agent key management systems such as @KeeperHubApp, the blast radius of a single operational failure grows proportionally. A private key left in a public repository could drain an autonomous agent treasury just as easily as it drained a bridge. The uncomfortable reality is that the weakest link in all this was never the cryptography. It was always going to be the person who committed it.

• 
  Taelin (@VictorTaelin) reported 12 minutes ago

  *sighs* it is already frustrating enough that most of you can't understand my posts, but not being able to distinguish them from some technically illiterate SF CEO who thinks they'd proven quantum physics or some **** is another level of stupid problem is, when I write long technical posts, they tend to just flop, which is why I have to resort to these "AI good!" and "AI bad!" posts, which, I admit, may sound a bit... over-excited sometimes. that said, Bend3's consistency proof is simple enough to be explainable in a way you all can appreciate. so, below, in its full glory, how Fable contributed to Bend's consistency proof, why that was incredible and, yes, absolutely valid first: consistency is basically a word that means: "can we trust this language to formalize mathematics?". or, equivalently, can someone prove a false statement in it? imagine if someone found a proof of 2+2 = 5 in Lean. that person would be able to use this falsehood to perform arbitrary type-level rewrites, and, thus, prove any theorem (even riemann hypothesis!) in a few lines of code. that wouldn't let them $1 million, but would make for a legendary issue on Lean's GitHub, immediately invalidating any proof checked by Lean. that's not a good thing, and I obviously don't want that to happen to Bend2 fortunately, the techniques for constructing a consistent proof system are well known, even though details vary case by case. it usually involves two main parts: first, prove it is sound (i.e., that evaluating an expression can't change this type). honestly, that's just the "show us your implementation is not hopelessly buggy". it is the easy part. the second part is much more difficult: "prove every well typed program in your language terminates" this is necessary because infinite loops allow one to encode "paradoxes" (like "this sentence is false") and, to explain it in a very silly way, these paradoxes "confuse" the type checker, and allow you to prove falsehoods. so, if I want people to trust Bend as a proof language, I must be able to convince them there's no way to express an infinite loop in it. programs like "while (true)" must be, somehow, banned by our compiler. but how? the way most proof assistants (like Lean) do it is to 1. not have loops to begin with, 2. ban any kind of non-structural recursion. that means that, to call a function recursively, you must ensure that arguments are getting smaller. that's fairly standard, and fairly easy to do. so, is that it? unfortunately, that's not enough, because, in functional languages, there's another way for infinite loops to manifest: self-replicating λ-terms. for example, consider the following Python program: evil = (lambda f: f(f))(lambda f: f(f)) print evil it hangs forever, even though it has no loops and no recursion. turns out it is very easy to accidentally let some variation of "evil" to creep in, and "evil" allows one to prove falsehoods. for example, the type of types is Type, you can summon evil via Girard's paradox. and if you allow recursive datatypes to store functions, then, you can summon evil via Curry's paradox: data Evil { bad(f : Evil -> Evil) } // this would break Lean! that problem is not exclusive to proof languages. a similar paradox once caused a crisis in mathematics itself! in 1901, Russel proposed a legendary proof of a false statement in naive set theory, which was THE foundation of mathematics back then. the news was that math itself was broken, and every proof ever written by humanity would to be untrusted. crazy times! of course, this has since been "patched". today, we call it "naive" set theory for a reason! but this shows how hard it is to design a consistent proof system. humanity failed to do so for millenniums! in Rocq, Lean and Agda, the way they avoid these self-replicating λ's is via a series of "patches" - i.e., human engineered antibodies to kill the paradoxes we found in the past. for example, the 'Evil' datatype above is syntactically forbidden by disabling certain shapes of recursive datatypes ("positivity checker"), and Girard's paradox is avoided by having an infinite universe of types ("universe hierarchy"). this disables the "does the set of all sets contain itself" paradox, which, in turn, disables the `evil = λf.f(f) λf.f(f)` summoned by it. this is all solid and stablished, and people are very confident Lean and others are trustworthy. that said - and that's where I tend to change things - I argue that's overkill. while these restrictions indeed avoid paradoxes, they're also very strict, and ban perfectly valid programs. for example, it is impossible to write a fast interpreter (i.e., via HOAS) in these, and alternatives (like PHOAS) are very contrived. this makes these languages substantially less practical. Bend aims to be a proof language that is also viable as a real world programming language, so, it is of my interest to find more permissive termination argument. and that's what I was working on, with the help of Fable my argument goes like this: first, only allow recursion when arguments decrease. so far, this is the same approach used by Lean and others, nothing new here. now, we must find a way to avoid self-replicating λ-terms (like `λf.f(f) λf.f(f)`) from creeping in. that's where we detour. instead of positivity checker and universe hierarchies, I simply re-use a feature of Quantitative Type Theory (QTT) - which, in short, is an industry standard way to have O(1) arrays in an FP lang, and which Bend *already implements* - to forbid non-linear lambdas. In other words, in Bend, lambdas must be used linearly, and, thus, cannot be cloned, and that's enforced by the already existing QTT system. this simple addition is sufficient to prevent all incarnations of `evil = λf.f(f) λf.f(f)` in one strike, cutting the evil in the bud, and ensuring Bend is terminating, as it easily exhausts every known way to introduce non-termination: - infinite loops → there are no loops - infinite recursion → only allow decreasing recursion - self-duplicating λ-terms → lambdas can't be cloned from termination, consistency follows easily. and that's it. this is *obviously* correct and so easy I'm sure even you're confident you can't write infinite loops in Bend. aren't you? now, I must be very clear here. these are all *my* design choices. I didn't ask an AI "pls build a consistent proof language". I studied the subject 10 ******* years and used AI to aid me materialize my ideas. this is the antidote I found to AI psychosis. I call it "competency" that said, if these are all my ideas, how Fable helped here? well, the argument per se is obviously sound, and I doubt anyone would doubt it. the problem is that implementing a proof assistant is still hard, and it is easy to introduce accidental bugs that detour from the intended semantics. turns out the way that Bend2 wasn't faithful to my intention, for a reason that is legitimately hard to see, and that Fable identified never the less. QTT, as described in the original paper, allowed "relaxing" its checks a bit on certain places of the code. this is important for usability, and harmless to proof languages that use QTT (like Idris2), because they don't rely on QTT for termination. but Bend2 does, and these relaxed checks allowed lambdas to be cloned in some circumstances. Fable read my termination argument, studied the QTT paper, audited the implementation, and found that inconsistency, handing me a proof of Falsehood! if you can't see how incredible this is... I'm sorry for you as for the solution, Fable proposed a few. all bad. my fix was to split Type in two sorts: one for arbitrary types, and other for lower order values. this lets me have the relaxed checks on positions where lambdas cannot occur, while still ensuring lambdas cannot be cloned and, therefore, self replicate. this is the "elegant proof" I mentioned in the post below! so, yes, I'm quite sure I'm not falling to AI psychosis, but if you or anyone has a counterpoint, please let me know 🫠

• 
  Federico Ulfo (@feulf) reported 15 minutes ago

  @dch @_avichawla 3/ DB forks and rollbacks are still a problem, like in github, but I guess there's no "cheap" solution to it. Question: Curious, why not combining gitsubtree + prompts-history-{***-sha}.jsonl + a skill to manage them?

• 
  Kevin (@kevincodex) reported 15 minutes ago

  @TheExplorerecho kindly submit a github issue please

• 
  Tristan Poland (@Trident_For_U) reported 15 minutes ago

  @piq9117 @github I mean, I have my own tracking due to my CI depending on it at my home lab. It pretty much lines up with what GitHub's says (minus a full internet outage on my part, a few months back) so I'll be trusting that.

• 
  Esther Crawford ✨ (@esthercrawford) reported 20 minutes ago

  A year ago I wouldn’t have believed our iOS workflow would simplify to: describe an issue in Slack and tag an agent who picks it up, fixes it, and then sends a message a few minutes later with the GitHub PR letting us know it’s done. The magical becomes the mundane so fast.

• 
  Techjunkie Aman (@Techjunkie_Aman) reported 21 minutes ago

  It's June 2020. European Space Agency engineer Juan Font Alonso loves Tailscale. WireGuard has never been easier to use. But one thing bothers him. The encrypted tunnels are open source. The control plane isn't. Authentication, key exchange, IP assignment, ACLs, and network coordination still rely on Tailscale's proprietary server. For self-hosting enthusiasts, there was no alternative. So instead of waiting, Juan built one. That project became **Headscale**, a clean-room, self-hosted implementation of the Tailscale control server. Built from public protocols, not copied code. The best part? Tailscale welcomed it. They praised Headscale publicly, and today both projects actively work to maintain compatibility. What started as one engineer's homelab project is now the go-to self-hosted control plane for thousands of users. **Why people use Headscale:** • Self-host your own Tailscale-compatible control server • Keep authentication, keys, and network metadata private • MagicDNS, ACLs, Grants, subnet routers, and exit nodes • OIDC authentication and SSH approval workflows • REST API, Docker, Kubernetes, NixOS, and systemd support • 40K+ GitHub stars and hundreds of contributors Sometimes the best open-source projects aren't built to replace something. They're built to give people ownership over the part that mattered most.

• 
  Olalekan (@lekodes) reported 22 minutes ago

  @pamilhereen @RoseMarvelous4 which i definitely have at the moment, github has being reject my push due to package-lock.json issue

• 
  Vikas Kumar (@Kumar_Vikas__) reported 25 minutes ago

  i kept distracting myself i'd sit down to work on my e-commerce site, drift into some unrelated tab, fall down the hole, and 20 minutes later wonder what I came here to do. so I built a small Chrome/Edge extension. an AI watches your tabs and closes the ones that don't matter: judged against what you said you're working on open source here: github link in comments it's still buggy, fair warning. i'm actively working on it. using my opencode go sub right now, but soon wiring in chrome's built-in gemini api so it's free end to end. built it for myself, dropping it here in case it helps. if you fork it and send some PRs, i'd genuinely love that.

• 
  berū (@ofcberu) reported 27 minutes ago

  Built a GitHub repo for my Ai bots they use to back up versions of themselves to… eventually I can test new skills without breaking my main production line. I literally built an entire enterprise grade server with relational data base in the cloud to maker my music 🙌😭