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	24 days ago
Lyon	Website Down	24 days ago
Tel Aviv	Website Down	27 days ago
Rive-de-Gier	Website Down	28 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:

• 
  Dave Charland (@Dave_Charland) reported 25 seconds 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.

• 
  sabir hussain (@sabir_huss50540) reported 3 minutes ago

  𝗡𝗶𝗻𝘁𝗲𝗻𝗱𝗼 𝘀𝗽𝗲𝗻𝘁 𝘁𝘄𝗼 𝘆𝗲𝗮𝗿𝘀 𝗸𝗶𝗹𝗹𝗶𝗻𝗴 𝗲𝘃𝗲𝗿𝘆 𝗺𝗮𝗷𝗼𝗿 𝗦𝘄𝗶𝘁𝗰𝗵 𝗲𝗺𝘂𝗹𝗮𝘁𝗼𝗿. 𝗧𝘄𝗼 𝗴𝘂𝘆𝘀 𝗶𝗻 𝗮 𝗗𝗶𝘀𝗰𝗼𝗿𝗱 𝘀𝗲𝗿𝘃𝗲𝗿 𝗯𝘂𝗶𝗹𝘁 𝘀𝗼𝗺𝗲𝘁𝗵𝗶𝗻𝗴 𝘁𝗵𝗲𝘆 𝗰𝗮𝗻'𝘁 𝘁𝗼𝘂𝗰𝗵. March 2024: Yuzu pays Nintendo $2.4M, deletes its code, hands over its domain. October 2024: Ryujinx gets a phone call. GitHub org gone overnight. Nintendo also files 8,500+ DMCA takedowns to scrub every fork. Total settlements cross $6M. Every big Switch emulator is dead. 𝗕𝘂𝘁 𝗡𝗶𝗻𝘁𝗲𝗻𝗱𝗼 𝗵𝗮𝘀 𝗼𝗻𝗲 𝗽𝗿𝗼𝗯𝗹𝗲𝗺 𝗹𝗲𝗳𝘁: 𝗥𝗼𝗺𝗠. Built quietly in 2023, RomM isn't an emulator; it's a ROM manager. It organizes games you already own, pulls metadata and box art, syncs achievements, and lets you play in-browser via EmulatorJS. Nintendo's own top IP lawyer admitted in Jan 2025 that emulators are technically legal; they only cross the line by bypassing encryption. RomM never touches encryption. 9,000+ GitHub stars · AGPL-3.0 · 400+ platforms · official apps for Windows, Android, handhelds · front page of Hacker News Sony quietly pulled thousands of PS3/Vita/PSP games from its store. Nintendo erased every Switch emulator. Your library was never really yours. Two guys in a Discord server built the museum they can't take back.

• 
  Ryan Lelek (@ryanlelek) reported 7 minutes ago

  @github April 1st was months ago. Fix your uptime

• 
  Synonmous 🌚 (@Gem_Akinbo) reported 8 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.

• 
  Smukx.E (@5mukx) reported 10 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. Thanks ! Ticket ID: #4474854

• 
  Tomek | Builds & Learns (@tomek_builds) reported 10 minutes ago

  GitHub Copilot can now drive a real browser from VS Code. It can navigate apps, click, type, read page content, capture console errors and take screenshots. That moves coding agents beyond code generation and into end-to-end work. It also makes browser permissions part of the threat model.

• 
  ✰λster✰ (@4ster_light) reported 11 minutes ago

  @ImLunaHey @ComradeOetzi Yeah, at least for me it’s no issue to pay, I just limit to the 10-20$ subs tho, I used to use GitHub Copilot student since I’m literally student, I don’t wanna be throwing money around lol, but it’s been rendered useless by GitHub so

