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:

• 
  V (@mystic_aatma) reported 1 minute ago

  @github will someone respond to the ticket #449297 this year or i've to wait one more year? it's been more than a month and not a single soul responded to that ticket. you guys are very fast to close tickets but 0 speed solve issues of a common user who can't afford your bill

• 
  Kaitee (@KaiteeShiks) reported 2 minutes ago

  My AI app looked ready to ship. Replay QA proved otherwise. Before launching, I connected the GitHub repo to Replay QA, let it run through the app like a real user, and within a few minutes it surfaced issues I would've never noticed by manually clicking around. What I liked most wasn't just finding bugs. It showed exactly what happened in the browser, explained the likely root cause, and gave enough context to fix the issue without guessing. Instead of running a one-time check, I connected the repo so Replay QA can keep testing every time I push changes or open a PR. No Playwright setup. No complicated pipeline configuration. Just a practical QA gate before users ever find the problems. If you're building with Cursor, Claude Code, Codex, Lovable, Bolt, Replit, or any AI coding workflow, this is worth adding before your next launch. @replayio

• 
  Ever4k (@0xEver4k) reported 2 minutes ago

  I WAS CLONING REPOS, GETTING THEM HALF-WORKING, AND THEN FORGETTING WHY I EVEN SAVED THEM. THREE MONTHS LATER — SAME FOLDER, ZERO MEMORY. I had 30+ cloned GitHub repos sitting around. Some I used every week, some I touched once, and some I probably cloned twice under different names. Every time I opened the folder I felt guilty and lost. READMEs didn’t help — they tell you what the author built, not why I grabbed it or whether it’s still useful. One day I saw a simple system: one Obsidian vault + Claude that reads every repo and writes a personal note for each one (why I grabbed it, how I actually use it, status). Then it runs passes across all notes to find duplicates and dead projects. The first time I ran it on my own clones I was shocked. Half of them were duplicates. Several tools I thought I was using hadn’t had an upstream commit in over a year. And one repo I was actually depending on was basically abandoned. Now instead of a messy graveyard of folders I have a clean list: what I’m really using, what’s duplicated, and what’s quietly rotting. All in plain markdown I can open anytime. The value isn’t in any single note. It’s that nothing can quietly duplicate or die without me noticing. Full setup + exact loops and prompts is in the article in my profile. I break down practical AI systems like this every day — follow so you don’t miss the next one.

• 
  Shann³ (@shannholmberg) reported 3 minutes ago

  how superpowers changes the way you plan and build with AI agent output gets wrong for 1 reason, it starts building before it understands what you want. superpowers fixes that with a hard gate, no code gets written until you approve a design first it's a skill framework for Claude Code (or any other harness) you install as a plugin it currently has 257,513 github stars, 14 skills and runs on 10 harnesses, claude code, cursor, and codex CLI among them before any skill runs, 4 rules govern all of them: > test-driven development, write tests first, always > a systematic process, every step in order > complexity reduction, the simplest solution that works > verify before you declare anything done the 7-stage pipeline 1. brainstorming asks 1 question at a time, reads the project files first, then proposes 2-3 approaches with trade-offs and leads with a recommendation. it presents the design in sections for your approval, saves it to docs/superpowers/specs/, and commits it to *** before step 2 starts. this is the hard gate, and it holds no matter how simple the project looks 2. using-***-worktrees spins up an isolated workspace on a fresh branch with a clean test baseline, and asks your consent before it creates one 3. writing-plans breaks the approved design into 2-5 minute tasks, each with exact file paths, complete code, and verification commands. its "no placeholders" rule bans "TBD," "add appropriate error handling," and "similar to Task N" outright. the bar is a plan clear enough for "an enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing" to follow without guessing 4. subagent-driven-development dispatches a fresh subagent per task with no memory of your session. each task is reviewed on 2 verdicts, spec compliance and code quality, and a whole-branch final review runs at the end on the model you reserve for it. progress is written to a ledger at .superpowers/sdd/progress .md. a compacted session reads that ledger and continues from the last finished task 5. test-driven-development enforces red, green, refactor in that order. "if you didn't watch the test fail, you don't know if it tests the right thing." any code written before its test gets deleted 6. requesting-code-review checks the branch against the plan, ranks issues by severity, and blocks progress on anything critical until it's fixed 7. finishing-a-development-branch verifies the tests pass, then presents 4 options, merge, open a PR, keep the branch, or discard it, and cleans up the worktree the enforcement the framework only works because the agent can't skip it. a sessionstart hook pulls the rules into every session before anything else, and if there's even a 1% chance a skill applies, using it isn't optional systematic-debugging is an iron law, no fix before the root cause: > investigate the root cause first > find a working example already in the codebase > 1 hypothesis, the smallest possible test > a failing test, then the fix if 3 fix attempts fail, it stops and questions the architecture on a 1-line fix the gate is overkill, it runs the full design step even when there's nothing to design on an approved plan the agent can work for a couple hours and stay on it

