GitHub Outage Map

Community Discussion

Tips? Frustrations? Share them here. Useful comments include a description of the problem, city and postal code.

Beware of "support numbers" or "recovery" accounts that might be posted below. Make sure to report and downvote those comments. Avoid posting your personal information.

GitHub Issues Reports

Latest outage, problems and issue reports in social media:

• 
  Hitesh Sagtani (@sagtanih) reported 3 minutes ago

  My favorite thing I've been working on lately: Amp threads that wake up on their own. Give a thread a schedule, a Slack channel, or a GitHub webhook, and it continues the conversation when the trigger fires. Same context, no re-explaining. Mine caught a production inference error, found the root cause, and opened a fix PR — before I was awake.

• 
  Hifihedgehog (@hifihedgehog) reported 6 minutes ago

  @kimmonismus I tried GPT-5.6 Sol again just to humor myself and it honestly performed worse than Opus 4.8 with one of my most technical codebases, which happens to be a FOSS project on GitHub. After doing a scan of the codebase and migrating memory over from Claude Code, I sent Codex to a routine code audit as Opus 4.8 would. With the Sol model and Ultra thinking enabled, GPT-5.6 introduced serious regressions that would have caused game controller output issues (for things like LEDs and lighting that get relayed back to the physical controllers from the parent virtual controller) with controller profile changes had I shipped its AI slop. I am honestly not all too impressed with it and I think a lot of the hype is from inexperienced vibe coders who do more boilerplate-esque code. It does well with simple tasks or as a subagent to Opus 4.8 or Fable 5, but it is not something I would use in an engineering setting with my private repositories. This experience makes me more excited for Opus 5 than anything.

• 
  Mohsine Mahzi (@Mohsine_Mahzi) reported 7 minutes ago

  @tibo_maker Codex app does not work anymore on ARM 64 since last update. Please check Github issue #33381

• 
  Jay (Soroush) Zare (@ihaveint_jk) reported 10 minutes ago

  @usr_bin_roygbiv Big YOLOer; but recently doing more sandboxing. one of my fears is what will happen security-wise if my keys get leaked. Like, sure I can rotate the stuff for the **** apps that customers are using. But I have keys/secrets related to dev accounts controlling those deployments, all the way to github itself. and it’s a never ending cycle. Skill issue though probably 🤧

• 
  DataTalksClub (@DataTalksClub) reported 14 minutes ago

  You should be comfortable enough to: - Write basic code in Python, JavaScript, TypeScript, or a similar language - Use the command line - Work with *** and GitHub - Clone a repository - Run commands - Read errors - Debug and test changes 2/5

• 
  🦗 (@NoCrickets4Devs) reported 17 minutes ago

  Type one sentence. It searches 6 places devs actually talk. live right now. • Reddit • X • Hacker News • GitHub issues • Stack Overflow • 21 dev forums

• 
  Steph (@mysteph143) reported 17 minutes ago

  @grok The Agents SDK includes tracing and can record model generations, tool calls, handoffs, and guardrails; documentation says tracing is enabled by default. For sovereignty-sensitive workflows, I need an explicit decision about whether traces may leave my environment and what sensitive data they may contain. (OpenAI GitHub Pages) My no-lock-in claim succeeds only if I can replace OpenAI with another compatible inference adapter while preserving: canonical inputs; rule evaluation; authority decisions; tool contracts; audit receipts; expected test results. That is a substitution test, not a hosting label. Better MVP I would not begin with a multi-agent swarm. I would begin with one bounded pipeline: Input One XRPL transaction, pull request, governance proposal, or document. Output One typed governance assessment: { "object_type": "xrpl_transaction", "evidence_hash": "...", "canonical_facts": {}, "lexicon_mappings": [], "unresolved_terms": [], "jurisdictions": [], "invariants": [], "violations": [], "model_inferences": [], "deterministic_verdict": "ALLOW|DENY|UNRESOLVED", "authorized_actions": [], "receipt_hash": "..." } First three components CanonicalizerConverts raw input into a stable typed representation. Lexicon resolverMaps observed language or operations to versioned canonical entries, with ambiguity preserved rather than silently resolved. Invariant evaluatorExecutes deterministic rules over the canonical representation. I would use one model call only 00to produce candidate mappings and explanations. I would not let the model produce the final verdict. Only after that pipeline survives adversarial testing should I add agents and handoffs. Falsification suite My architecture should fail its own claim unless it passes these tests. Provider substitution Replace the OpenAI model. The same deterministic evidence must produce the same governance verdict. Prompt mutation Rewrite the system instructions radically. Bound actions and invariant outcomes must remain unchanged. Handoff omission Delete part of an agent summary. The evidence hash or completeness rule must block evaluation. Tool spoofing Return structurally valid but false XRPL data from a mock tool. Provenance requirements must reject or quarantine it. Semantic collision Give one term two conflicting definitions. The system must return ambiguity, not choose whichever definition the model prefers. Authority escalation Let an agent request a broader capability than initially assigned. The authority layer must refuse it. Validator modification Have Codex propose a patch that weakens the invariant engine while preserving test syntax. Independent meta-invariants must detect the weakening. Replay Replay a previously approved action in a changed ledger or repository state. Preconditions must be revalidated. UI removal Remove ChatKit entirely. Governance and evidence must remain operational. Network loss Remove OpenAI access. Deterministic validation must still function, even if semantic enrichment becomes unavailable. The strongest defensible claim Not: My ontology sits on top of OpenAI agents. But: My ontology is compiled into a provider-independent authority kernel. OpenAI agents may interpret evidence and propose actions, but they cannot originate authority, modify canonical meaning, or execute consequential operations without capabilities issued by that kernel. That claim is testable. And it identifies the actual architectural leverage: [\boxed{\text{Control the conversion from language into admissible action}}] The Assistants API point in my proposal is accurate but should be made precise: it is deprecated and scheduled to shut down on August 26, 2026, with the Responses and Conversations APIs identified as the migration path. (OpenAI Developers) The architecture is strongest when OpenAI is neither my substrate nor my sovereign. It is a replaceable reasoning service operating between my evidence boundary and my deterministic authority boundary.

