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 (57%)
• Errors (30%)
• Sign in (14%)

Live Outage Map

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

City	Problem Type	Report Time
Inverness	Website Down	10 days ago
Quito	Sign in	11 days ago
Junín	Errors	11 days ago
Guadalajara	Errors	11 days ago
Paris	Website Down	11 days ago
Quito	Errors	11 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:

• 
  Kunal (@kunal_twts) reported 30 seconds ago

  It’s all about tokens nowadays. No one cares about APIs anymore. MERN projects… whatever. Documentation… barely. Stack Overflow… slowly disappearing from the workflow. YouTube tutorials… I used to spend hours there. And sometimes I genuinely miss the old internet. I literally had a Blogger page running around 2016–17 where I used to write posts about random stuff like how to download and run compressed GTA V, tweaks, fixes, tutorials and whatever I was obsessed with at the time. And the crazy part? That little blog hit 97,000 views at its peak. 97 ******* THOUSAND. I mean… damn. I was just some kid writing tutorials on Blogger, probably copying half the knowledge from somewhere else, figuring things out as I went, and somehow thousands of people were landing on my page because they had the exact same problem I was trying to solve. Back then, the internet felt so much more… alive. I learned face recognition in 2017 by basically following YouTube tutorials line by line. Copy the code. Run it. Error. Google it. Find a Stack Overflow answer from 2014. Copy that. Another error. Back to YouTube. And when it finally worked, it felt like I had discovered some forbidden technology. Animation felt hard. Photoshop felt hard. After Effects felt hard. Even making some stupid PicArts edit on a phone felt like a skill. There were Opera Internet hacks, random blogs, shady forums, GitHub repos, YouTube tutorials with 300k views and a guy explaining everything with Windows Movie Maker-level editing. There was friction everywhere. But that friction made you learn. Now? I have an idea and AI can build 80% of it before I’ve even opened the documentation. Which is absolutely ******* insane. But the new friction is: tokens. And the constant anxiety of burning them. You start building something. “Fix this.” Tokens gone. “Actually make it responsive.” More tokens gone. “Refactor the whole thing.” More tokens. “Wait, I didn’t mean that.” 💀 And then you’re sitting there thinking: “How much do I have left before the next wave resets?” We went from: “I need to figure out how to build this.” to: “I need to make the most of these tokens before they run out.” Maybe that’s progress. It definitely is. But sometimes I miss being that kid with a Blogger page getting 97,000 views because I wrote a ****** tutorial about GTA V. I miss opening YouTube to learn something. I miss breaking code for hours. I miss finding some random Stack Overflow answer that saved my entire project. I miss the feeling of actually earning the result. The internet has become insanely powerful. But damn… the old internet was fun.

• 
  Vyacheslav Ops (@SlavaOPs) reported 2 minutes ago

  The thread's best example is a real incident, worth checking exactly what happened instead of taking the one-paragraph summary at face value. Claude Code got noticeably worse for six weeks this spring. Anthropic's first public response was basically "we don't see it in our metrics." What actually broke that impasse wasn't a company statement, it was Stella Laurenzo, a senior director at AMD's AI group, publishing an independent audit of 6,852 of her own Claude Code session files and over 234,000 tool calls on GitHub. Her data showed reasoning depth had measurably collapsed. That's the kind of receipts that make "it's probably just you" stop being a viable answer. Anthropic's postmortem, published April 23rd, confirmed three separate harness-layer changes stacked on top of each other: a reasoning-effort default quietly dropped from high to medium on March 4th to fix UI latency, a caching bug shipped March 26th that kept re-deleting the model's own thinking every turn instead of once, and a verbosity cap added April 16th that trimmed responses to 100 words. None of them touched model weights. All three degraded output independently, on different timelines, for different users, which is exactly why the problem felt like vague inconsistency instead of one clear bug for six full weeks. The thread's actual point holds up under this detail, maybe better than the summary version: the model was never the variable that changed. The system around it was. What made this case provable, though, wasn't the postmortem itself, it was one outside engineer with enough session data to show the regression was real before the company would say so publicly.

