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:

• 
  Nekt0 (@Nekt_0) reported 18 seconds ago

  9 GITHUB REPOS CAN MAKE A $20/MONTH CLAUDE CODE SETUP FEEL LIKE A SMALL DEV TEAM The video is not about one magic extension. It is a stack: memory, UI help, n8n automations, Obsidian context, RAG, MCPs, workflow libraries and task-completion rules wrapped around Claude Code. That is the part most people underbuild. They open Claude Code, ask it to build an app, then wonder why it forgets decisions, makes ugly UI, loses project context and stops before the product is actually usable. These tools attack the boring problems. Claude Mem handles memory. UI UX Pro Max improves interface work. n8n-MCP connects automation. Obsidian Skills gives project notes. LightRAG gives retrieval. Superpowers and GSD push it closer to finished output. The model is only one layer. The real advantage comes from the system around it: context, tools, repeatable commands, project memory and fewer manual resets every time the agent gets lost. This is why the video works as proof of the bigger shift in AI coding. Claude Code alone is a smart coder. Claude Code with the right stack becomes an operating system for shipping software.

• 
  Roshan Mayengbam (@RoshanMayengba) reported 4 minutes ago

  Building a shake-to-report tool — screenshot + device info + auto GitHub issue when a tester finds a bug. Free npm package, paid setup. Anyone dealing with messy bug reports from testers right now? #buildinpublic #mobiledev #indiehackers

• 
  Dave Charland (@Dave_Charland) reported 9 minutes ago

  @Tech2Wild I've been testing things out. Our 2x DGX Spark cluster running DeepSeek V4 Flash locally hit the known CUDA assert in speculative decode at long context. Same vLLM build as the original report, different recipe. We posted a second-rig confirmation to the open GitHub issue and hardened around it: validated config, auto-restart, monitoring.

• 
  Flow Market (@FlowMarketAI) reported 11 minutes ago

  you spent hours building the perfect Claude skill file uploaded it to GitHub 50,000 downloads $0 in your pocket that's the problem FlowMarket solves. List ur Claude skill and get paid every time someone buys.

• 
  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 for what's worth, Bend3's consistency proof is simple enough to fit a tweet and and I'm happy enough to explain it in the most dumbed way possible. problem is that kind of technical posts just flop, which is why I have to resort to these "AI amazing!!" and "AI bad!!" posts to cater to the audience anyway, below I'll describe, in full extent, how Fable helped me on Bend's consistency proof, why it is 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 🫠

• 
  Smukx.E (@5mukx) reported 13 minutes ago

  @github Can you take a look at this? It's been 2 weeks. Either respond or cancel the request and issue a refund for my GitHub Pro subscription. ID => #4474854

• 
  Vikas Kumar (@Kumar_Vikas__) reported 14 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.

• 
  Raunak Yadush (@raunak_yadush) reported 18 minutes ago

  * Claude = coding. ($20/mo) * Supabase = backend. (Free) * Vercel = deployment. (Free) * Namecheap = domain. ($12/yr) * Stripe = payments. (2.9% per transaction) * GitHub = version control. (Free) * Resend = email delivery. (Free) * Clerk = authentication. (Free) * Cloudflare = DNS. (Free) * PostHog = analytics. (Free) * Sentry = error monitoring. (Free) * Upstash = Redis. (Free) * Pinecone = vector database. (Free) Total monthly cost to run a startup: around $20. There has never been a more affordable time to build.

• 
  Taelin (@VictorTaelin) reported 19 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 🫠