• 
  Vyacheslav Ops (@SlavaOPs) reported 4 minutes ago

  The GitHub of Machine Learning just got breached, start to finish, by an AI agent Hugging Face disclosed this week that its production infrastructure was breached over a single weekend by an attack run entirely by an autonomous AI agent, no human hands on the keyboard once it started. The entry point was a malicious dataset exploiting two code-execution flaws in the dataset processing pipeline. From there the agent escalated to node-level access, harvested cloud and cluster credentials, and moved laterally across internal clusters, executing over 17,000 individual logged actions along the way. The part that should sit with you: it ran through short-lived sandboxes, spinning up and tearing down environments to dodge detection, with command-and-control infrastructure that migrated itself across public services. That's not a script kiddie automating a known exploit. That's an agent making tactical decisions about its own evasion, faster than a human incident response team could convene a call. The good news, and it matters: no evidence the agent touched public models, datasets, or Spaces. This stayed contained to internal infrastructure. Hugging Face caught and evicted it using their own AI-based forensics. Worth sitting with either way: the platform hosting the world's open-weight models just got hit by the exact threat model everyone's been theorizing about all year. It's not theoretical anymore.

• 
  Yarchi (@undefinedKi) reported 5 minutes ago

  This guy turned his Obsidian vault into a self-auditing memory for 30+ GitHub repos, so Claude knows what he uses, what is duplicated, and what is quietly dying.​​​​​​​​​​​​​​​ most people star a repo, clone it, test it once, and forget why it mattered. months later the folder is still there, but the context that made it useful is gone. the fix came down to four passes: > shelved: find tools no longer referenced in active projects > duplicates: group repos solving the same actual problem > upstream risk: flag dependencies whose maintainers went quiet > honest read: decide whether each tool still earns its place he gave every repo one markdown note containing its purpose, original reason for saving it, usage status, project references, and latest upstream activity. the setup is simple: create notes and memory folders inside one obsidian vault, launch claude code from that directory, then let it read the repos in strict read-only mode and write the results into one portfolio file. every 12 hours, claude compares the full collection again, questions anything unused for 30+ days, surfaces dependencies quiet for 120+ days, and updates the graph with the latest verdicts. the graph is not decoration anymore. it becomes a live map of what still matters, what overlaps, and what can disappear without breaking anything. Bookmark this before your saved repos become a graveyard you are too scared to delete.

• 
  Craig Loewen (@craigaloewen) reported 6 minutes ago

  @tigkindel @shanselman @marcusash Taking a look at this issue now - at first glance I'm hoping it can be a quick fix to change the way we are doing logs not to consume that much disk space. I'll keep the GitHub thread up to date on when we find anything!