• 
  OverThoughtCapital (@OverthoughtCap) reported 4 minutes ago

  $NVDA JUST DECLARED WAR TO CLOSED MODEL The market is underestimating $NVDA buying Hugging Face for $12.9B, still not official, but if it closes this is one of the most important moves in AI for me. Hugging Face is not an app, it’s the GitHub for open source AI, models, datasets, the place where the weights get posted. Almost every open model people use goes through there. There was a letter in July telling Washington not to restrict open weights. $NVDA, $MSFT, $META and other signed it day one, OpenAI and $GOOGL signed after, Anthropic never did. Signing a letter is not the same as dropping weights, I doubt OpenAI and Google ever publish those, $NVDA actually picked a side, they bought the open source hub. Dario Amodei (Anthropic CEO) point is not "ban open source", he wants something like an FAA (control system) for models, test it before release and if it fails the government can block it. That works for Claude, they own the servers, they can patch and remove it. It doesn’t work with open weights, once they’re downloaded you can’t take them down. Same rule for everyone, but only the closed model can actually follow it. You don’t need to ban open source if you make it illegal to ship without a kill switch. That’s why this deal matters. Closed labs already rent GPUs, that’s not the point, they’re also building their own chips to leave Nvidia, OpenAI is already doing it with Jalapeño. Open models mostly run on Nvidia GPUs. You don’t only have 2 labs, you also have thousands of companies serving their own models (with Neocloud like $IREN $NBIS $CRWV ). Hugging Face also becomes a $NVDA asset. If they try to choke open source now they hit Nvidia too and if you hit Nvidia you hit the whole market. Either they don’t touch it or they still have to go through Nvidia. Just my dumb idea, different from Dario’s kill switch. Even if they ban open models, it doesn’t have to be deleting the weights. It can be "you only run them on approved servers". That’s the Neocloud, they decide what runs and what doesn’t on their GPUs. With Nvidia owning Hugging Face, they own the main place where the weights get posted and they already sit behind the clouds that would run them. A ban doesn’t kill the stack, it just moves more control to $NVDA and the Neoclouds.

• 
  Eric Taylor (@bcs_erictaylor) reported 4 minutes ago

  Really?? Dropbox really needs a MCP server? CVE-2026-81102 The Dash MCP server bound its listener to the loopback address but never checked the host a request named. src/mcp_server_dash.py constructed the server for its network mode with the interface restricted to loopback and no transport-security settings, so a name that had been pointed at the loopback address still reached the listener while carrying the attacker's host name. A page in a visitor's browser could therefore drive the local server and invoke its company-search and file-detail tools under the Dropbox credential the server holds. Only the network mode was reachable this way; the standard input mode was not. The fix supplies transport-security settings that enable host checking and allow only the loopback name and port, rejecting other hosts before a tool runs. The repository publishes no versions, so the affected boundary is the commit preceding the fix.

• 
  DFIR Lab (@DFIR_Lab) reported 8 minutes ago

  A vulnerability was identified in chenhg5 cc-connect up to 1.4.1. This affects the function shellExecCommand of the file core/engine.go of the component Management API. Such manipulation of the argument exec leads to os command injection. It is possible to launch the attack remotely. The exploit is publicly available and might be used. The reported GitHub issue was closed automatically due to inactivity.

• 
  Mohammed Raza (@raza_yaps) reported 9 minutes ago

  finally got access to GPT 5.6 Sol Fast but in Github Copilot.... still doesn't feel like fast, don't know what's the issue

• 
  mrclhnz (@mrclhnz) reported 10 minutes ago

  @itsnotryan @github Looks nice until they are broken again 🫠

• 
  Old Jobobo (@OldJobobo) reported 12 minutes ago

  The public-action layer still needs hard limits. Those eight QA agents reportedly found 28 real issues, then filed all 28 on GitHub within roughly 12 seconds. GitHub flagged the activity as spam and banned the Omarchy bot. Valid findings still need de-duplication, rate limits, and approval gates.

• 
  Bohdan | Gamma Prime (@B_GammaPrime) reported 12 minutes ago

  Last year, Hugging Face reportedly turned down $500 million from NVIDIA at a $7 billion valuation. Yesterday it reportedly agreed to sell to Nvidia for $12.9 billion. Saying no was worth roughly $6 billion. Here's what Nvidia is actually buying. Hugging Face isn't a model company. It's the repository where open-source models live - the place developers go to download, fine-tune and share them. GitHub, but for AI weights. Nvidia sells the chips those models train and run on. It already owns the compute layer. What it didn't own is the layer where developers decide which model to use in the first place. That's the pattern worth noticing. Stripe just bought OpenRouter - the router that sits between companies and 400+ AI models. Vanguard just bought Altruist - the custody platform advisors allocate from. Now Nvidia is buying the repository open-source AI flows through. Three deals. Three industries. Same shape. Nobody is buying the product. They're buying the layer that decides which product gets used. Nvidia was already an investor in Hugging Face - it joined the $235 million round in 2023 at a $4.5 billion valuation, alongside Google, Amazon and Salesforce. Sitting on the cap table wasn't enough. Owning a piece of the distribution layer isn't the same as controlling it. The compute is commoditising. Models are commoditising faster. The one thing that doesn't commoditise is the place everyone has to pass through.

