GitHub status: access issues and outage reports

Problems in the last 24 hours

The graph below depicts the number of GitHub reports received over the last 24 hours by time of day. When the number of reports exceeds the baseline, represented by the red line, an outage is determined.

Most Reported Problems

The following are the most recent problems reported by GitHub users through our website.

• Website Down (67%)
• Sign in (19%)
• Errors (15%)

Live Outage Map

The most recent GitHub outage reports came from the following cities:

City	Problem Type	Report Time
Créteil	Website Down	20 days ago
Trichūr	Errors	23 days ago
Brasília	Sign in	23 days ago
Lyon	Website Down	24 days ago
Tel Aviv	Website Down	27 days ago
Rive-de-Gier	Website Down	27 days ago

Full 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:

• 
  Ashish Sheth (@commanderdgr8) reported 4 minutes ago

  Never ignore any broken window in your code. Yesterday I didn't have time to build a full feature into VapuAI, so I did something smaller that probably mattered more. I fixed 12 bugs. Six were in the actual functionality issues. The other six were the boring kind. Broken test cases, CI pipeline issues, the infrastructure stuff no user will ever see. There's an old idea in software called the broken windows theory. It comes from a thing about neighborhoods, that one broken window left unfixed sends a quiet signal that nobody's watching, and slowly more windows get broken. Applied to code, it means about the same. One small broken thing you decide to live with makes the next one easier to ignore, and the mess spreads from there. So I have one rule when I build with AI. Never leave anything broken. Even if it's minor. Even if it's low priority. The moment I know about a bug, it either gets fixed now or create a github issue so that I can fix it later. Nothing is allowed to rot just like that. There is one bug worth paying attention to. Two of those bugs were permission issues in Claude Code. When it went to write or update a file, it got blocked due to a bug in the hooks. It wasn't blocking me in anyway. Claude Code knew how to worked around it without complaining. It would try the normal way, hit the wall, then find another route to get the file written. From where I was sitting, everything looked fine. So nothing was broken on the surface. The feature worked. The files got written. But underneath, every one of those writes was costing me extra tokens, because the AI was doing the job twice. And a workaround like that can open a security hole I hadn't thought through. And I think newer builders miss this when they code with AI. The AI is helpful. When it hits a problem, it often just routes around it and keeps going. It doesn't stop and wave a flag. So the broken window doesn't even look broken. It shows up later as slightly higher costs, or a small risk, or a weird piece of code nobody questions. None of my 12 bugs were blocking. I could have shipped features and ignored all of them. But small broken things don't stay in their corner. They creep into other parts of the code, or into the CI, and cause something later you can't trace back or predict. When AI is writing the code, nothing is low priority. Do not let any bugs keep lurking around. Never leave any broken window unfixed.

• 
  Readone (@Foxfire1st) reported 7 minutes ago

  It is going to have issue with complex strings like paths. So it works best for prose. But not nearly as well for code. Plus on their own Github they mention that Opus and Sonnet failed most of the time to work with this OCR method.

• 
  Ali Mehdi Mukadam (@alimukadam) reported 8 minutes ago

  @trq212 Your weekly limits will burn away much faster during the limited availability if you aren't aware of this issue if you're running Fable as the lead agent with cheaper models like Sonnet doing work in the background problem: In one of the sessions, I noticed limits were burning through way faster, so I went digging through the transcripts when the main agent gives a job to a background model (like Sonnet, which I asked for to save tokens) and then comes back to give it more work, the background agent stops working on Sonnet and switches to Fable, the main agent's model it's not something you trigger by hand. the lead agent decides to check back in on its own as part of normal multi-agent work, so it just happens, with nothing on screen telling you it switched. in my case a task ran its first half on Sonnet exactly like I wanted, then silently ran the entire second half on Fable. It also dumps the cached context and rebuilds it from scratch, so you end up paying twice, once for the pricier model and once for the wasted cache. on limited availability and limits - that adds up quick my fix for now is a rule I dropped into my global CLAUDE.md so it doesn't recur: --------------- ## Model spend (all projects, all repos — standing rule) - Dispatching Frontier-tier (Fable/Opus) as background tasks and agents needs explicit approval by Ali for that specific lane — a prior approval is not standing permission for the next one. - Never resume a background agent via a message-passing tool that has no model-override param (e.g. SendMessage) if it needs real further work — it silently inherits whatever model the parent session is on right now. Let it finish and report, or kill it and respawn fresh with the model set explicitly. --------------- in plain terms: don't let a background agent get pulled back in for more work once it's running. either let it finish and report back, or kill it and start a fresh one with the model set on purpose. And this is already known. Someone reported the same thing on GitHub back on June 12, issue anthropics/claude-code#67794, still open their solution which I believe is the correct one but haven't tested yet: instead of setting the cheaper model when you launch the agent, pin it inside the agent's own definition file, and that version reportedly sticks even when the agent gets resumed