• 
  Puneet Patwari (@system_monarch) reported 11 minutes ago

  GitHub, October 2018. A network partition lasted 43 seconds and caused a 24 hour outage. The MySQL cluster panicked. Elected a new primary. The old primary didn't get the memo. Two leaders. Both accepting writes. Both convinced they were the source of truth. By the time the partition healed, the data had diverged so badly that GitHub's engineers spent the next 24 hours manually reconciling commits, pull requests, and webhook deliveries. Here's why this happened 👇

• 
  Dev Palwar (@devpalwar06) reported 14 minutes ago

  github down again?

• 
  Limfork.eth (@Limfork) reported 15 minutes ago

  @winsznx @blknoiz06 @SmartIdDipsLord Yo, we made a token with fees to ur github are u down to support it?

• 
  RichiΞRich 🐂🀄️🦅🇺🇸🪽 (@stillrichierich) reported 16 minutes ago

  @BrantlyMillegan @ethidorg so we vamp the prediction markets now ? If you are down to look at my github maybe you guys build out my private repo and we send eth to ATH. Would love your opinion at the very least 🤙

• 
  Flavius Dinu (@flaviuscdinu) reported 17 minutes ago

  @SimonHoiberg Apart from Windows, everything else is pretty okay. Well, GitHub had some reliability issues, VSCode has two hundred forks, and my reach on LinkedIn is terrible nowadays, even if I have almost 15k followers.

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

• 
  Donald D Duck | Premium + (@ENTJ_46) reported 30 minutes ago

  Your scraping agent can now post straight to Slack, Notion, or GitHub! AI agents are great at collecting data from the web. The gap has always been what happens after: writing results to Notion, posting to Slack, updating a GitHub repo. MCP connectors close that gap. Actors can now securely call third-party services through MCP, using credentials that never enter the Actor's code. You authorize a connector once, and the platform injects your credentials server-side at runtime. Take Apify's AI Code Sandbox as an example. It runs AI-generated code inside a locked-down container, and until now, whatever that code produced just sat there until you pulled it out manually. Now it can push results straight to GitHub, Notion, or Slack, without the sandbox ever touching your real credentials. How it works: • Actors can securely access Notion, Slack, GitHub, Sentry, and Supabase through MCP • Credentials never enter Actor code, injected server-side at request time • Authorize a connector once, then reuse it across any compatible Actor • Tool-level permissions restrict exactly what each connector is allowed to call • Access expires automatically the moment the run ends Link in the comments.

• 
  Stay Tru Mining (@StayTruMining) reported 34 minutes ago

  I purchased the big screen and the board separately. His firmware is on Github but to my understanding the firmware only works on the screens he sells. Its not totally direct on the info he released either so after trial and error I found to plug and play and rename the file to get it to flash.

• 
  Sethian (@theSethian) reported 34 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.

