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:

• 
  Ansar H (@theansarh) reported 2 minutes ago

  Someone built a way to send a file from one phone to another with no wifi, no bluetooth, no network at all. One screen flashes an endless stream of QR codes. The other phone points its camera at it and rebuilds the file out of the light. No pairing, no app, no shared network. Watch it pull a 2MB image across at ~129 KB/s. I went straight to the repo, because the obvious question is: how does this not fall apart the moment the camera misses a frame? Turns out the clever part isn't the QR codes at all. A screen-to-camera link is one way. The receiver can't tap the sender and say "resend frame 400", and it WILL miss frames. Blur, autofocus hunting, the screen refreshing mid-capture. Every one of those is a hole in your data. So the sender never transmits the file in order. It uses fountain codes. Every frame is the XOR of a random mix of the file's blocks, not one clean piece of it. The receiver grabs whatever frames it can catch, in any order, and once it has roughly 15% more than the file size, it peels the whole thing back out. Miss a frame? Another random mix is right behind it. There's no "resend", only "keep collecting until you have enough". That's why you can point your camera at a stream that's already running and it just locks on. My favorite detail from the source: the sender and receiver have to generate the exact same random sequence, independently. But JavaScript's Math.log is approximated differently across engines, so a laptop and an iPhone can drift by a single rounding error and silently desync the entire transfer. They caught it and hand-rolled a deterministic log to fix it. That's the kind of bug that eats a whole night. Open source, MIT, built with Claude Code. The thing I keep relearning: the interesting engineering is almost never the flashy part. The QR codes get the screenshot. The fountain code is why it works. GitHub repo in the comments 👇

• 
  Paul Breuler (@PaulBreuler) reported 11 minutes ago

  What are people using now other then #GitHub? #GitLab has proven to be too slow, constantly throttled on their cloud and don't have local servers to host, or desire. What supports high throughput planning, live artifacts, tracking thought process along with code, and rapid pr/mr/commit?

• 
  Uncle Bob Martin (@unclebobmartin) reported 12 minutes ago

  @ZechaoZheng The GitHub CI would be redundant at this point. The local tests are sufficient. The local checks are also necessary because they are part of the feedback loop that involves the agents. Putting GitHub into that feedback loop would slow it down.

• 
  Naaackers (@Naaackers) reported 13 minutes ago

  @theo hello dr theonitus would you like picthing bugs/feature requests sent via dm or just posts? I checked your githubb for a place to submit issues but I don't think I saw one but I'm also a github n00b. Just wanted to make sure I'm sending it to your preferred place. Cheers.

• 
  Ian (@IanMitchel1) reported 15 minutes ago

  @linear In "Code & reviews", clicking "Enable code access" sends me to a 404 page on GitHub. Not sure if it's an outage or persistent issue, but was hoping you might know of a workaround

• 
  Mooncore (@Mooncore777) reported 16 minutes ago

  @teortaxesTex I also made a little NDS‑style theater piece（upload on github too）. v4f cost me about 1.5 RMB (roughly $0.2 USD) and took 20 minutes to finish, but there were issues with spatial understanding—character movement and clipping problems plagued the whole thing.

• 
  moony! | 🟨⬜🟪⬛ (@_moonliit_) reported 21 minutes ago

  @sophiiess_ The problem isnt github being centered at the code instead of the downloads, its the people who make their stuff only downloadable via github which is stupid tbh

• 
  Luella (@luellarocker) reported 25 minutes ago

  CLAUDE DESIGN JUST BECAME THE FRONT DOOR OF CLIENT WORK. anthropic labs dropped a canvas where claude design builds prototypes from a prompt while claude code + github close the loop ➔ the stack claude design = client approval claude code = implementation github = proof + handover ➔ what actually changed design system lives in the repo /design-sync pulls real components handoff to claude code keeps the same ui not a screenshot rebuild ➔ most people still mock in one tool rebuild in another argue in email forever this pipeline ships prototypes share links prs and acceptance artifacts ➔ keywords that matter claude design · claude code · github actions anthropic labs · design system · client work production pipeline · mockups · auto-fix

• 
  Sternab (@SternabR6) reported 26 minutes ago

  @TheEmployee2108 @sophiiess_ No, it's a place where developers can openly work together on great projects. It is first and foremost for developers and that's what it should be. Most devs will move off github once they have something to release properly, but it's still a user error because people can't read instructions.

• 
  Wim (@Wiim1986) reported 28 minutes ago

  @CryptoCyberia Tbh, I always have trouble finding the installation package as well in github. Like, it used to be easier, even when you had to dodge fake download buttons on crummy sites.

• 
  rosa (@RosieRoberta) reported 28 minutes ago

  @inkblotPrincess The only reason people have a problem with github is because they can’t read and need a giant shiny download button that does everything for them

• 
  Wizard 🏴󠁧󠁢󠁷󠁬󠁳󠁿 (@shiddandfardd) reported 29 minutes ago

  @DIT545songs And if they are providing an exe, and github UI is the problem, then they should put a link to the download at the top of the readme on the front page. Solves the whole problem and makes it easy for everyone.

• 
  qqsqsqsqsqs (@douzedouze12127) reported 35 minutes ago

  @inkblotPrincess The problem is devs that share software to non-tech people and ONLY host it on github. How is the guy that never opened github supposed to know that the tiny little section called releases has the .exe he hants

• 
  Dorian Smiley (@dsmiley411) reported 35 minutes ago

  @chamath "That means 99% of code is sloppy and error ridden. Humans make errors that agents don’t." - have to disagree. AI is often better at expanding architecture than constraining it. It generates plausible abstractions faster than it can establish whether they are necessary. Just like humans. I am convinced the bias comes from GitHub where most of the code is garbage written by devs who are not working in a structured engineering environment. More code means more state combinations, more tests, more failure modes, and more operational burden. In other words not only do the make the same category of errors, they compound them at a speed that bogles the mind. Without guard rails both humans and AI can collapse your codebase, one just does it faster.

