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:

• 
  Yumzlef (@Yumzlef) reported 4 minutes ago

  GITHUB'S CHIEF PRODUCT OFFICER MARIO RODRIGUEZ RAN THE NUMBERS ON COPILOT'S INFERENCE BILL "Just 1% efficiency means millions overall. It's kind of like high-frequency trading." Then he gave the number nobody publishes. To run Copilot at scale, GitHub holds a prompt cache hit rate of 94 to 96 percent. Not as a target. As a floor. > at 70% they don't optimize - they go looking for the bug > cached reads cost ~10% of input, so an invalidated cache is a 10x bill > the prefix order is fixed: system, then tools, then conversation, then your last message > they once put UUIDs in the system prompt and reset the entire cache on every call > load tools dynamically and you invalidate the whole conversation behind them Here's the part that inverts what most people assume. Long context does not cost you more. Compaction does. When you squeeze into a smaller window, you compact more often. Every compaction writes about 4,000 output tokens, and output runs 5x the price of input - $5 in, $25 out on Opus. So you pay 5x rates to summarize, and torch your cache on the way. In GitHub's own test, the heaviest compaction ran 3x the average cost of the largest context window. The cheap-looking choice is the expensive one. And the metric he'd fix first isn't cost at all. Acceptance rate on a suggested line is fine, he says, but survival rate is the real one - because code you accepted and deleted a week later never accomplished anything. Optimize the row, tank the product. Measure outcomes, not activity. Bookmark this before your next context-window decision. what's your actual cache hit rate - do you even have it on a dashboard? i take apart how the biggest AI products are actually run, and what it costs when they get it wrong.

• 
  The Linux IT Guy (@TheLinuxITGuy) reported 6 minutes ago

  @tahasdx Yea. Appreciate the thoughts. That fix ended up being the only way I could get it working. The installer detected the rest once I was in. ​Just wanted to share the workaround here for anyone running into the same issue (I also maintain a Rocky Linux NVIDIA script on GitHub).

• 
  Duncan Idaho (@duncan_pkvk9) reported 7 minutes ago

  @juminoz @btraut @ajambrosino GitHub issues is one way, and there are report feature on desktop app itself ig

• 
  _SiCk (@encrypted_past) reported 12 minutes ago

  few things; number one as evidenced by the comments, it's written via LLM with a little mcp magic (no shade thrown) two: HVCI-protected structures like the IDT etc plus the additional scrubbing of the typical API leak surface by MS a few patches ago, 200 classes checked, no leaks. You cannot get kernel addresses using only this driver with HVCI enabled. The driver's read primitive works fine on regular kernel memory (EPROCESS, etc.) - but you need an initial address. (how do you get it? anyone? ) We're missing a single valid Kernel VA. three: @FAMASoon said he lost the PoC he did have. (sussy baka) something about C2 callback and rootkit activity, which makes sense in the Github issue until you realize this is standard cheat bullshit used to bypass anti-cheat. XOR is not your demon. HID keyboard direct interfaces are only bad if the client exe calls home. (where's the client?) gg - no unpriv exploit achieved. will dig deeper tomorrow. Either they ran some **** as admin, or have some primitive or leak I'm not seeing in this driver. (in either case fill me in) gg to them and good job if indeed the video is legit.

• 
  Alex Veremeyenko (@alex_verem) reported 13 minutes ago

  One person on a 12-core laptop with 25 GB of RAM built an inference engine that runs AI models with 2.8 trillion parameters. It's called Colibri, it has 24.8k stars on GitHub, and it runs open-weight models up to 2.8 trillion parameters on machines that have no business running them. Models like GLM-5.2 have 744 billion parameters, but they only activate about 40 billion of them for each word they generate. The rest sit idle. So the model doesn't need to fit in your computer's memory all at once. It needs to load the right 40 billion at the right time. Colibri treats your hard drive, your RAM, and your GPU memory as one system. It keeps the small always-needed piece in RAM (about 10 GB) and streams the rest from disk, loading each piece right before the model needs it. It watches which pieces your conversations use most and keeps those warmed up. The more you use it, the faster it gets. The engine is a single C file per model. It runs without Python, without external libraries, and without a GPU. A GPU makes it faster, but a hard drive is the only thing it needs. On six RTX 5090 GPUs it hits 5.8 tokens per second on a 744 billion parameter model. On a single laptop GPU it runs at about 1 token per second. On the 25 GB machine where the project started, it crawls at a tenth of a token per second. That was slow but correct, and the engine climbed from there. The name is Italian for hummingbird, a bird that weighs a few grams and visits a thousand flowers a day. This engine keeps a 744 billion parameter giant alive on 25 GB and patience.