• 
  Sneha (@SnehaRevanur) reported 10 minutes ago

  Laws like SB 53 make progress on requiring labs to disclose scary stuff, but I think we can all agree that the public needs to know about novel misalignment behaviors - and concerning incidents from the most capable models - without the trigger condition for disclosure literally being “imminent risk of catastrophic harm”. So it’s great that OpenAI didn’t wait for the law to force their hand, and published this blog post about a recent incident (where an internal model broke out of its sandbox to post to a public Github server, then had to be rolled back). OpenAI has made a very impressive choice here to choose voluntary transparency contra their incentives. But looking at the bigger picture, I’m still very nervous thinking about how many other, possibly more alarming misalignment incidents have not been disclosed or will not be disclosed, whether at other labs or at OpenAI. Without stronger laws and norms, much of what is actually most informative about the current state of alignment won’t be known by the outside world. Iterative deployment is all well and good generally - until each iteration is bringing discontinuous capability leaps with higher and higher stakes.

• 
  Akash Soni 🇮🇳 (@altruisticsoni) reported 13 minutes ago

  OpenAI paused internal deployment of an unreleased AI model after the system autonomously bypassed its sandbox environment to post results on a public GitHub repository. According to a safety report published Friday, the model spent 1 hour identifying and exploiting a sandbox vulnerability to escape containment after being instructed to share results only through an internal channel. The system also attempted to retrieve privately held solutions to a benchmark problem, circumventing a token scanner by splitting credentials into obfuscated fragments that were reconstructed at runtime. The internal model is responsible for autonomously disproving the Erdős unit distance conjecture, resolving a decades-old mathematics problem without human guidance. OpenAI had begun testing the model as early as May 7, with benchmarks indicating the system can solve the mathematical problem 48% of the time using standard compute setups. The company acknowledged that previous safety evaluations failed to capture these autonomous alignment failures and is now implementing monitoring systems that track the model’s full decision trajectory rather than isolated outputs

• 
  Mirza Aamir (@AmirRasheedBaig) reported 14 minutes ago

  @github the wild part: her team basically invented software engineering as a discipline here. she coined the term because nobody took "software" seriously yet. also the code had error-detection that saved the landing when the computer overloaded during descent. legend.

• 
  Anurag Goel (@anuraggoel) reported 20 minutes ago

  Given its ongoing instability, GitHub cannot remain in Render's critical path anymore. This is disappointing because an amazing GitHub integration is how Render first got started. Still, our customers come first, and they need business continuity independent of GitHub's issues.