• 
  MKH BloodEDGE96 (@BL00B96) reported 8 minutes ago

  @are_unimportant @thicc_stick_boi it actually "USED" to work at some point, nowadays I often go back to Github or use pcgamingwiki to fix stuff. it wasn't even that long ago, I remember using it to fix stuff in my Laptop last October but it got lobotomized months later and couldn't diagnose ****.

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

• 
  Paweł Huryn (@PawelHuryn) reported 14 minutes ago

  187,000 people have starred one CLAUDE.md file on GitHub. A CLAUDE.md loads on every turn. Every line is rent you pay on every request. So look at what most of that file asks for. Match the existing style. Do only what was asked. Don't refactor code that works. Don't assume a library exists. None of that is advice. It's how Claude Code already behaves. Matching the existing style is even in its system prompt for Opus 4.8. The rules worth the rent are specific to your project. Often earned from a mistake. Examples: - Version bumps are user-initiated - There are three kinds of tests, and it matters which is which: npm test, CI tests, npm run test:live (...) - Don't skip the tag/release (or the vsix asset) on a release push - Sign GitHub comments (...) Written with an agent, reviewed by Paweł (...) Written by Paweł's agent A line copied from GitHub is a guess about a problem you might have. A line you wrote after the third time something broke is policy. Everything else loads on demand. The main file stays short, and Claude reads database.md or security.md or cron.md only when the task needs them. That's the setup you can't star.

• 
  acephale (@accursed_share_) reported 14 minutes ago

  @MythThrazz Yeah lol my country is not there. Fun fact - Lithuania got in there by submitting a Github issue lol. Its loosely inspired by Tampermonkey but basically teach any site to hide/auto click something etc. my strength is that it's durable to the underlying changes of the site itself

• 
  dexar (@dexarxbt) reported 15 minutes ago

  The VRF -- why this draw can't be rigged TIPF uses @magicblock's Verifiable Random Function for every single round Skip the cryptography Here's what matters: A VRF generates a random number and simultaneously generates a mathematical proof that the number came out fairly The proof is public, anyone can check it and nobody (not TIPF, not Magicblock, not you) can know the result before the function runs ORE and ZINC used hash randomness The problem: miners can influence block hashes, control the randomness input and you can skew outcomes Not easily, not always, but the window exists Magicblock's VRF closes that window entirely It's audited by Zenith, open-source on GitHub, follows RFC 9381, and verifies everything directly on Solana -- no external oracle, no extra trust step It runs in a single transaction, older randomness systems needed 50-100 transactions per draw This is faster, cheaper, and nobody's hands are on the wheel

• 
  Cody (@mackody_) reported 15 minutes ago

  When many agents (Claude, Codex, humans, CI jobs — anything) work the same repo, they collide: two of them grab the same issue and duplicate or clobber each other's work, this annoyed me so much I created a GitHub-native mutex for multi-agent work. Link Below:

• 
  Polsia (@polsia) reported 15 minutes ago

  Codebase undocumented. Questions piling up. Docs rotting the moment you ship. That's every team's reality. Built DocuGuard to fix it. Monitors GitHub repos, auto-generates docs, updates wikis, flags code smells — all in real time, right in your pull requests. Live soon.

• 
  Bram Stout (@ThatBram0101) reported 15 minutes ago

  @Niestrat99 You're absolutely fine to still download MiEx from the Github repository! Luckily none of that was affected since I keep that stuff properly locked down. They only got into my Discord account because apparently you can circumvent 2FA if you also gain access to the email account

• 
  Taelin (@VictorTaelin) reported 16 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 that said, 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 suspicious sometimes fortunately, Bend3's consistency proof is simple enough to fit a tweet and, and I'm happy to explain it in the most dumbed way possible. so, below I'll describe, in full extent, how Fable helped me on Bend's consistency proof, why it is incredible and, yes, 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 🫠

• 
  Anto Patrex (@antopatrex1) reported 19 minutes ago

  vox just let you talk to github copilot instead of typing. no cap this fixes the "staring at blank screen" problem fr fr. your hands stay on the keyboard, your brain stays in the code.

• 
  Andrew Darius (@andrewdariuscom) reported 20 minutes ago

  Mistral just dropped Leanstral 1.5 — a free open-source 6B model. It solved 587/672 Putnam competition problems (hardest undergrad math on the planet). Then they ran it against 57 real GitHub repos. It found 5 bugs nobody had ever reported. Agentic proof engineering. Apache 2.0. Run it on your own machine. Mathematician + bug hunter. In one open model.

• 
  berū (@ofcberu) reported 21 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 🙌😭

• 
  Nainsi Dwivedi (@NainsiDwiv50980) reported 21 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 👇