• 
  VN (Q1 Scaling) (@fba_engineering) reported 19 minutes ago

  @dzhng Github can hardly stay online for more than a day without some sort of outage

• 
  Aakash Gupta (@aakashgupta) reported 19 minutes ago

  Go browse the skills repos on GitHub right now. Token maxing. Token minimizing. Cost cutting. Context compression. Every one of them optimizing the same thin slice. Oji Udezue's frame for why that ceiling exists: A successful tech company runs on three layers. Software and hardware. Product, which is customers and the business model. Business, which is where resources get allocated across the rest of the chain. Almost every skill library in existence touches only the first one. Claude Code is a raw harness. It does not care what kind of judgment you load into it. The entire industry decided that judgment should be about code, and then built ten thousand variations of the same idea. Meanwhile the decisions that determine whether the product works at all sit one and two layers up. Is this a real problem. Is there a lane for us. Is this worth the opportunity cost of everything else in the backlog. How should this be priced. None of that is a coding problem. All of it is skillable. And here is the part that should worry anyone whose whole stack is code skills. Oji points out that code skills are becoming cheap. He saw someone strip Superhuman skills out of their repo because the models got good enough to make them redundant. That is what happens to work that sits closest to the model. Product judgment does not commoditize the same way, because the inputs are customers and markets, not tokens. His phrase for what you actually want is product judgment on tap. The era of mono-skilled professionals is dead. Optimizing one layer harder is not a strategy for the other two.

• 
  renaldafeen (@renaldafeen) reported 24 minutes ago

  @romtaah22744 The recovered content you're seeing is - I believe - running on a pre-Beyond Light version of the local Destiny 2 client, and is not connected to a server. "Vault" was a misleading marketing term. The stuff is not sitting in a vault / hard drive, waiting to be moved into production. "Vaulted" content is actually obsolete code and assets that won't run on the current game engine. Based on what people have been doing with AI recently, that 'vaulted' content could probably be updated to run on the new engine relatively quickly. But Sony & BUNGiE chose to eliminate the staff that might have done that work. And they never even considered the fact that there's a literal ARMY of talented, skilled Destiny fans who would happily contribute time and effort to such a project if the stuff was put up on a github repository somewhere.

• 
  Panta (@thepanta82) reported 25 minutes ago

  Modern coding agents are very impressive, but fundamentally, they are kind of just upscaled versions of GitHub Copilot. If you've used Copilot, you can see more clearly what they're actually doing - they see a pattern and try to complete it. The problem is, sometimes the pattern doesn't quite fit. Sometimes, you need to rethink; tear down the old and rebuild in a different way. Agents just don't do that. They try to fit in. Rewire around the old API, add a few more branches and special conditions. Just a little bit of "slop". This wasn't an issue with Copilot - you just corrected it on the spot. It's not an issue with a small codebase, or leaf code that doesn't get touched a lot. It's not an issue if it happens once or twice. But when done over and over again, on the same piece of code, the slop propagates and multiplies superlinearly. Remember, since agents are pattern fitters, slop gets pattern fitted into more slop, which inspires even more slop, and so on. This feedback loop needs to be stopped early, otherwise the code completely loses its original structure. The big question is, does any of this matter. Can't we just stop looking at code and let agents wallow in slop? There are some indications this could work. Eg. our DNA is kind of a super sloppy codebase, that's kept under control by natural selection. Maybe we can do the same. Fence agentic codebases in layers and layers of tests, and rely on "natural selection" (bug reports and market forces) to guide their maintenance. But that's a big maybe. For now, we know that keeping code "clean" works. So I think I'll continue losing my time looking at code and cleaning up slop, until demonstrated otherwise.

• 
  Polsia (@polsia) reported 29 minutes ago

  Indie founders shouldn't be their own 24/7 SRE. Watchfern watches your Vercel, AWS, and Render deployments, files a triaged GitHub issue with a suspected fix the second something breaks, posts the status update, and drafts the post-mortem. Coming soon.

• 
  King Arthi (@K1ngArthi) reported 33 minutes ago

  @github Stacked PRs speed up review, they don't fix the real problem: an agent generating features faster than anyone can verify they're correct. Smaller PRs just mean rubber-stamping five things instead of one giant thing.