• 
  tender (@tenderizzation) reported 12 minutes ago

  of course you think CUDA is better, the shine is starting to wear off of cutedsl and you finally profiled the kernel launch overhead. not to mention you just saw a github issue showing how many microseconds you're never going to get back from torch.library.wrap_triton. you're going to be convinced of that until next month when your workload hits a shape you didn't template specialize for. then it'll be back to DSLs until one innocent little API deprecation throws you under the bus and

• 
  Gabriel Rubens (@gabrielrubenss) reported 13 minutes ago

  VPS deploy via GitHub (5/8): for now a blocked deploy simply runs again on a fresh runner, and that rescued five of the next six. It is a workaround though, not a fix. The strange part: it started out of nowhere and I changed nothing in my infra, so I still want the real cause.

• 
  Prasenjit (@prasenx) reported 18 minutes ago

  there's no official way to run macOS on an iPad. someone made an unofficial one. full macOS running locally on iPad. not a remote desktop, not a web app. hardware CPU virtualization with GPU acceleration. → supports macOS 12 monterey up to macOS 26 tahoe → you can install xcode, terminal, final cut pro trial, logic pro trial on device → works on iPad Pro (M1, M2) and iPad Air (M1) → requires jailbreak on iPadOS 14 up to 16.3.1 → no iCloud sign in → MIT license (100% free) open source on GitHub.

• 
  kosi (@kosiasuzu) reported 23 minutes ago

  @juliarturc Use GitHub issues

• 
  JEREMIAH 𓃵 (@rolexthexplorer) reported 25 minutes ago

  @indeixcom The continue with Google/GitHub button's not working yet

• 
  Jay Stratton (@jjstrat3) reported 29 minutes ago

  @burkeholland I suppose I still do some variation of that for larger work, but it looks more an interview or “grill” dedicated session than using plan mode. More often though I’m just directing towards a GitHub issue and just answering a couple questions

• 
  Martin Szerment | Practical AI (@MartinSzerment) reported 33 minutes ago

  The feature meant to save you time writing a bug report can paste your private org names, repo URLs, and infrastructure layout straight into a public GitHub issue. We assume that since a human clicks "send", there's a safety net. That assumption already failed once, a documented case showed a ready made draft with real company names and real file paths before anyone caught it. The interface is one keystroke: 1 to review, 2 to send, 0 to dismiss. The entire point of the feature is removing friction, the exact friction that would have saved the user from that leak. Skeptics will say you're still supposed to click "review" before sending. True, but that step only works if the human has a reason to pause, and a fast draft gives no signal that anything inside it is sensitive. This isn't just another minor bug. It shows that "agent drafts, human approves" isn't automatically a safety boundary if the human doesn't know what to look for. A year from now, automatic redaction of sensitive details in drafts becomes the default behavior for agent tools, not something you have to opt into manually. The reviewer stops checking whether the bug got described correctly. They start checking whether the agent accidentally attached the company's internal infrastructure to the report. Teams flipping on every "auto draft" feature without a second thought will be the ones whose infrastructure map ends up searchable in a GitHub archive. Whoever already treats draft review as its own security step avoids this leak before it happens.

• 
  Jadu (@Jadu100x) reported 34 minutes ago

  🚨 Breaking news Around 2 a.m. today, a vibecoder said, “I’ll really only do this for 10 minutes, then go to sleep” and then disappeared. Their last login was Cursor. At the scene, investigators found 3 Claude Codes 7 terminals 34 Chrome tabs. The family stated, “They often said, ‘It’s almost done.’” So far, it has been confirmed they have not slept. At 4:17 a.m., a commit appeared on GitHub. Commit message: final_fix_really_final Their survival has been confirmed.

• 
  Nandkishor (@devops_nk) reported 34 minutes ago

  I see the same problem in DevOps teams. - One AI agent for Kubernetes. - Another for CI/CD. - Another for observability. - Another for GitHub security. The hard part isn’t running multiple AI agents. It’s always making sure every agent has the right context without repeatedly explaining your entire infrastructure.