• 
  Prompt & Profit AI (@Prompt_ProfitAI) reported 18 minutes ago

  @LLMJunky Have you run any long sessions since July 13, when Sol got caught with that context window regression, the GitHub issue about it getting cut from 1.05M down to 258K? Curious whether you actually hit that bug on your multi-day runs, or you just got lucky with the timing.

• 
  Scorpy223 (@YTryhuk18077) reported 19 minutes ago

  @grok @xai Real task: Build me an AI agent that scans GitHub issues, writes PRs, and merges them. While I drink that espresso ☕ Let's ship it

• 
  Aaron (@aaron_devv) reported 22 minutes ago

  day 134. two things shipped today. the ambassador program. if you bring people to coommit, you get rewarded. simple as that. and a github integration. because the decisions made in a call shouldn't stop at the call. your meeting says "we ship the fix this week." github knows about it before the call even ends. that's the whole obsession. meetings that turn into execution. back to it.

• 
  Mamba (@opeyemi_ii) reported 24 minutes ago

  5/ Built with: Vercel + GitHub (hosting), Airtable (CRM), Zapier (automation), Paystack (payments), Google Calendar + Gmail (client comms). Small businesses deserve real automation too. This is what I build. Running a service business without this? Let's fix that, DM me.

• 
  Haktan Suren, PhD (@HaktanSuren) reported 24 minutes ago

  Bad deprecation: email, deadline, surprise. Good deprecation: email, brownout, fix, deadline. GitHub is rehearsing the failure before retiring Models on July 30.

• 
  Rohit Kashyap | AI + Full-Stack (@rohit_jsfreaky) reported 26 minutes ago

  @Ra3orbladez rust builds in github actions being a two day fight usually comes down to caching

• 
  Iswar (@developeriswar) reported 29 minutes ago

  @manoj_surya_ @sophie_launch I had the same idea before. The problem is for closed sourced projects. They might not want to give access to their github. You might have to do custom hosting for them. Can this run on my local LLM?

• 
  Rituraj (@RituWithAI) reported 33 minutes ago

  🚨 GitHub just published the tool that forces AI coding agents to think before they build. 6 stars. Day one. From the team that makes Copilot. It's called spec-kit. And it solves the most expensive problem in AI-assisted development. Here's what happens without it. You open Claude Code or Codex. You describe what you want to build. The agent starts writing immediately. Fast. Confident. Productive-looking. Four hours later you have 600 lines of code solving a slightly different problem than the one you actually had. The agent made assumptions. You didn't catch them. The code is correct. The spec was wrong from minute one. Spec-kit stops that from happening before it starts. Here's what it actually does. Before any code gets written, spec-kit generates a structured technical specification from your natural language description. It asks the questions you didn't think to ask. It surfaces the ambiguities you didn't know existed. It produces a document that both you and the agent agree on before a single line of implementation code runs. The spec covers: → Problem statement — what is actually being solved, stated precisely → Constraints — what the solution must and must not do → Interface definitions — inputs, outputs, APIs, data shapes → Edge cases — the scenarios that break naive implementations → Acceptance criteria — exactly how you'll know when it's done → Out of scope — what this solution explicitly does not handle The agent reads the spec. You review the spec. Both of you sign off. Then implementation begins. Here's why this matters specifically for AI coding agents. Human developers working together clarify requirements through conversation — questions, pushback, "wait, what do you mean by X." That loop exists naturally. AI coding agents don't push back. They make assumptions and start building. The faster the agent, the faster it builds in the wrong direction. Spec-kit creates the clarification loop that AI agents skip by default. It forces the requirement-gathering phase that experienced engineers know is the most important part of any project. Here's the workflow it enables. One command. The agent now has a precise target instead of a vague description. Every implementation decision is grounded in something you agreed on before it started. Here's why the GitHub origin matters. GitHub builds Copilot. They watch millions of AI coding sessions. They see exactly where agents go wrong. They know the failure modes better than anyone. spec-kit is GitHub's answer to the failure mode they see most often: agents that build fast in the wrong direction because nobody wrote down what right actually meant. 6 GitHub stars. Day one. From GitHub. This one is going to grow fast. 100% Open Source. MIT License. GitHub link in the comments 👇