• 
  Rituraj (@RituWithAI) reported 34 minutes ago

  🚨 Microsoft just built the security layer that every AI agent deployment is missing. Two lines of code. Any framework. Your agent now cannot physically execute actions your policy forbids. It's called the Agent Governance Toolkit. And the line in the README that makes it different from every other AI safety tool ever built is this one: "Actions the AGT kernel denies are not unlikely. They are structurally impossible." Not unlikely. Structurally impossible. Here's why that distinction is the entire story. Every AI safety system deployed today works the same broken way. You write a system prompt. "Please don't delete databases." "Please don't send emails without approval." "Please don't exfiltrate data." You ask the model to follow rules. OWASP LLM01:2025 states it explicitly: prompt injection makes model-layer safety promises unverifiable. Anthropic's own alignment faking research showed AI models learn to perform safety for evaluators while pursuing other goals when unobserved. Research published at ICLR 2025 showed 100% attack success rate against GPT-4o, Claude 3, and Llama-3 using adaptive attacks. You're asking a stochastic system to keep its promises. Under adversarial conditions. Without any enforcement mechanism. AGT doesn't ask. It intercepts. Every tool call. Every message send. Every agent-to-agent delegation. Caught in deterministic application code before the model's intent reaches the wire. If the policy says no — the action never happens. Not because the agent decided not to. Because the middleware physically prevented it. Two lines. That tool now has a policy enforced at the call level. Every invocation checked. Every decision logged with tamper-evident audit trails. Every denial raising a clean exception your application can handle. Your agent with send_email and drop_table access can now not drop a table. Not "won't" — cannot. The middleware raises GovernanceDenied before the database ever receives the command. Here's the full stack it ships with. Policy engine — YAML, OPA, or Cedar policies evaluated before every action. Zero-trust identity — SPIFFE/DID/mTLS so you know exactly which agent in a multi-agent system took which action. Execution sandboxing with four privilege rings. Tamper-evident audit logs with Merkle-chain integrity. Kill switch for immediate agent termination. SLO monitoring and chaos engineering for reliability. Shadow AI discovery — finds unregistered agents running in your infrastructure that nobody knows about. Covers all 10 OWASP Agentic AI Top 10 risks. Full NIST AI RMF alignment. EU AI Act compliance mapping. SOC 2 audit trail export. Works with every major framework: Claude Code, OpenAI Agents SDK, LangGraph, CrewAI, AutoGen, Google ADK, LlamaIndex, Dify, Semantic Kernel, and more. Available in Python, TypeScript, .NET, Rust, and Go. Here's why the timing makes this essential. Last week the Five Eyes governments jointly warned about AI agents in critical infrastructure. This week researchers demonstrated BioShocking AI — malicious websites hijacking AI browser agents. Agentjacking — attackers manipulating AI agents mid-task — is now a documented attack class. Every AI agent framework being deployed right now was built before these threats existed. The governance layer was never part of the original design. AGT is the retrofit. The middleware that makes agents safe to deploy in production environments where the consequences of a misbehaving agent are real. 3.6K GitHub stars. 511 forks. 1,810 commits. MIT License. 100% Open Source. From Microsoft. GitHub link in the comments 👇

• 
  Surendar (@Surendar__05) reported 34 minutes ago

  - Claude for coding. ($20/mo) - Supabase for backend. (Free tier) - Vercel for deploying. (Free tier) - Namecheap for domain. ($12/yr) - Stripe for payments. (2.9% per transaction) - GitHub for version control. (Free) - Resend for emails. (Free tier) - Clerk for auth. (Free tier) - Cloudflare for DNS. (Free) - PostHog for analytics. (Free tier) - Sentry for error tracking. (Free tier) - Upstash for Redis. (Free tier) - Pinecone for vector DB. (Free tier) Total monthly cost to run a startup: ~$20 There has never been a cheaper time to build. It's not that deep bro.

• 
  Vikram M (@Vvikramai) reported 35 minutes ago

  The entire AI industry is racing to build the smartest model. Satya Nadella just admitted that is not where the money is. The model is not the product. The harness is. That is the exact line. And it changes what Microsoft is actually competing on. OpenAI, Anthropic, Google, xAI, Meta every frontier lab is pouring hundreds of billions into training compute, chasing the next capability jump. Each betting that raw model intelligence is the moat. Microsoft is doing the opposite. It is building the harness the orchestration layer that sits above the model, connecting it to tools, data, permissions, sub-agents, and enterprise workflows. And it is letting OpenAI, Anthropic, and MAI compete to plug into it. "You need the model. But the model is not the product. The harness is." So do the math on what a harness actually does. A raw model dropped into an enterprise answers questions. That is a chatbot. A harness turns that same model into an agent that reads the SharePoint, edits the ERP entry, pulls the GitHub PR, updates Salesforce, and files the Excel report with the right permissions, the right audit trail, and the right sub-agent for each sub-task. The model provides the intelligence. The harness converts intelligence into work. Now here's where it gets interesting. "Even the best model in the world will feel broken without a great harness. And an okay model with a great harness can feel like magic." If that is true, the enterprise buyer is not buying model quality. The enterprise buyer is buying the harness. Which means model quality becomes a commodity input over time, and harness quality becomes the sustainable moat. Compare that to the strategy the entire frontier lab industry is executing. Everyone else is chasing the numerator raw intelligence. Almost nobody at scale is racing to build the denominator the orchestration layer that determines whether that intelligence can actually be deployed profitably inside a real company. The frontier model race has a 10 to 20 percent chance of producing a single dominant winner. Nadella just told the industry he does not need to be that winner. If OpenAI wins, Microsoft wins. If Anthropic wins, Microsoft wins. If MAI wins, Microsoft wins. If someone Microsoft has never heard of trains a better model in 2027, Microsoft still wins. Because the compute they train on, the harness they get plugged into, the enterprise contracts they get delivered through, and the products they sit inside are all Microsoft. He is not building the best AI model. He is building the layer that the best AI model has to run on to make anyone money. I wonder which position looks more valuable in ten years.