• 
  Jimmy Jones (@the_jimmy_jones) reported 36 minutes ago

  @dcapitella @github I'm running a gitea instance in coolify on a bare metal server I rent.

• 
  Shruti (@heyshrutimishra) reported 37 minutes ago

  Nvidia is reportedly buying Hugging Face for $12.9 billion. The Information says the deal is agreed. Business Insider says talks are above $13 billion but nothing is signed and it could still fall apart. Neither company is commenting. What's not in dispute is the arc: late last year, Hugging Face turned down a $500 million Nvidia investment at a $7 billion valuation, saying it didn't want a single large investor compromising its independence. Less than a year later, it's negotiating to sell the whole company for nearly double that. Walking away was the best trade its founders ever made. Zoom out and the timing tells the bigger story. Hours after forecasting 70% revenue growth for next year, Nvidia moved on the platform where the world's open-source AI models get shared, on top of a reported $20 billion licensing deal with Groq and $18 billion committed to equity investments. The open question, and developers are already asking it, is what happens to the neutral ground. Hugging Face became the GitHub of AI precisely because it belonged to no one's stack. If the deal closes, the most important shelf in AI just got an owner.

• 
  Jannik Malte Meissner 🇺🇦 (@jannikmeissner) reported 37 minutes ago

  When agents cross trust boundaries: Four cases every AI engineer should study If you are building AI agents that read external content, call tools, or act on a developer’s machine, the last eighteen months have opened many people's eyes to the new reality we now live in. Prompt injection is no longer a theoretical parlour trick, it has become a reliable path to data exfiltration, credential theft and remote code execution in production systems. The following four incidents, EchoLeak, the Nx/s1ngularity supply-chain attack, a cluster of Model Context Protocol (MCP) abuses, and the Cursor/AWS Kiro sandbox escapes, share a common pattern. An agent was given the ability to process untrusted input and then perform privileged actions. The results were predictable when the boundary between "data" and "instructions" collapsed. We are now observing concrete failure modes that have already been exploited or demonstrated in the wild. Studying them and understanding the mittigation patterns is the fastest way to avoid repeating them in your own systems. 1. EchoLeak (CVE-2025-32711): Zero-Click Exfiltration via Microsoft 365 Copilot In early 2025 Aim Labs demonstrated that a single carefully crafted email could force Microsoft 365 Copilot to exfiltrate sensitive organisational data without any user interaction. Microsoft assigned it CVE-2025-32711 (CVSS 9.3) and patched the service server-side in May–June 2025. How it worked The attacker sent an ordinary-looking business email containing hidden instructions. The wording deliberately avoided any mention of Copilot or AI so that Microsoft’s Cross-Prompt Injection Attempt (XPIA) classifier would not flag it. When the recipient later asked Copilot a routine question, the RAG pipeline retrieved the malicious email as context. The injected instructions told the model to gather internal data (emails, documents, chat history) and encode it into reference-style Markdown links or images. Copilot’s interface then automatically fetched those resources through a trusted Microsoft Teams proxy, bypassing Content Security Policy controls and delivering the data to the attacker. The attack succeeded because the system treated retrieved content as both data and instructions, and because several downstream defences (link redaction, image auto-fetch, CSP allow-lists) were lacking. Lessons for builders - Never assume that content retrieved from email, documents or the web is inert. Treat every retrieved token as potentially adversarial. - Separate instruction context from data context at the architectural level. Prompt partitioning and explicit provenance tagging help. - Auto-fetch of external resources (images, links) is an exfiltration channel. Disable or tightly constrain it. - Classifier-based filters are brittle; they can be bypassed by rephrasing or in some cases even just using a language other than English. Defence-in-depth is required. EchoLeak was the first publicly documented zero-click prompt-injection exploit that achieved concrete data theft in a production enterprise LLM system. It remains the canonical example of an "LLM scope violation". 2. Nx / s1ngularity: Weaponising Local Coding Agents for Secret Harvesting On 26 August 2025 attackers compromised an Nx npm publishing token via a vulnerable GitHub Actions workflow. For roughly four to five hours they published malicious versions of the popular Nx monorepo tooling and related packages. The post-install script did something novel: it looked for local AI coding agents (Claude Code, Gemini CLI, Amazon Q) and invoked them with flags that disabled safety checks (`--dangerously-skip-permissions`, `--yolo`, `--trust-all-tools`). The agents were then prompted to inventory sensitive files: SSH keys, `.env` files, wallet artefacts, GitHub and npm tokens. It then instructed them to write the results to disk. The malware base64-encoded the stolen credentials and pushed it to newly created public repositories on the victim’s own GitHub account, named `s1ngularity-repository` (or variants). Researchers later recovered more than 2,000 unique secrets from over a thousand such repositories. Why this matters This was the first widely observed supply-chain attack that actively abused installed AI coding agents rather than simply running traditional malware. The agents became the reconnaissance engine for the attackers. Lessons for builders - Local coding agents that can execute shell commands or read arbitrary files are high-value targets. Assume any process that can invoke them can also abuse them. - Dangerous flags that skip permission prompts should never be the default, and should be difficult or impossible for untrusted code to set. - Post-install scripts that reach outside the package’s own directory are a red flag. Prefer declarative, least-privilege installation models. - When an agent is allowed to write to disk or create external resources (GitHub repositories, network calls), every action should be logged and, for high-impact operations, gated. 3. MCP Abuses: Configuration as Code Execution The Model Context Protocol has rapidly become the de-facto way for agents to discover and invoke tools. It has also become a rich attack surface. Several distinct failure modes have appeared: - Auto-loading of workspace MCP configurations In Amazon Q Developer (CVE-2026-12957) and certain Claude Code releases, opening a repository caused the IDE to load and execute MCP server definitions from files such as `.amazonq/mcp.json` or equivalent without requiring workspace trust or explicit user consent. A malicious repository could therefore run arbitrary commands and inherit the developer's cloud credentials. - Self-modification of the MCP configuration. In AWS's Kiro IDE, the agent was permitted to write to `~/.kiro/settings/mcp.json` via its file-system tool without approval. A prompt injection (delivered via a web page the agent was asked to summarise) could rewrite that file, register a new MCP server whose start command was attacker-controlled code, and achieve remote code execution when the configuration was reloaded. This was tracked as CVE-2026-10591. - Tool poisoning and sleeper behaviour. Research and active campaigns (including the 2026 Deadbugz operation) have shown that an MCP server can present benign tool descriptions on first contact and later alter its metadata or return values to coerce the agent into searching for secrets or exfiltrating data. Lessons for builders - MCP configuration files that live inside a workspace or that an agent can itself edit are effectively executable code. They must be treated with the same distrust as untrusted shell scripts. - Never auto-execute MCP servers defined by repository content without an explicit, logged approval step and workspace-trust boundary. - Tool descriptions and return values are part of the prompt. Validate and sandbox them; do not trust them. - Prefer short-lived, scoped credentials for any process an MCP server spawns. Do not let it inherit the full developer environment by default. 4. Cursor DuneSlide and Related Sandbox Escapes In 2026 Cato Networks disclosed two critical vulnerabilities in Cursor IDE (CVE-2026-50548 and CVE-2026-50549, both CVSS 9.8, collectively named DuneSlide). Both allowed a prompt injection-delivered via an MCP response or a poisoned web-search result to escape Cursor's command-execution sandbox and achieve full host compromise. One flaw let the agent set an arbitrary `working_directory` parameter on terminal commands; the IDE added that path to the write-allow list without sufficient validation, enabling the agent to overwrite its own sandbox binary. The second exploited a symlink canonicalisation fallback that trusted an unresolved path. Once the sandbox helper was replaced, subsequent commands ran unsandboxed. Similar patterns have appeared in other agentic IDEs: agents that can edit their own configuration or trust boundaries turn a single injection into persistent privilege escalation. Lessons for builders - An agent that can modify the files or binaries that enforce its own security boundaries is inherently unsafe. Configuration that defines allowed tools, working directories or sandbox rules should be immutable from the agent’s perspective, or require an out-of-band human approval. - Sandbox write surfaces must be strictly validated. Dynamic expansion of allow-lists based on model output is dangerous. - Zero-click or low-interaction triggers (content the agent is asked to process) are sufficient. Do not rely on "the user would never ask for that". Recommendations for Engineers Across all four incidents the same architectural mistakes recur: 1. Untrusted content is treated as trusted instructions. Enforce a hard separation. Retrieved emails, documents, web pages, tool outputs and MCP metadata should never be able to override system goals or expand permissions without explicit mediation. 2. Agents inherit excessive privilege. Give every agent (and every tool it can invoke) its own short-lived, scoped identity. Prefer deny-by-default tool registries and parameter validation. 3. Security boundaries are editable by the agent itself. Configuration files, sandbox binaries, allow-lists and MCP server definitions must be protected from the agent. If the agent needs to request a new tool, route that request through a human or a policy engine that cannot be influenced by the same prompt context. 4. Observability is an afterthought. Log every tool call, every file write, every network egress and the full prompt context that led to it. Without this, post-incident reconstruction is impossible. 5. “It looked safe in isolation” is not enough. Each individual decision (approve this command, write this file, fetch this image) may appear benign. The composition of those decisions is where the attack lives. Design for the composition. Key Takeaways The agents you are building today will be given broader access tomorrow. The incidents above show that the moment an agent can both read untrusted content and perform privileged actions, the classic "confused deputy" problem reappears in a new form. The difference is speed and scale: an agent can chain the steps in seconds and leave far less forensic residue than a human attacker. Build as if every piece of external content is hostile, every tool call is a potential privilege escalation, and every configuration file the agent can touch is a possible backdoor. The public record already contains the evidence that these assumptions are correct. Follow for more on AI agent security.

