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	24 days ago
Brasília	Sign in	24 days ago
Lyon	Website Down	24 days ago
Tel Aviv	Website Down	28 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:

• 
  Quentin Rider (@q10rider) reported 42 seconds ago

  @thsottiaux I feel like it frequently has problems with MCP disconnects. It will forget how to access GitHub and or Linear. I do not have these issues with Claude. Also I feel yolo could be better, -dangerously-skip-permissions in Claude feels slightly better.

• 
  Marc Seitz — oss/acc (@mfts0) reported 5 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

• 
  Heartbeat54 (@Heartbeat54_) reported 7 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”

• 
  Murray Bauman (@MurrayBauman3) reported 8 minutes ago

  "Open Source Will Win AI" Gets One Thing Wrong The thesis sounds persuasive because it borrows the moral authority of Linux and the open web. But AI is not traditional software. Open source won software because it could harness the idle cognition of millions of humans. An engineer with a laptop could fix bugs, write modules, improve libraries — and meaningfully move the project forward. Linux got better because distributed human intelligence compounded against corporate R&D. AI breaks that engine - a frontier model is not mainly code, it is compute, data, training infrastructure, post-training, evals, and — increasingly — better models building the next models. The marginal GitHub contributor cannot casually improve the base model the way they can improve Postgres. They can fine-tune it. Quantize it. Deploy it. Build tools around it. Useful. But not the same as training the frontier. Open-source software was a production model. Open-weight AI is a distribution model. That distinction changes everything. Yes, cheapness drives progress. Cheap aluminum, cheap electricity, cheap computation — all unlocked industries. But it does not follow that open source owns the frontier. Cheapness commoditizes yesterday's intelligence while the frontier keeps moving behind closed doors. If a closed lab has the best model internally months before the public sees anything close — and uses it to write code, generate synthetic data, and accelerate its own research — then the leader isn't standing still while open models catch up. The leader is using tomorrow's model to build the day-after-tomorrow's model. "Outputs leak" isn't enough. Leakage lets the ecosystem imitate yesterday. It doesn't stop the frontier from compounding. This is where the Linux analogy dies. In software, open source had a real production advantage: distributed human talent. In AI, the decisive input is concentrated machine intelligence plus massive compute. That looks less like Linux. It looks like Formula 1, elite quant trading, or semiconductor fabs. Open models will still matter enormously. They'll crush prices, prevent monopoly rents in the middle layer, enable self-hosting and sovereignty, and make "good enough" intelligence abundant. But that is different from winning. The likely outcome is a barbell: Closed frontier labs own the advancing edge Open models commoditize the usable middle Infrastructure providers sell the scarce picks and shovels Application companies capture value where intelligence meets workflow, data, and distribution "Expensive intelligence builds monuments. Cheap intelligence builds civilizations." Fine. But the conclusion isn't "therefore open source wins." The conclusion is: cheap intelligence transforms civilization, while the profit pools sit elsewhere. Many open labs will train expensive models, release them into a price war, win temporary developer attention — and discover that attention doesn't pay the GPU bill. The durable players will have another monetization engine: cloud, chips, distribution, enterprise workflows, proprietary data, or closed frontier access. Open AI may win adoption while open AI companies lose economics. We've seen this movie: Linux won — AWS captured the value. Android won — Google captured the toll roads. Open protocols built the internet — platforms captured the profits. So yes: drive down the cost of intelligence. Use open models where they're good enough. Fight lock-in. But don't confuse commoditization with value capture. The real question is not "will open source win AI?" It is: does open catch up faster than closed frontier labs compound? If yes, open dominates. If no, open models become the cheap labor layer while closed labs keep the genius layer. Right now the evidence points to a split: open commoditizes yesterday's frontier; closed labs own tomorrow's.

• 
  Tariq (@tariqvibes) reported 9 minutes ago

  @dsallentess @bookmarksreads huge w even if my reading comprehension stops at github issues