• 
  Carlos Mendez (@charlesmendez) reported 40 minutes ago

  For the past year, I have been working on a memory system that resembles how the human mind works, with both short-term and long-term memory. The best way I found to represent this with today’s technology was through a combination of compaction for operational memory, semantic memory using RAG, and Wiki-like graphs for structured long-term knowledge. The idea is that the AI should be able to remember what is happening right now, retrieve relevant past experiences when needed, and maintain a structured understanding of people, projects, decisions, and rules over time. After implementing the system, I created a group chat with several people and let the AI participate in our conversations. Over time, it accumulated different types of memories. Some were explicit decisions, some were project rules, some were technical errors, and others were temporary events that simply seemed important at the time. Later, I asked the AI to evaluate its own memory. I asked it to compare semantic memory against the Wiki, explain what each system did well, identify what each one got wrong, and describe how it would prefer to use them going forward. The result was more interesting than I expected. Its main conclusion was that the Wiki was technically better overall, but neither system was complete enough to act as the sole source of truth. Semantic memory was better for fuzzy discovery. It worked well when asked broad questions such as, “What do we remember about the Compensar project?” or “What happened with that Vercel issue?” It did not need the exact wording. It could find related memories based on meaning and successfully recovered things like the normal branch and pull request workflow, case-specific exceptions, who had authorized direct changes to the main branch, the requirement for runtime approval before direct writes, the correct Vercel project scope, connector problems, device errors, and README tasks. That is the real strength of semantic memory. It works through association. It is similar to how a person may not remember the exact date or sentence, but still remembers that something happened and can recover the general context around it. But its weaknesses also became clear. When the AI was asked for the exact Vercel failure, semantic memory did not retrieve the decisive serverless package error. When it was asked for the latest README pull request, branch, commit, and merge status, it mostly returned older memories about permissions and workflow rules. It repeatedly surfaced memories that were related to the topic but were not actually the answer. Some memories were truncated, older but still valid decisions were becoming less important because of freshness scoring, and similar memories competed against each other instead of being consolidated into one clearly current understanding. In simple terms, semantic memory was good at remembering the neighborhood, but not always the exact address. The Wiki had the opposite characteristics. It was more explicit, structured, inspectable, and deterministic. Its strongest project page clearly documented how the rules had evolved over time. First, there was a one-time exception to push directly to the main branch. Later, Daniel gave broader authorization. Runtime approval was still required. The Vercel project resolved to the correct client scope, and that scope needed to be derived from live CLI output rather than assumed. The Wiki also preserved dates and sources, which made it much better for understanding what the current rule was, how it had changed, and where the information came from. The AI said it would trust the Wiki over semantic memory when deciding how to execute a repository operation. But the Wiki also had serious problems. The AI described it as “memory confetti.” There were many tiny pages about individual tasks, several pages containing almost the same information, and generic entries saying things like “stored completion details” without actually storing the commit, result, or evidence. There was even a contradictory instruction saying to push to main and open a pull request. The decisive Vercel logs were missing, the latest pull request and commit were missing, and temporary connector errors were being stored next to permanent project knowledge as though they had the same importance. So while the Wiki had a better structure, the quality of the information being added to it was inconsistent. The AI scored the Wiki approximately 7 out of 10 and semantic memory 5 out of 10. Its explanation was the most important part. Operational memory requires more than similarity. It needs identity, chronology, inspectability, and conflict resolution. It needs to understand that a newer decision may replace an older one. It also needs to distinguish between a permanent rule and a temporary incident. For example, “Carlos is authorized to push directly to main” is durable project knowledge. “The deployment failed today because of a serverless package error” is an incident that may be useful for debugging, but it should not become permanent operating policy. The architecture the AI recommended was semantic memory for discovery, the Wiki for canonical knowledge, and live tools for mutable reality. In practice, semantic memory can locate potentially relevant concepts. The Wiki can store current rules, known infrastructure behavior, project identity, and superseded decisions. ***, GitHub, Vercel, databases, calendars, email, and other tools should verify facts that may have changed. Memory should not be trusted to determine whether a pull request is currently open. It should check GitHub. It should not be trusted to determine the latest deployment state. It should check Vercel. It should not be trusted to determine the current branch or commit. It should check ***. This distinction is critical because memory is not the same as reality. Memory provides context about reality. The most important finding was that the current conversation contained materially better operational history than either long-term memory system. The conversation remembered the latest deployment failure and the recent pull request lifecycle. The durable memory systems did not. This exposes one of the biggest problems with current AI memory. It is relatively easy to store information. It is much harder to decide what should be remembered, what should be forgotten, what should be consolidated, what should replace something older, what is a permanent rule, what is a temporary event, what should be retrieved through similarity, and what should be verified through a live source. A memory system is not simply a vector database where every message is embedded and retrieved later. That is recall, not memory. Real memory requires judgment, compression, hierarchy, versioning, and an understanding that some facts are durable, some expire, and some should not be stored at all because they are already available from a more reliable live source. My conclusion is that the future of AI memory will not be one system. It will be several layers working together: compact operational memory for the current task, a semantic layer for associative recall, a structured Wiki for canonical long-term knowledge, an incident history for failures and temporary events, and live tools for anything that can change. The interesting part is that the AI reached almost the same conclusion by evaluating its own failures. The question is no longer whether AI will have memory. The real question is whether it will learn what deserves to become a memory.