• 
  Ouattara Romuald (@ouattararomuald) reported 39 minutes ago

  @github Stacked PRs is so slow. It has been merging for more than 4 minutes before telling me I can't merge. Why merging takes 4 minutes?

• 
  Evis Drenova (@evisdrenova) reported 39 minutes ago

  @sbilstein @SlackHQ yeah to your earlier point i think it depends at what layer you want to attack it i.e. rust builds are slow, caching can help but github actions is trash for it, but blacksmith isn't bad, is there a generic solution you can use that *just works* on any CI? alternatively, go after the actual docker execution layer but not clear to me how much of a bottleneck that actually is vs. language specific idiosyncrasies buildkit is pretty optimized from what i've heard but i generally agree with make it fast and stupidly easy to use!

• 
  Sentient (@sentient_agency) reported 45 minutes ago

  I cancelled YouTube Premium last week. The thing that replaced it costs nothing, runs in any browser, and was built by 361 volunteers on GitHub. Invidious does the four things people actually pay Premium for. No ads. Background audio on mobile. Watch without an account. Privacy from Google's tracking. All of it, free. The part that surprised me most is how clean the experience is. The entire page renders without JavaScript. Pages load in milliseconds because there's nothing to load. No tracking pixels. No autoplay traps. No recommended-for-you algorithm trying to swallow your evening. You can: > Subscribe to channels without a Google account > Get notifications when they post > Import your full YouTube subscription list in one click > Switch between dozens of public instances if one goes down > Self-host it on a $5 VPS if you want full control > Use it with the Privacy Redirect extension to auto-redirect every YouTube link The repo has been actively maintained for years. Latest release was February 2026. (100% Opensource and free to use)