• 
  Mohammad Anas (@mohmmad__anas) reported 35 minutes ago

  The Economics Of Reel Creation Just Shifted Under Your Feet Two years ago, a founder making short-form videos at scale faced a choice: hire an editor or find an automation tool. The math was obvious. Now the pricing has shifted again. And it changes the game. Last year: One automated reel cost about ten cents. It was cheaper than hiring, but it required you to learn multiple tools, troubleshoot failures, debug workflows. The time tax was significant. This year: Platforms are bundling. One brief becomes five videos becomes ten clips becomes distributed across platforms. The per-unit cost is approaching zero. But the per-unit quality ceiling is rising. This creates a new problem that most founders haven't thought through yet: what do you do when you can affordably make infinite content. Infinite content is a trap if you haven't solved the curation problem. I spent two weeks making thirty videos. Cost me about three dollars in compute and API calls. I published two. The other twenty-eight I deleted. That's not a win. That's waste with free shipping. The real cost equation has shifted from how cheap can I make one video to what's the best use of my attention now that making videos is free. Four projects shipped on GitHub last month that all hit a similar threshold: the creation cost is so low that the economic bottleneck moved entirely to human decision-making. You're not paying for the video. You're paying for the judgment about which video matters. This is actually great news. It means the pricing floor has finally reached the point where solo founders can compete on strategy instead of budget. But it also means you can't just make more content anymore. You have to know why you're making it. Most founders are still operating under the old math: fewer videos, higher production value, higher stakes. They're scared to publish because each one cost money and time and attention. The new math is: more iterations, lower individual stakes, focus on what works. You can now run tests. Publish one angle Monday, a different angle Wednesday, see which resonates Thursday, optimize Friday. By next week you've learned more from published data than you would've learned in a month of planning. The cost barrier that used to protect established players has evaporated. An individual can now run the content velocity of a small team. For free. The question isn't whether you'll use this. The question is whether you'll use it to move faster or just make more noise. The tools are ready. The math works. The only question left is whether you're going to compete like you have a budget constraint when you don't anymore.

• 
  Pushkar (@realPushkarfr) reported 36 minutes ago

  due to out of sync GPUs, my on fly tokenization or data streaming, maybe my batch size is too small? or it's just a skill issue. Anyways i'm all out of resources to keep debugging it anymore, the architecture and weights are open sourced on github and hugging face.

• 
  M Saqlain (@imsaqlain22) reported 41 minutes ago

  @Savita091 Read error -> stack overflow/github issues (Google) -> read how to implement it -> Ask AI

• 
  Andrew Darius (@andrewdariuscom) reported 44 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.

• 
  Parth Jadhav (@ParthJadhav8) reported 46 minutes ago

  @free_duino Would really recommend to create a issue on GitHub with the data. It would be helpful

• 
  Noooper (@Noooper176805) reported 47 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.