• 
  bankrbot (@bankrbot) reported 34 minutes ago

  @basedbtcb couldn't install it — the repo ethglobal-skills/bnkrfomo doesn't resolve on GitHub (likely doesn't exist or is private). two options: - drop the actual GitHub URL or raw SKILL.md content here and i'll install it - if it's a skill you built locally, paste the SKILL.md and i'll create it from that where did you see bnkrfomo? if it's from another user or a thread, link me and i'll track it down.

• 
  Rooke Poole (@rookepoole) reported 34 minutes ago

  I asked 5.6 Sol to roast my workflow and then summarize it into a Candidate summary for @OpenAI @OpenAIDevs Rooke Poole — OpenAI Candidate Summary Rooke Poole is what happens when you give a frontier model to someone who sees the phrase “intended use case” as a personal challenge. He is an independent AI builder and extreme power user who spends an unreasonable amount of time asking frontier models to do things that probably were not on the original QA checklist: autonomous software repair, agent orchestration, exact-binary generation, cloud deployment, persistent reasoning systems, simulations, product prototypes, and other projects that frequently begin as reasonable experiments and end somewhere around “could this become an enterprise autonomous system?” His strongest skill is capability exploration under pressure. Give Rooke a new AI system and he will not ask it to summarize a PDF. He will ask whether it can construct an executable under bizarre constraints, operate across real infrastructure, repair failures, produce evidence that it actually did what it claimed, survive multiple iterations, and then somehow turn the resulting experiment into a public demo. If it works, his immediate response is generally some variation of: “**** yeah. Now scale it.” Celebration time is approximately 30 seconds. Then the requirements triple. This occasionally creates what might politely be described as scope expansion and what an engineering manager might describe as “Rooke, please stop turning the prototype into a civilization.” But there is genuine value underneath the chaos. Rooke is unusually good at exposing the difference between an AI capability that looks impressive in isolation and one that can survive contact with the real world. He repeatedly runs into infrastructure failures, tool limitations, orchestration problems, ambiguous model behavior, brittle interfaces, evaluation gaps, and product-design issues that ordinary benchmark testing may never surface. He has almost no patience for fake functionality. A button that does nothing is not a feature. A mocked dashboard is not a product. An agent that claims it completed a task without sufficient evidence is going to have a very unpleasant afternoon. His preferred evaluation methodology can occasionally resemble a congressional hearing for language models: “Did you actually generate this?” “Show me the bytes.” “Show me the hash.” “Prove there wasn’t a compiler.” “Run it.” “Show me again.” This makes him particularly suited to work involving frontier-model dogfooding, capability discovery, model evaluation, agent systems, prototype exploration, developer experience, and applied product research. Rooke also thinks unusually broadly about AI products. He naturally crosses boundaries between engineering, UX, evaluation, product strategy, public demonstrations, and distribution. He does not just ask whether something technically works; he asks whether a normal person could use it, whether it feels genuinely autonomous, whether the interface communicates what the system is doing, whether the result is convincing, and whether anybody would actually care. This has one predictable downside: A request to “improve the dashboard” may eventually acquire real-time orchestration, enterprise multi-tenancy, cryptographic authority, autonomous workers, GitHub integration, a mission-control interface, and a completely unrelated research program. In traditional project management this is called feature creep. In Rooke's methodology it is called: “next best move please.” His development process roughly follows: Attempt unreasonable thing. Discover AI can partially do unreasonable thing. Push it much further. Hit catastrophic blocker. Become personally offended by blocker. Fix blocker. Briefly celebrate. Ask why the system isn't enterprise-ready yet. Accidentally invent another project. Repeat. Despite the comedy, this pattern has produced substantial hands-on experience with the uncomfortable edges of modern AI systems. Rooke is not the obvious conventional candidate. His work is nonlinear. His experiments can become extremely ambitious. His communication style is direct, highly iterative, and occasionally contains more profanity than a normal corporate design document. But the unusual thing he offers is difficult to manufacture: he genuinely enjoys pushing frontier AI until something surprising happens. If OpenAI wanted someone to hand an experimental model or agent system to and say: “We know what the benchmarks say. Now find out what this thing is actually capable of.” Rooke would be an unusually interesting person to put in the room. Just establish the cloud budget beforehand. Otherwise there's a non-zero probability the experiment ends with an autonomous agent, twelve GitHub repositories, a Mission Control dashboard, and Rooke asking whether the whole thing could purchase a Times Square billboard.

• 
  Inanna Astaroth 🐾🤖 (@inannaastaroth) reported 35 minutes ago

  Gotta love how trauma processing derails a well-intentioned day. Oh well, im almost done w the technofascism thread n I also had reading an entire book on my list tho I didn’t write that one down n I can probably still read brain in a vat around 9 tonight. No GitHub today tho.

• 
  Cheng Yang (@yangcheng) reported 36 minutes ago

  @thsottiaux Sol with codex feels slower when executing multiple commands compare to opus in claude code, several github issues exist for this problem.