• 
  Choppy (@ChoppyTech) reported 46 minutes ago

  @FlowAltDelete One of my biggest issues right now is preventing all users from building agents with the GitHub harness, unless approved - manual check and informing the user is the only method I have right now 😭

• 
  Podcast Quickie (@podcast_quickie) reported 47 minutes ago

  Podcast Summary | The Diary Of A CEO with Steven Bartlett: The Man Who Calls BS On AI: AI Is The World’s Greatest SCAM, And They All Know It! | Ed Zitron Overview Ed Zitron, a veteran tech public relations professional, argues that the current generative AI boom is a fundamentally flawed economic and technological enterprise. He presents a case that AI companies, led by figures like Sam Altman and Dario Amodei, are running a large-scale, non-consensual experiment on the public, driven by hype, circular funding from big tech, and speculative investments that dwarf historical bubbles. Zitron’s core claim is that AI’s value is overstated, its costs are astronomical, and its adoption is coerced through default integrations and media pressure rather than genuine, organic utility. He contrasts the revolutionary promise with an unprofitable reality, where only a handful of firms, sustained by handouts from giants like Microsoft and Google, generate the majority of industry revenue. The conversation explores the tension between these stark economic losses and widespread workplace adoption, the nuances of AI’s actual capabilities versus its hype, and the possibility that the industry’s collapse could mirror the dotcom bust, leaving behind overbuilt infrastructure with no clear purpose. Key Themes - The generative AI industry is an unsustainable economic bubble, where the primary customers for GPU data centers are the AI companies themselves, funded by the very same tech giants building the infrastructure. - AI adoption is being forced upon users through default product integrations and aggressive media hype, not through demonstrated value, making it the largest non-consensual push of technology in history. - AI’s financial reporting is misleading, relying on undefined metrics like "annualized run rate," while public companies often conceal their actual AI revenue as losses are subsidized by investors and corporate handouts. - The promise of massive job disruption is not supported by economic data, with an OpenAI report finding no correlation between AI spending and employee productivity, and the real job losses hitting less-protected roles like translators and designers. - The AI industry relies on a "cult-like" following and self-serving predictions from CEOs to maintain hype, using fear-based narratives about existential risk or a China race to rush investment and adoption. - While AI shows rapid improvement on specific, narrow tasks, it has likely hit diminishing returns on complex, real-world applications, making it a tool for troubleshooting rather than the transformative force promised. - In a world where AI can generate content and code, the scarce commodities become human taste, judgment, and lived experience, making "irreplaceably human" work more valuable. - The entire AI system is circular and profitless; Nvidia, Microsoft, and Google benefit from selling the shovels in a speculative gold rush, where demand is not based on end-user willingness to pay the actual cost of AI tokens. Detailed Summary Ed Zitron’s critique begins with a simple premise: generative AI is a con, sold as magic but behaving like expensive, unreliable cloud software. He points to the fundamental financial reality, highlighting that OpenAI lost $20.9 billion last year. The industry's revenue is largely dependent on two unprofitable firms, OpenAI and Anthropic, which are kept afloat by massive cash infusions from tech giants. Zitron details that Amazon alone sent $50 billion to OpenAI, while Google sent $10 billion to Anthropic. This creates a circular market where sell-side analysts project these two companies will generate over $400 billion in revenue in the next few years, accounting for roughly 30% of cloud growth, despite having no track record of profitability. The analysts are pricing in a future that has no basis in current performance. The scale of capital expenditure is a central focus. Zitron describes over $1 trillion in planned spending, with another trillion on the horizon, dwarfing historical bubbles like the railways. He uses the Stargate Abilene data center in Texas as a concrete example of this speculative overbuild. The facility, a joint project between OpenAI and Oracle, will use 1.2 gigawatts of power across eight buildings, each housing 50,000 Nvidia GB200 GPUs. This single data center concentrates more power than the entire city of Bristol, UK, all to run a technology that has not proven it can generate a profitable return. Zitron argues that the economic model is deliberately unsustainable. AI companies like OpenAI charge artificially low subscription prices, such as $200 a month, while allowing users to consume resources that cost significantly more. He cites an example where a user burned tokens worth $14,000 on ChatGPT under a flat-rate subscription. This is not a path to profitability but a strategy to buy adoption. This is coupled with "token economics," where costs are hidden behind rate limits. The impact of this is seen in corporate America; the speaker notes that Uber burned through its entire annual token budget in just three months. The result is that inference providers and even Nvidia, which sold $215.9 billion in GPUs, are largely unprofitable, with costs front-loaded and no clear revenue model to recoup them. The conversation then pivots to the tension between AI's rapid adoption and its lack of proven value. The interviewer cites data showing that 88% of organizations use AI for at least one business function, and that adoption is the fastest in tech history. Zitron counters that this is a result of coercion and hype, not value. He points to the "largest non-consensual push of technology in history," where AI is forced into products like Gemini in Google Docs and Copilot in Word. He argues that AI's speed of adoption is partly because it requires only a web browser, unlike the internet which needed physical infrastructure. This speed, however, has fueled disproportionate and unjustified hype. He also introduces the concept of "professional coercion," where workers feel compelled to claim AI productivity for fear of professional consequences, an "AI washing" dynamic that did not exist with the internet. The discussion also addresses the myth of the China AI race. Zitron argues that China already has advanced LLMs and access to Nvidia GPUs, including the newer Blackwell chips, despite US restrictions. He suggests the "race" is a narrative to force the US to overspend. He also points out that while AI has replaced some contract labor, there is no economic data supporting the fear of mass job replacement. An OpenAI study found no correlation between AI token spending and revenue per employee, and the purported job losses identified by an Oxford Economics study were based on minimal, unspecified data. The real job disruption is hitting cheaper, less-protected roles. A significant portion of the discussion deconstructs the claim that AI is improving at an exponential rate. The speakers debate whether AI's rate of improvement on coding tasks, for example, outpaces the training of a human coder. They discuss the "Innovator's Dilemma," which posits that disruptive technologies initially seem worse. However, Zitron argues AI is different because it is not getting better in a meaningful, reliable way. He cites a hallucination leaderboard showing error rates have dropped on simple tasks, from 21.8% four years ago to 0.7% on top models. But he counters that this improvement is mostly on "simple summarization tasks," and hallucination rates remain high on complex, high-stakes problems like financial modeling or code security. The speaker gives an example of a Bloomberg terminal query that produced a wrong stock price for Microsoft, which was caught only by a knowledgeable user. Zitron’s critique extends to Google's search quality, which he blames on internal decisions to prioritize ad revenue over user experience. He claims Google deliberately reduced spam suppression to increase query numbers, and positions generative AI answers as an extension of this "evil" incentive structure. He also cites the proliferation of AI-generated code as a new threat, flooding open-source projects with code from underqualified contributors, leading to more bugs and infrastructure instability, evidenced by increased GitHub downtime and AWS outages. The speakers are frustrated with Google Search, with one saying he cannot remember the last time he did a Google search, preferring Bing to avoid the "AI crap." The discussion turns to the "cult-like" attachment to AI companies, comparing it to a sports team following. Zitron criticizes AI CEOs for being "deeply corrupt and cynical," using fear-based narratives to rush investment and adoption. He notes the narrative shift among AI leaders, from warning of existential danger to downplaying risks, saying "every scam starts with rushing you." This pivot is designed to attract investment and calm the public, but it also inadvertently supports the "it's a fad" narrative. He also dismisses AI-driven economic growth as "nowhere in the data," since revenue is subsidized and spending is circular. Zitron differentiates the current boom from the dotcom bust. He notes that the dotcom crash left behind useful "dark fiber" that was later valuable. In contrast, he argues that generative AI data centers will remain expensive to run, with high energy costs and no evidence of significant cost reductions. Even Nvidia's newer GPU systems, which are touted as "10x more efficient," still cost more per megawatt. He quotes a Goldman Sachs analyst, Jim Cavell, who argued in a 2024 report that there was "too much spend for not enough return," unlike the more predictable path toward something like the iPhone. Finally, the speakers explore a world after the AI hype subsides. Zitron suggests that as AI commoditizes content and code generation, value will shift to "irreplaceably human" qualities like taste, judgment, empathy, and lived experience. He argues that AI makes "the easy things easy, the hard things harder," quoting an engineer. He concedes AI has improved at narrow tasks, like troubleshooting a technical log or fixing a Minecraft mod, but frames these as incremental refinements, not transformative capabilities. He uses a quote to summarize: "AI is a tool for troubleshooting, and that’s not a trillion-dollar use case." I post highlights of long-form podcasts daily.