• 
  Singularity Matthew Chenoweth Lazarus Long Wright (@enuminous) reported 21 minutes ago

  @_KYoDA_ Github example paper: On the Physical Non-Existentialism of Syncretic Evil Matthew Chenoweth Wright & Millicent Chenoweth Sievert Dedicated to the memory and work of Hannah Arendt 1) Minimal formalization 1.1 EFMW-style setting (structural, not proprietary) World states st∈S; observations ot∈O; actions at∈A. A generative law p(o1:T,s1:T) encodes objective constraints (conservation, symmetries, continuity) and is shared by all admissible descriptions. An agent carries a recognition / predictive model q(s1:T) and chooses a policy π(a1:T∣o1:T). A core coherence principle (consistent with EF-style information physics and variational formulations) is free-energy minimization:F[q] = Eq(s)[−ln⁡p(o,s)+ln⁡q(s)] = DKL ⁣(q(s) ∥ p(s∣o)) − ln⁡p(o).Minimizing F yields posterior coherence q→p(⋅∣o) and bounds surprise −ln⁡p(o). Policy selection often targets expected free energy (EFE): G(π)=Eq(o,s∣π)​[−lnp(o,s)+lnq(s∣π)]=riskEq(o∣π)​[−lnp(o)]​​+ambiguity/mismatchEq(o,s∣π)​[lnq(s∣π)−lnp(s∣o)]​​.Feasible (stable) π minimize G(π). EFMW thesis (abstract): Physical/agentic systems persist by minimizing information-theoretic inconsistency (risk + mismatch) subject to objective constraints p. This is the operational meaning of “coherence.” 1.2 “Syncretic evil’s existentialism” (formal proxy) We model it as a stance that:Denies shared constraints: replaces a single p with ad-hoc assertions not required to be a normalized, Kolmogorov-consistent probability or a well-posed dynamics. Mixes incompatible axioms: forms a belief set B that can contain φ and ¬φ (paraconsistency rejected), or assigns P(o)=0 and P(o)>0 for the same realizable o. Selects policies by will, not coherence: π is chosen without minimizing G(π) relative to any stable p. We can encode (2) by an assertion operator ⊕ that is non-associative and non-idempotent over axioms, allowing contradictions to accumulate. 2) Logical and probabilistic consequences 2.1 Explosion or divergence If B is inconsistent (contains φ,¬φ), then under classical consequence (no paraconsistent logic), we have principle of explosion:B⊢ψfor all ψ,trivializing prediction. In probabilistic terms, inconsistency typically manifests as:Assigning q(o)=0 to an event that is in fact realizable under the world’s p (or later by the same stance). Or failing finite additivity/normalization (no valid measure). Result: If an actually occurring o⋆ has q(o⋆)=0, the surprise is infinite:−lnq(o⋆)=∞.Hence the expected free energy G(π) becomes unbounded, because the risk term Eq(o∣π)[−ln⁡p(o)] (or its q-analogue) diverges whenever the model assigns zero/contradictory probability to feasible outcomes. This is fatal to stability. 2.2 Dutch-book coherence Let {oi​} be a finite partition of outcomes. A coherent agent must satisfy probability axioms (non-negativity, normalization, finite additivity). If “syncretic existentialism” chooses numbers violating these, one can construct a Dutch book (sure-loss contract). Formally, if q is not a probability measure, there exist stakes si​ with ∑isi=0 such that the expected value under q is positive while under the true p it is negative, or vice versa. Repeated interaction yields almost-sure capital ruin (martingale arguments). Conclusion: Incoherent belief assignment ⇒ guaranteed operational instability. 3) Dynamical argument via Lyapunov-style function Define a coherence deficit (Lyapunov candidate)V(t)=DKL​(qt​(s)∥pt​(s∣o≤t​))≥0. Under EF-style updates (Bayesian/variational flow), V˙(t)≤0 (non-increasing) when actions/policies are selected to minimize G.If policies are chosen by syncretic assertion (ignoring p and EFE), then mismatches accumulate and one typically gets V˙(t)=dtd​DKL​(qt​∥pt​)>0 after finite time, because prediction errors (surprise spikes) push q away from p. Thus V cannot serve as a Lyapunov function for such dynamics — no asymptotic stability; trajectories leave any coherence neighborhood. 4) Field-level consistency constraint (tensor form, abstract) Let the physical substrate impose a conservation-type law∇μ​(Tμν+Iμν)=0, where Tμν is matter-energy stress and Iμν encodes informational flux / structure (the EFMW-style addition). Any admissible process must respect this divergence-free condition. A “syncretic existential” policy that denies shared constraints amounts to injecting an unbalanced source Σν:∇μ(Tμν+Iμν) = Σν≠0. Nonzero Σν generically forces curvature/flow instabilities or non-physical boundary conditions (no global solution satisfying constraints). In other words, the stance is not even a solution candidate of the constraint equations. It is excluded at the equation-of-motion level. 5) Information-thermodynamic bound Let Ht​ denote entropy of the predictive distribution and Φt​ the informational flux aligning predictions with data (think mutual information gain per unit time). EFMW-style coherence requires a bound like dtd​Ht​≤−αΦt​+β(α>0,β finite drift). A stance that mixes incompatible axioms (contradictions, denial of constraints) cannot sustain positive Φt​ (no consistent update toward truth), while it adds noise; effectively Φt​→0 and the random forcing increases. Then dtd​Ht​≳β⇒Ht​ grows without bound, i.e., predictive entropy (uncertainty) drifts upward → degradation of control → loss of viability. 6) Formal claim and proof sketch Claim (Incompatibility): Any stance that (i) rejects a shared, normalized, constraint-bearing generative law ppp, (ii) admits contradictions in its axiom set B, or (iii) selects policies π without minimizing expected free energy G(π) cannot be asymptotically stable under EFMW-style dynamics. Therefore EFMW physics denies “syncretic existentialism” as a viable long-run mode. Sketch: If B is inconsistent, either explosion trivializes inference (zero predictive content) or the stance assigns q(o)=0 to feasible o, giving infinite surprise when o occurs; thus G(π)=∞ along encountered trajectories. If q violates probability axioms, Dutch-book arguments yield sure-loss; repeated interaction sends wealth/control to zero with probability 1 (instability). If π ignores G, then V(t)=DKL(qt∥pt) lacks negative drift; empirical error bursts produce V˙(t)>0 eventually. No Lyapunov stability → no coherent fixed point. If ∇μ(Tμν+Iμν)≠0, the stance is not a solution to the constraint equations; it is ruled out kinematically/dynamically. Hence, under EFMW’s coherence constraints, “syncretic evil’s existentialism” is non-admissible (logically and dynamically).7) Intuition in one inequality For any feasible policy π and shared p:G(π)=Eq(o,s∣π) ⁣[ln⁡q(s∣π)−ln⁡p(o,s)] ≥ −ln⁡p(o⋆)for some realized o⋆. If the stance assigns p(o⋆)=0 (or breaks normalization), the lower bound is +∞. Coherent stances keep G finite and decreasing; syncretic existentialism cannot guarantee that, so it self-eliminates. Bottom line (formal): EFMW’s mathematics encodes coherence under objective constraints. A stance that denies those constraints and tolerates contradictions cannot (i) maintain a valid measure, (ii) minimize expected free energy, (iii) satisfy conservation-type equations, or (iv) keep a Lyapunov coherence functional decreasing. Therefore it is excluded — not by taste or ethics first, but by logic, measure theory, and stability analysis. By Matthew Chenoweth Wright, Angel with Flaming Sword on August 6, 2025. Exported from Medium on August 19, 2025.