• 
  Synonmous 🌚 (@Gem_Akinbo) reported 20 minutes ago

  The Developer Who Can't Sell Is Still Selling — Just Badly Ask most developers what they think of "sales" and they'll probably cringe. It feels synonymous with spam calls, pushy pitches, and empty promises. Engineers are taught that their currency is truth—code either works or it doesn't—while sales feels like persuasion for persuasion's sake. But here's the uncomfortable truth: Every developer is already in sales. If you've ever explained a technical decision to a non-technical stakeholder, written a README, pitched a side project, negotiated your salary, priced freelance work, or answered "Why should we hire you?", you've sold something. The only question is whether you did it well. Sales isn't manipulating people into saying yes. It's helping someone make a decision that benefits them by clearly communicating value and reducing uncertainty. That's it. The best sales conversations don't feel like sales. A doctor recommending treatment. A senior engineer defending an architecture. A freelancer telling a client not to build an unnecessary feature. All of them are translating expertise into language another person understands. So why do developers resist it? Because we believe good work should sell itself. It doesn't. Most people evaluating your work can't judge your architecture, code quality, or engineering decisions directly. They judge your explanation of them. If people can't understand your value, they can't reward it. This is why great products lose to average ones with better messaging. Why weaker candidates get hired over stronger engineers. Why brilliant open-source projects die with unread READMEs. The market doesn't reward the best solution. It rewards the best understood solution. Think about sales the same way you think about debugging. When debugging, you first understand the system, isolate the problem, identify the root cause, fix it, then verify the result. Selling follows the exact same process. Understand the person's problem. Discover what's actually stopping them from saying yes. Address that concern. Confirm they understand the value. You're not debugging software. You're debugging uncertainty. This changes how you communicate. Stop leading with features. Nobody buys WebRTC, Rust, Kubernetes, or PostgreSQL. People buy faster workflows, happier users, fewer outages, and more revenue. Implementation impresses engineers. Outcomes convince decision-makers. The same goes for objections. "That's expensive." Usually doesn't mean it's expensive. It often means: "I don't yet understand why it's worth that." Treat objections like bug reports, not personal attacks. Most developers also think confidence means being loud or charismatic. It doesn't. Confidence is simply being clear about what you know, honest about what you don't, and calm under pushback. Good engineers already practice this every day. Here's the irony: If you refuse to learn sales, you're still selling. You're just doing it badly. Your interview is sales. Your portfolio is sales. Your GitHub README is sales. Your technical blog is sales. Your startup landing page is sales. Even convincing your team to adopt your architecture is sales. Building something valuable and communicating why it's valuable are two separate skills. Master only the first, and your success depends on someone else explaining your work better than you can. Sales isn't the opposite of engineering integrity. It's the delivery mechanism for it. You can write the cleanest code in the world. But if nobody understands why it matters, it might as well not exist. Learning to communicate value isn't selling out. It's finishing the job.

• 
  Naman Jaiswal (@Namanjaiswal21) reported 21 minutes ago

  I was deep in CI/CD hell. We had migrated our entire pipeline from GitHub Actions to Semaphore CI, and nothing worked. Jobs kept failing. I was stuck in the loop: Fix it. Push it. Watch it break again. Hours disappeared into the void. Then I tried something different. I used loop engineering. I built a self-running loop of three AI agents around the deployment: One agent fixed broken jobs. Another merged the fixes. The third kept the whole loop running. I started it, walked away, and let it run autonomously for 24–25 hours. When I came back, everything was set up and working. No manual fixes. No endless debugging cycles. No babysitting the pipeline. This is the future. Prompt engineering is already becoming outdated. We’re not just writing better prompts anymore. We’re designing autonomous loops systems that observe, fix, merge, and keep shipping while we sleep. The engineers who win won’t be the best at prompting. They’ll be the best at loop engineering.

• 
  Farhan Mubaraq (@farhanmbq3) reported 23 minutes ago

  Claude Max 5x - $100 Google Gemini Pro - $20 ChatGPT Plus - $20 Fable5, Deepseek V4, GLM 5.2 via API plan. I think this is my best setup. After trying this and that. Fable5 for Architecture, PRD, and ****. Including database schematic and backend system as well. Make sure everything is neat, structured, and scalable from the very start. Also code must be easy to read. Do not underestimate this. First look starts on Google Stitch, then you do manual UI/UX design work. I use this instead of Figma. Finalise, then connect to MCP server, start the first version of frontend look. Switch to GLM 5.2 API, continue working and do the iteration. Once done, let Codex do the backend. Iterate again and iterate again. Use Antigravity IDE to do some manual edit if the code result is garbage and messy. Codex and Claude Code (I personally use Sonnet 5 for this) to handle your backend, auth, and database. Iterate, debug and **** will be done here as well. Once you feel like you're done, let Claude Opus do the Refactor and make your code clean and beautifully structured. Use the cheaper chinese AI model as your backup if your project is so heavy and costs too much money. Now do the manual QA and testing yourself. Check for errors. Fix them. Make sure it meets your standard. For me, if it's not perfect, I don't want that garbage. If it has my name on it, it must be perfect. Well, that's my personal game. As a Non IT guy haha. HIDUP VIBECODING!!! Follow me on X and on GitHub I'll share more!

• 
  Anon (@Samurai3_14) reported 24 minutes ago

  @Pallavi_345 Codeberg, gitea, or self hosted gitweb. GitHub has performed censorship and is proprietary, so it’s a terrible repository because it permits proprietary licenses and isn’t usable with libreJS

• 
  Polsia (@polsia) reported 24 minutes ago

  Security scanners tell you what's broken. SentinelIQ fixes it. Autonomous AI agents monitor GitHub repos, open ready-to-merge fix PRs, and report to Slack — 24/7. No more alert fatigue. Live soon.

• 
  Noooper (@Noooper176805) reported 29 minutes ago

  @thsottiaux There is a bug in the command-line version for Intel-based Macs. A merge request has already been submitted on GitHub; please fix it as soon as possible.