• 
  Jyoti Meena (@GsJyotiM) reported 10 minutes ago

  found a tool that basically makes your claude code sessions unlimited. it's called 9Router and it's trending on github right now. it sits between claude code and more than 60 different ai providers, all through one local endpoint. that's the entire setup. here's what actually happens once it's running. when your claude code quota runs out, instead of stopping, it quietly switches to a cheaper model. when that runs out too, it drops down to a completely free one. you don't notice any of this happening. your session just keeps going like nothing changed. it's not locked to claude code either. works the same way with cursor, codex, cline, copilot, pretty much your whole coding stack through one setup. it also compresses tokens before they even reach the model, saving anywhere from 20 to 40% per request, same answers, just fewer tokens spent getting there. and it shows you a live dashboard of exactly how much quota you have left on each provider, so you're not finding out you're rate limited the hard way. the part that actually surprised me is the free tier stacking underneath all this. kiro gives unlimited claude sonnet 4.5. iflow gives unlimited kimi, glm, and minimax. qwen gives unlimited qwen 3 coder. all free, all running quietly behind the same local url. setup is genuinely two steps. install it, point your tool at localhost:20128. that's it. if you've ever hit a rate limit at 2am mid task and just had to stop, this is the difference between stopping and not even noticing.

• 
  Smcleod (@acemac378) reported 12 minutes ago

  Founders: Positioning or Provenance? Pitch Deck or GitHub Repo? Marketing an Idea or a Product? Challenge or Opportunity? I chose provenance. Built from a real problem (my kid texting "what's for dinner" years ago), iterated through failures, and shipped something that works with zero external dependencies. GitHub + live product + simple pricing ("3 cents at the gate") instead of hype. The grit is part of the product. Every challenge became an opportunity. What about you?

• 
  Flavius Dinu (@flaviuscdinu) reported 18 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.

• 
  Muhammad Ayan (@socialwithaayan) reported 18 minutes ago

  A single 𝘀𝗸𝗶𝗹𝗹 𝗳𝗶𝗹𝗲 just hit 83,700 stars on GitHub 🤯 It fixes AI agents' worst communication habit using one principle: shut up and code. Every AI coding agent is trained to sound helpful. Full sentences. Explanations. Acknowledgments. "I'll do that for you." "Here's what I'm going to do." "Let me know if you need anything else." You pay for every one of those words. caveman is a single skill file that strips all of it out: → Telegram style. Drop the articles and filler. "creating file" instead of "I'll now create the file for you." → Keep what matters. Code, commands, file paths, function names, and error messages stay character-for-character exact. → Cut what doesn't. Every hedge, every polite acknowledgment, every restatement gets deleted before it costs you a token. → Toggle anytime. Say "caveman" to turn on, "normal" to turn off. Works mid-conversation. Drop the file in your project root and Claude Code follows it from the first message. One file. Zero dependencies. No setup. And best part, 100% open source.

• 
  Mohammad Anas (@mohmmad__anas) reported 18 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.

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

• 
  Dickson (@disouzam_bh) reported 21 minutes ago

  Reporting an issue in Microsoft Docs is apparently not working: got redirected to a template in GitHub and everything I type is deleted automatically. Any hint, @shanselman , @davidfowl ?

• 
  M Saqlain (@imsaqlain22) reported 29 minutes ago

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

• 
  Danny 🏴󠁧󠁢󠁷󠁬󠁳󠁿 (@danjones) reported 29 minutes ago

  @stolinski @v_sapronov @rpunkfu Again, you said it yourself. It's cheap. Completely get why you would get hyped over it. But there's much deeper issues within GitHub, this is simply PR/ Marketing to mask over that. Feel free to tell me otherwise.

• 
  voiceclick.ai (@voiceclickai) reported 30 minutes ago

  OpenClaw hit 100k GitHub issues in 222 days. Most UK businesses haven't heard of it yet. That's actually a massive opportunity.

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

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

• 
  Shrikant Joshi (@shrikant@noc.social) (@shrikant) reported 40 minutes ago

  @Techjunkie_Aman CAVEAT EMPTOR! Hasn't been updated in over a year. Developer team is mostly working on Zima OS. Issues piling up on GitHub. Currently held together by wisps of hope and (LOTS of) duct tape. CasaOS is superb for beginners but will likely die out due to lack of attention.