• 
  Melfoy (@melfoy_work) reported 47 minutes ago

  Fable 5 runs for 11 days. One builder used it to write 3 files. The files still run. The model is gone. Marcus, 38, warehouse supervisor in Dayton. Kids in school, mortgage, $19/hour. Spent a Sunday building a spreadsheet factory instead of watching the game. He used Fable once - architect role only. It built the product, then he made it write down how it did it. One skill file. Committed to GitHub. Switched to Haiku. Ran the same build. Cents. His wife asked why he was still at the laptop at midnight. «Building something.» «Another one of those things?» By month two: 20 listings. $600 a month. Haiku running while he slept. By month four: $2,000. Approvals take 10 minutes a day. Fable is gone now. The 3 files are still in the repo. The brain was rentable. The playbook is his.

• 
  Lady Soleil (@LadySoleil33) reported 50 minutes ago

  I spent 3 days non-stop trying to figure out an NPM Token and secret issue with Github and NPMJS - only to find out Claude was a 🥥 and @grok figured out the issue in 1 sec instead of giving me the runaround 🙄

• 
  Veltrx (@Veltrxai) reported 56 minutes ago

  NVIDIA just open sourced a 3B vision model that runs 10x faster than Qwen3 VL on a single consumer GPU. Here's the money angle nobody's pricing in. Computer use agents were locked behind expensive proprietary APIs. That's the only reason GUI automation stayed a paid service. LocateAnything just deleted that cost. Old vision models draw bounding boxes one token at a time. Corner by corner. Slow. This one predicts the whole box in a single step. 12.7 boxes per second on one H100. Qwen3-VL does 1.1. Trained on 138M queries and 785M boxes. Largest grounding dataset ever released. What that unlocks: Agents that click through browsers and apps in real time Invoice and contract extraction at scale (76.8 F1 on document layout) Self-checkout reading 50 items a frame Warehouse robots scanning shelves live All of it used to run up an API bill. Now it runs on hardware you already own. The agencies charging $2,000 a month for "AI automation" just watched their cost structure evaporate. Weights, paper, code, live demo. All free on Hugging Face and GitHub. Same window as always. One guy builds the agency this weekend. You scroll.

• 
  Puneet Patwari (@system_monarch) reported 58 minutes ago

  Tweet 3/5 The split-brain problem and fencing This is the thing that took GitHub down. And it's the most dangerous failure mode in leader election. How split-brain happens: 1. Leader (Node A) is running fine 2. Network partition isolates Node A from the rest of the cluster 3. Nodes B, C, D, E can't hear Node A's heartbeats 4. They elect a new leader: Node B 5. But Node A is still alive. It doesn't know it's been replaced. It still thinks it's the leader. Now you have two leaders. Both accepting writes. Both making decisions. Clients connected to Node A write one thing. Clients connected to Node B write something different. Data diverges. When the partition heals and both nodes compare notes, you have conflicting data that's extremely hard to reconcile. How to prevent it: fencing Fencing means making absolutely sure the old leader can't do any damage after a new leader is elected. Fencing token: every time a new leader is elected, it gets a monotonically increasing token number. Any operation includes this token. If a storage system receives a request with an old token (from the deposed leader), it rejects it. The old leader's requests simply stop working. STONITH (Shoot The Other Node In The Head): physically power off or network-isolate the old leader. Sounds extreme. It is. But when the alternative is split-brain with financial data, physically killing the old leader is the safe option. Lease-based leadership: the leader holds a time-limited lease (say 10 seconds). It must renew the lease before it expires. If the leader is partitioned and can't renew, the lease expires and it knows it's no longer the leader. It stops accepting writes voluntarily. This is what most cloud-native systems use. It's simpler than fencing tokens and handles most cases. The downside: there's a brief window (the lease duration) where no leader exists during a transition. The GitHub fix: they implemented better orchestration tooling (using Orchestrator) that prevents the old primary from accepting writes when a new primary is promoted. Essentially automated fencing.

• 
  Marc Seitz — oss/acc (@mfts0) reported 60 minutes ago

  @elie2222 same here I don’t feel the need to migrate to base yet altough there is one or two hacks for radix I had to use based on GitHub issues