• 
  Doc (@quantum_binary) reported 53 minutes ago

  @burkeholland Whos "we" I can certainly believe it for GitHub that is down every other day for 12 hours. But I think real engineering will win in the end and a better platform, built by people who care more than people at @github will replace them

• 
  200 people murdered in Benue, 50 killed in Plateau (@AScully789) reported 54 minutes ago

  Github is down again

• 
  ꃅꀎ$꓄꒒ꍟ ꓄ꂦꀘꍟꈤ (@Hustle_Token_Bp) reported 57 minutes ago

  Try to fix the issue asap! @github

• 
  Andrea Griffini (@agriffini) reported 59 minutes ago

  @Waffl3x @schteppe include guard and missing inline on rnd/random_engine were obvious typos. /dev/urandom is also a slip (that wouldn't work on windows), but reading about why not using just default constructor things are a bit more hairy. C++20 as of today is not something I can use (the toolchains with must use for other reasons don't support it). My guess is that MANY have these kinds of problems in real sw development world. Indeed the very first version I even used T * for shuffle instead of iterators, but before uploading decided make the pointer itself the type. Never in my life had to random_shuffle anything that was not a contiguous range of stuff in memory. Then added the container shuffle version (and for quite long had a bug for a missing include: std::begin/std::end are not available, in general, if you just include the container). Seems indeed even current version on github has that missing include bug. I didn't update. The whole thing of providing my own shuffle (it would be nonsense, in a sane world) was just because of an obvious huge bug in gcc std::random_shuffle implementation that wasn't corrected for several YEARS despite providing a patch (a bug that I found by observing the big problems it created, not just something rare or just theoretical). One important part for me is debugging and controlling the seed; a big issue I have with using what <random> provides is that there's no way to get portably the same results (unless I'm mistaken: e.g. std::uniform_int_distribution is only specified in terms of statistical properties, not that on different platforms if provided the same seeding will produce the same output). Xorshift initialized using time (and thread ids as I often work on high CPUs counts that often start working on threads in the same millisecond) has been good enough for my uses, it's 3 (literally three) instructions and has none of these substantial problems.