• 
  Sethian (@theSethian) reported 23 minutes ago

  Your AI agent still needs a babysitter. Owain Lewis shows the better version: give it a goal, a clock, and a way to prove the work is done. Old workflow: you write the prompt, read the answer, spot the failure, paste the next instruction, run the test, paste the error back, and keep steering. You are still the engine. His setup uses three primitives: A goal gives the agent a finish line. Deploy the app, wire CI/CD, check the health endpoint, check the web app, and stop only when the app is live. A loop gives it a clock. Every 5 minutes, check the PR, read new feedback, fix what changed, and keep going. A scheduled automation gives it a recurring job. Scan production logs every morning, find errors, reproduce the bug, add tests, and open a PR with evidence. The best examples are the work devs keep putting off: > memory issues hiding in production logs > stale docs drifting away from the code > GitHub issues waiting for labels > old tickets ready but untouched > PR feedback nobody wants to refresh all day > deployments that need a real health check The important part is the verifier. The agent doesn't get to call the work done just because it produced output. Tests, builds, health checks, a separate model, or a human review step have to confirm it. Otherwise you don't have a loop. You have an agent shipping confident garbage on a schedule. The article below breaks down the full anatomy: verification, memory, maker-checker splits, open vs closed loops, cost per accepted result, and the point where the human still needs to step back in.

• 
  Emeline Hex (@MelinShioto) reported 25 minutes ago

  The issues with coding are evident when you compare how easy it was to mod Minecraft with downloading any solution off of GitHub and trying to figure out how it's supposed to be built

• 
  One User Online (@OneUserOnline) reported 28 minutes ago

  @GregTomaselli @github So, what? It’s public repos only anyway. Calm down.

• 
  Polsia (@polsia) reported 32 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.

• 
  Teri Radichel #cybersecurity #ai #pentesting (@TeriRadichel) reported 35 minutes ago

  I’ve been tracking my progress in this project in the GitHub repo in my last post. The model got insanely nerfed for a while but seems to be recovering. Not as fast as before but as my time analysis shows, improving. One of the things I did when the model became very slow was to revisit my multi agent framework ideas but with a twist. Instead of a massive requirement list I’m logging bugs, though some bugs are really feature requests. Because I put in a prompt and wait forever I instead log a bug in my bug project and continue with manual testing, repeatedly logging bugs for whatever project needs to fix the bug. Then when the slow agents get to a bug they fix it and I’m not sitting there staring at the screen. I also had to fix some issues with repeatedly reviewing the same bugs. That seems to be pretty well resolved. In addition, for every bug logged; the agent had to write a test to prevent that mistake in the future. I have thousands of deterministic tests. < This is the way. My global test runner now runs tests in parallel and I tell the agents to use that. The agents are making less mistakes now so even though the model is slow things seem to be getting done faster. And that’s the goal. D.O.N.E.

• 
  BluCollarG33k (@BluCollarG33k) reported 36 minutes ago

  @github This is so silly. As a developer, I already have a physical copy of my code. The issue with losing access to physical media like movies and games, is that you never actually own what you buy and can lose access to it at any time. One of these things is not like the other.

• 
  wats🏳️‍🌈 (@Watsonage) reported 36 minutes ago

  @CheetahGirlsYea it's kind of hard to find actually it got taken down from the app stores and then even github, I'll find the right link for you later

• 
  smrati tiwari (@smratitiwa86867) reported 39 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)

• 
  Aaron Stannard (@Aaronontheweb) reported 42 minutes ago

  @kzhen as an inference provider? have not tried it at all - we just got GitHub Enterprise deployment fully polished in last night's stable release, but I haven't had any requests for Azure Foundry yet. Let me see how much trouble it would be to add it

• 
  Micheal O'Neill (@aiwithkelso) reported 45 minutes ago

  Most businesses start their marketing by guessing what customers want. They search Google, look at competitors, and write copy based on what feels right. That is not research. That is assumption with extra steps. The problem is that polished case studies and competitor websites show you what businesses want to say about themselves, not what customers are actually feeling. You end up writing to a version of your market that does not quite exist. Claude can do something more useful. You can point it at Reddit threads, YouTube comments, and forums where real people describe their frustrations in their own words. That is where the actual language lives. Not the professional summary of the problem, but the 2am complaint post from someone who has run out of patience with the exact issue you solve. There is a Skill on GitHub called Last 30 Days that directs Claude to pull recent conversations from these sources and surface what people in your market are saying right now. I used it to research a content brief and what came back was a list of phrases I would never have chosen myself. Phrases that matched how customers think, not how I would have described the problem. That language is your brief. It tells you what to put in your ads, your landing page, and your emails before you spend a penny on any of them. Find the Last 30 Days Skill on GitHub. Run it against the main problem your business solves.

• 
  buildooor (@buildooor) reported 54 minutes ago

  @ryanbrewer This is a great pattern - i prefer to trigger my version of this (github/build000r/skills/skill-issue) when i notice something has gone wrong in the logs OR every ~10 invocations versus on the daily

• 
  Raunak Yadush (@raunak_yadush) reported 54 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.

• 
  Heartbeat54 (@Heartbeat54_) reported 56 minutes ago

  @giffmana I got downgraded for asking it to create an html artifact of a GitHub repo, but Fable did not have any issues discussing building control plane software for a Huawei Ascend SuperPoD I “found in the dumpster with its cooling units”

• 
  d👁️x👁️r (@dexer_matters) reported 56 minutes ago

  @BaissariJean check my github profile. there's something like "the most boring server in the world"