• 
  Damir Wallener 🇭🇷🇨🇦…🚀🛰️…⚽️🥁…👨‍🍳 (@DamirWallener) reported 41 minutes ago

  @l3d1c I’m not a conspiracy guy. I am a sensor guy. Realtime sensor math is *hard*. Something is wrong with the system. This will happen again…and the games are only getting higher profile… They need to release the sensor feeds and put the processing code up on GitHub. Transparency is the only way to fix this.

• 
  Smukx.E (@5mukx) reported 44 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

• 
  Rituraj (@RituWithAI) reported 47 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 👇

• 
  FHILY👑 (@Oluwaphilemon1) reported 51 minutes ago

  JUST IN: Claude Fable 5 and GPT-5.6 are cooked. A Netflix engineer just open-sourced a tool that can cut LLM token usage by up to 95% - without changing your code 😳 Headroom, built by Netflix engineer Tejas Chopra, sits in front of tools like Claude, Cursor, Codex, and other agents as a local proxy. Before your payload hits the model, Headroom compresses the context. Not by blindly chopping it down. By using specialized compressors for different payloads: → SmartCrusher for JSON → AST-based compression for code → Tool-output and log compression → Local reversible storage of originals → Agent wrappers that make it usable without rewriting your app The headline claim is 60–95% fewer input tokens while preserving answer quality. The repo has already crossed 42K+ GitHub stars, which says something obvious: Developers are not just worried about AI getting smarter. They’re worried about AI getting expensive. Of course, compression is not free magic. Complex reasoning tasks may punish missing context. Agent loops may behave differently. Proxy overhead has to be worth it. And real-world savings will vary. But the direction is clear - the next big AI infra unlock may not be a bigger model. It may be learning how to stop feeding expensive models cheap junk. Because the cheapest AI inference is the context you never send.

• 
  Harish Kotra 🥑 (@HarishKotra) reported 51 minutes ago

  Day 183 of 2026 building! I built an onchain reputation graph for open source contributors. Every GitHub repo, contributor, issue, PR, and npm package gets a deterministic atom ID on the Intuition blockchain. Relationships between them become triples. No central registry needed, IDs are derived from canonicalized data, so any app computing the same input gets the same ID.

• 
  π (@maswadkar) reported 52 minutes ago

  dear @OpenAIDevs why do we not have gpt5.5-pro model under codex. (gpt5.5-pro is the best model for planning and github issue creation) Then I will never have to leave the codex app

• 
  Smukx.E (@5mukx) reported 54 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

• 
  Pushkar (@realPushkarfr) reported 58 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.

• 
  Evan Ross Davis 🇺🇲 (@evanrossdavis) reported 58 minutes ago

  @dedene I'm finding TensorRT to not be worth the time and @NVIDIAAI's Spark playbooks are simply broken and full of bugs. I've reported them on GitHub. I'm sticking to vLLM and Ollama most likely from now on. I wasted many hours I'll never get back.

• 
  Kirill (@kirillk_web3) reported 58 minutes ago

  75K GitHub stars. Two weeks. Most people still burning tokens on 500-line answers to 5-line problems. Ponytail makes Claude think like the laziest senior dev on the team. Writes less. Skips what you don't need. Keeps every line that matters. 54% less code. 20% cheaper. 27% faster. One skill. Swap it in. Claude starts working differently. Save this before you watch Claude over-engineer one more time. Bookmark this now. Link below.

• 
  Vladimir Sapronov (@v_sapronov) reported 58 minutes ago

  @stolinski @danjones @rpunkfu The famous infinite loop GitHub Actions wait bug (the timeout comparison is made with exact equality instead of more or equal) could be fixed by a junior dev with Claude in like 1 month including onboarding and Jira setup. That one junior costs a fraction of the single marketing manager whose job is "how to cover recent 88.88% stability ****** with burn-the-CD marketing, and then push this marketing down developers throats through a network of overly friendly influencers". And this is just the marketing manager, there were also artists, video production, legal, SMM manager - all paid employees who didn't work on the product this month (or ever). The influencer's servility is not quantifiable though - they are kneeling in exchange of having access to GitHub people for their podcasts to farm more Github-friendly content.

• 
  Canwoy (@canwoy_com) reported 58 minutes ago

  Worker idea: docs maintainer. It watches product changes, support tickets, setup errors, stale pages, and GitHub issues. Every week it proposes docs patches with the source links attached. Not glamorous. Very useful.