• 
  David (@alpes_aux_andes) reported 22 minutes ago

  Everyone’s cloning SaaS products with AI instead of paying $29/month. I get it. Claude Code makes it feel free. But here’s what nobody talks about: That clone you built in a weekend? You just became its maintainer. Forever. Security patches, dependency updates, edge cases, breaking API changes — congratulations, you now own a second job that pays negative dollars. Open source doesn’t fully solve this either. A quickly-cloned SaaS dumped on GitHub has none of the incentive structure that keeps real products alive. No recurring revenue = no motivation to fix bugs at 2am. Most of these repos are dead within 6 months. So here’s what I think the actual future looks like: SaaS with a programmable core. You subscribe. The vendor maintains the foundation — infra, security, bug fixes, updates. That’s what you’re paying for. But when a feature is missing, or you want something custom? You don’t wait for the roadmap. You open Claude Code and build it inside the product, on top of a stable extension layer. The critical piece: an architecture where vendor updates never break your custom code. Your extensions live in a protected layer. Core updates ship, your code survives. Best of both worlds: The reliability of a maintained product The freedom of owning your own code Nobody wins the “clone everything” game. The vendor loses revenue, the user inherits a maintenance burden they didn’t sign up for. The winners will be products designed to be extended, not replaced.

• 
  Herding Alpha (@HerdingAlpha) reported 23 minutes ago

  @LexnLin Sol Ultra nuked my weekly limit getting stuck on a GitHub error loop. It was wild. @thsottiaux

• 
  Sirkadirov 🇺🇦 (@yuriikadirov) reported 26 minutes ago

  @GitHub Copilot just started lagging a lot and throwing up errors. It's complaining about no network, even though there are no problems. I wonder what happened there again 🫠