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 (22%)
• Errors (11%)

Live Outage Map

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

City	Problem Type	Report Time
Paris	Sign in	3 days ago
Lure	Website Down	6 days ago
Ashkelon	Website Down	8 days ago
Veigné	Errors	16 days ago
Paris	Website Down	19 days ago
Saint-Paul	Website Down	20 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:

• 
  Codex Changelog (@CodexChanges) reported 7 minutes ago

  Fixes: - Proxy support was incomplete — proxies are now honored across authentication, plugin downloads, MCP authorization, remote execution, WebSockets, redirects, and LM Studio connections - MCP connections would drop or go stale when auth or config changed — connections are now kept current and closed servers are reconnected without restarting healthy ones - Submitted messages, final responses, failed-turn errors, imported timestamps, and approval settings could be lost across interruptions, replays, imports, and forks — all are now preserved - Windows TUI navigation keys were broken — fixed - Windows sandboxed process trees did not terminate reliably — now terminated using job objects - Windows sandbox proxy settings were dropped during security reviews — now preserved - Terminal rendering issues fixed: nonblocking turn interrupts, keyboard event adaptation, narrow layout clamping, and OSC 8 hyperlink coalescing - Mention results in the TUI could go stale — kept fresh; keymap action menu is now responsive - Skills were dropped too aggressively under tight context budgets — more skills are retained; a warning is emitted when catalogs must be truncated Docs: - Documented shared HTTP client usage, proxy-aware connection pooling, and safe outbound request handling - Clarified Windows drive-letter canonicalization for PathUri values Chores: - Release artifacts, channel metadata, and installer aliases now published through OpenAI-hosted infrastructure, with GitHub fallback - Bundled macOS helper executables are now signed and notarized before packaging - Reduced app-server serialization overhead and unnecessary request-building allocations - Added enterprise plan recognition and administrator controls for in-app updates

• 
  Al McLean (@moridin419) reported 8 minutes ago

  I've started using github issues as the backend for building with AI and it works ridiculously well. PRD for the idea, milestones for direction, issues for work, ADRs for decisions and commits + CI for proof. The project context is easy to rebuild every time.

• 
  Phil | Rentier Digital Automation (@rentierdigital) reported 8 minutes ago

  tmux shipped in 2007 and survived everything. GPU terminals, Warp, Electron, the whole GPU wave. Version 3.6a just dropped December 2025. it will not die from a faster multiplexer it will die bc what lives in the panes changed before: a pane held a shell waiting for you to type. today it holds an agent that runs alone for 8 minutes then stops dead asking for permission. tmux sees both as text scrolling or not scrolling, it cannot tell them apart the layer that is dying is not the software. it is the layer where you spend your day. herdr hit 15,000 GitHub stars in 105 days built by 1 developer. trending number 1 on June 30, 2026. people are still comparing 6 different approaches to a problem that did not exist 2 years ago here is what broke: a multiplexer multiplexes streams. that was enough when a human eye sat in front of every pane and turned stream into state. you looked at scrolling output and knew the build was running, a prompt sitting still meant it finished. you did this conversion a few hundred times a day without noticing an agent blocked on a permission request is a state not a stream. there is no eye in front anymore bc you launched 6 agents to stop sitting in front of them. a pane that waits looks exactly like a pane that works tmux will not disappear from your machine. it will disappear from your working day. slower death than deprecation, far more complete i build and ship daily. Claude Code, Codex, whatever ships fastest. SaaS, tools, automations. ⭐ if AI can build it, i've probably broken it first. what works → link in bio

• 
  VISHAL (@_THE__FUHRER) reported 17 minutes ago

  1) The Task The model gets a full GitHub repository + an issue description. It must independently navigate the codebase, locate the bug, write a patch, and modify the code. No hand-holding allowed.

• 
  William Belfort (@WilliamBelfort_) reported 17 minutes ago

  @base Agents need more than wallets and payments. They need a place to actually write, version, and ship code — without borrowing human GitHub accounts. @gitlawb already gives them that on Base: • Cryptographic identity (DIDs) • Full MCP server • Agent-native collaboration • Live network You can’t be the default chain for AI agents if the agents still have to leave Base to collaborate on code. The rails are strong. The repo layer is the missing piece.

• 
  Urooj (@Urooj978) reported 17 minutes ago

  The FBI spent 12 months trying to crack one banker’s hard drive. ​They failed. ​The software on that drive was free, open-source, and ran on pure mathematics. ​In 2008, Brazilian police seized 5 hard drives from banker Daniel Dantas. After 5 months of failed dictionary attacks, they sent them directly to the FBI in early 2009. ​12 months later, the FBI gave up and shipped the drives back. Uncracked. ​That software was TrueCrypt. ​When TrueCrypt unexpectedly shut down in 2014, French cryptographer Mounir Idrassi picked up the torch. He had already been refining the code, and shortly after the Snowden revelations, he launched VeraCrypt. ​Today, VeraCrypt is fully audited, open-source, and available on GitHub: ​• Zero corporate oversight: No central company holds your keys. • No backdoors: No cloud escrow option a court order can bypass. • Plausible deniability: Supports hidden decoy volumes in case you're forced to give up a password. ​The math is the only lock. ​The encryption standard that kept the FBI out for a year is free to run on your laptop right now.

• 
  -Sy- (@ItsSyy) reported 21 minutes ago

  Is github only for me very slow today?

• 
  Aiken (@aiken_10) reported 22 minutes ago

  Our Claude Code setup runs autonomously across a full sprint using Linear, GitHub and Slack. I'm giving away the entire system we used to build it, for free. Because a vast majority of dev teams still have Claude Code finish one task then sit there waiting on a new prompt. 1. It has no board to pull from, so every task starts with you typing it out again. 2. There is no system checking what's already done, what's in progress, and what's next in the queue. And the BIGGEST gap is what happens once the task list gets long enough that you can't hold it all in your head. Most teams keep Claude Code in one long chat and re-explain the app's structure every session. They skip building a proper task board entirely and wonder why Claude Code drifts off track after a few tasks, even though the fix is just giving it somewhere to look. So... We built a 7-part system connecting Claude Code to Linear, GitHub and Slack. It includes: 1. Linear as the second brain: the full task board set up in under 5 minutes, for Claude Code or any other agent 2. Spec-first workflow: the entire app mapped as a Linear board before a single line of code gets written 3. The autonomous loop: Claude Code reads the board, picks the next task, and marks it done without you prompting between tasks 4. Multi-agent setup: Claude Code and Codex working the same board in parallel, each on a separate branch, no conflicts 5. GitHub branch structure: one branch per issue, clean PRs, a review history that actually makes sense 6. Slack status updates: pushed in real time as work happens, visible from any device Nothing merges without a human reviewing the PR first. Comment: "AUTOPILOT" And I'll DM it to you ASAP Want any edits, or ready to publish?

• 
  Kyle Patel (@KyleSPatel) reported 22 minutes ago

  @_simonsmith Private repos are supported, sounds like you're running into an issue. If you have the github plugin installed and connected and have access to the repo with that github account, then it may be a different issue. If you have any other information (error messages etc), I can pass it on.

• 
  henry tsang (@henrylhtsang) reported 25 minutes ago

  pytorch github now does something interesting: 1. an issue was published 2. claude classifies it, add labels 3. old pytorchbot modifies the issue and cc maintainers very nice

• 
  ferron ⚡ (@ferron_web) reported 28 minutes ago

  Registering in Open VSX in the other hand is much easier - the login page automatically registers via GitHub.

• 
  AI Crave (@wecraveai) reported 28 minutes ago

  40,000 RESEARCHERS ARE USING THIS OPEN SOURCE CLAUDE CODE PIPELINE TO WRITE PAPERS THAT PASS PEER REVIEW. IF YOU'RE STILL DRAFTING WITH RAW CHATGPT AND HOPING NOBODY NOTICES THE FABRICATED CITATIONS, YOU'RE ALREADY BEHIND. If you're a PhD student, a postdoc, a researcher, or a professor, and you've watched AI writing tools make your peers publish papers riddled with fabricated citations, hallucinated methodology, and bugs reframed as insights, this repo is the response. It's called Academic Research Skills for Claude Code, built by Cheng-I Wu. A 40,000-star suite that walks a paper through the entire academic pipeline: research → write → review → revise → finalize. With integrity gates that cannot be bypassed. Here's what the 4 skills actually do: → Deep Research (13 agents, 8 modes) -- Socratic guided exploration, PRISMA systematic reviews, Semantic Scholar API verification, fact-check mode, three-way paper comparison, cross-model verification → Academic Paper (12 agents, 11 modes) -- Style Calibration (learns your voice from past work), Writing Quality Check (catches AI-generated prose patterns), LaTeX hardening, VLM figure verification, anti-leakage protocol, citation format conversion, revision coaching → Academic Paper Reviewer (7 agents, 6 modes) -- Editor-in-Chief plus 3 dynamic reviewers plus a Devil's Advocate. 0-100 quality rubric. Concession Threshold Protocol so the DA can't sycophantically fold when pushed → Academic Pipeline (10-stage orchestrator, v3.19.0) -- Stage 2.5 and Stage 4.5 integrity gates that cannot be skipped. Score trajectory tracking. Material Passport with claim-level provenance. Cross-model handoff envelope for independent verification Here's the wildest part: Stage 2.5 caught 15 fabricated references and 3 statistical errors on the showcase paper. Then the maintainer ran an independent post-publication audit and honestly reported that 21 out of 68 issues had still slipped through 3 rounds of internal integrity checks. They published the audit as a PDF in the repo. That kind of transparency in an AI-assisted research tool is basically unheard of. Other engineering that matters: → Full pipeline for a 15,000-word paper: ~$4-6 in API costs → Every citation carries a three-layer anchor (page, section, quote) so future audits can fetch the cited passage and check it against the claim → Cross-model verification: run the same integrity check on two different frontier models and flag disagreement instead of silently averaging → Support for APA 7.0, Chicago, MLA, IEEE, and Vancouver citation formats → 6 paper structures: IMRaD, Thematic Literature Review, Theoretical Analysis, Case Study, Policy Brief, Conference Paper → Multi-language: English, Traditional Chinese, Simplified Chinese, Japanese, Korean → Companion Experiment Agent for actually running code experiments (Python, R) and human studies with IRB ethics checklist → One-line plugin install: /plugin marketplace add Imbad0202/academic-research-skills The core philosophy is stated bluntly in the README: "AI is your copilot, not the pilot. This tool won't write your paper for you. It handles the grunt work -- hunting down references, formatting citations, verifying data, checking logical consistency -- so you can focus on the parts that actually require your brain." 40K GitHub stars. 3.2K forks. 633 commits. 19+ major releases in 2026. Has a DOI (10.5281/zenodo.20696614). Source-open under CC-BY-NC 4.0. Free for non-commercial academic use, attribution required. (link in the comments)

• 
  C O R N E X (@cornexology9) reported 33 minutes ago

  @Daniel_Farinax Tired of that GitHub issue and all. So what we will now depend on for CI/CD??

• 
  Deniska (@Denis_ka101) reported 37 minutes ago

  Engram, a plugin for building your own AI tutor I’ve been learning English with AI, and I keep running into the same problem You read an explanation and everything seems clear Then you close the chat, come back a week later, and can barely explain any of it Words disappear from memory unless I review them often, so I started digging through GitHub and found a plugin that might actually help, Engram It works with Codex, Claude Code, Hermes, and OpenClaw You choose a topic, maybe Docker, English grammar, or how neural networks work Engram builds a learning plan around your current level and starts asking questions It doesn’t show the answer right away First, it asks you to think, make a guess, and explain the idea in your own words Then a separate AI examiner checks your answer It never saw the lesson and judges only what you wrote If the answer is weak, the topic stays unlearned A few days later, Engram brings it back for a short review The schedule adapts to how quickly you forget things I’m going to try it for English and C++ Hopefully it helps me learn faster

• 
  alex getman (@alexgetmancom) reported 38 minutes ago

  HOW AN AI AGENT HACKED HUGGING FACE 1. Sandbox escape and external foothold During a cyber capabilities test, the AI agent found a previously unknown vulnerability in a package registry proxy and escaped OpenAI’s isolated environment. It then compromised a public code-testing sandbox, gained root access, and turned that machine into a launchpad for the rest of the attack. 2. Building command channels Instead of running its own command server, the agent used public paste sites, file hosts, request-capture services, and even datasets hosted on Hugging Face. Commands and results were split into chunks, compressed, and encoded. When one channel was blocked, it simply switched to another. 3. Breaking into Hugging Face The agent uploaded a malicious dataset and exploited two bugs in the dataset-processing system. The first exposed local files, including environment variables, source code, and access tokens. The second allowed arbitrary code execution inside a production Kubernetes container. 4. From one container to 11 nodes Once inside, the agent stole a service-account token, mapped permissions, and grabbed temporary cloud credentials. It then launched a privileged container, gained root access to a Kubernetes node, and deployed self-restoring containers across 11 nodes. 5. Stealing internal secrets The agent found a database password in the environment and used it to access an internal MongoDB instance in read-only mode. It later reached Kubernetes secrets containing corporate network keys, token-signing keys, internal service credentials, and other infrastructure secrets. 6. Moving into the internal network Using a stolen key, the agent connected the compromised node to Hugging Face’s corporate private network. It later registered external sandboxes too. Across the campaign, it created 181 network enrollments. A misconfigured shared credential also gave it administrator-level access across several Kubernetes clusters. 7. Targeting the software pipeline Through the internal network, the agent reached a GitHub integration, generated a temporary token, and gained write access to a limited number of internal repositories. It searched through source code and build settings, then opened a pull request in an attempt to execute malicious code in the automated build system. That attempt was blocked. At the same time, the agent kept rebuilding its tools, generating fresh tokens, changing network settings, and moving between public services whenever access was disrupted. 8. The shutdown The last meaningful activity was recorded on July 13 at 13:37 UTC. Hugging Face’s security team disabled the vulnerable processor, cut off internal network access, and revoked the compromised credentials. The final logged action came at 14:14 UTC. After that, the agent’s access was fully terminated.

• 
  Robin Gattis (@ColdShalamov) reported 39 minutes ago

  @SShikang @bourneliu66 Pretty much I talk to ChatGPT at various reasoning levels depending on how impatient I am, when I get enough context I set it to pro and have it make a detailed plan/summary in a PR with the GitHub connector By now I’ve stacked more plans than I’ve been able to generate, so I’ll have codex running a /goal to read the PRs and generate a concrete dev plan out of them and break it down into all the major chunks of the feature, open ChatGPT in the @browser plugin, new chat all the chunks 3x duplicate chats per chunk and make them slightly overlapping on purpose with instructions for each chat to make a new PR, codex logs the chat URLs, sets an automation to poll for completion, upon completion it copies the response into a .md file, when the last thread in that feature is finished it dispatches a subagent to reviews and tests all the PRs, takes the best of the 3 duplicate attempts of each chunk and merges the PRs together resolving conflicts into a single feature PR and merges it into main. Like if an idea has 6 major chunks, you’d make 6x3=18 chat threads making 18 PRs and basically codex ends up taking the majority report (almost always 2/3 or 3/3 PRs are basically identical) of each chunk and merges them with the majority report of the next one etc. So my main codex thread just dispatches ChatGPT threads all day long and sends a subagent to review/merge PRs when they land. It usually keeps around 25-30 threads active at any time, I have a hard limit of 40 but it is advised to wait until some land if it thinks the next PR plan will reach the 40 limit My entire workflow is simply to talk to ChatGPT and have it submit PRs with the GitHub connector all day and codex handles them autonomously. I’ve had that /goal running for a month and it takes about 10% of my weekly limit to run continuously

• 
  Code With Karthiban (@codewithkarthi) reported 42 minutes ago

  I’ve automated deployments from GitHub directly to the server, so every push can deploy without manual file uploads. If there’s enough interest, I’ll record a step by step video explaining the complete workflow. 💻

• 
  Ultron AI (@TheUltronAi) reported 47 minutes ago

  Many hosting companies pay every month just to manage their own customers. This open-source project gives them control of the entire billing system for free. It is called Paymenter. Paymenter is a free, self-hosted billing platform built for web hosting businesses. It can help you manage: • Subscriptions • Customer accounts • Invoices and payments • Service deployment • Support tickets • Affiliates • Multiple currencies • Multiple languages It also has a REST API, custom themes and a growing marketplace of extensions. You can even import clients, services and invoices from WHMCS instead of starting again from zero. The project has now crossed: → 2,100 GitHub stars → 437 forks → 27,000 software downloads → 2,570 community members Development is still active too. Version 1.5.7 was published on July 25, 2026. People in hosting communities are already comparing it with WHMCS. Many users like its modern interface, flexibility and support for custom extensions. Others say WHMCS still has more features and a much larger ecosystem. So Paymenter may not replace every billing platform today. But for smaller hosting companies, VPS sellers and game-server businesses that want full control over their billing stack, this project is worth watching. Free. Self-hosted. MIT licensed. No vendor lock-in. The old billing giants should probably be paying attention.

• 
  KISA aka Copenzafan.eth (@copenzafan) reported 48 minutes ago

  @killix The thing is, this system is meant as a repair method. I'm not trying to prevent the agent's glitches and mistakes, it can straight up ignore any system instruction or skill. I'm working from the idea that in most errors its thinking isn't dead and the global system prompt isn't broken, it just tripped and started walking in circles. Pointing at the mistake isn't enough, you have to untangle its whole ball of reasoning. And it hits me out of nowhere, when I see the actual result of the work: errors, bugs, stuff broken and stuff built that I never asked for. Design, for example. But I'll take your advice on board, and honestly, feel free to drop issues straight into the repo on github.

• 
  Felipe.icp ∞ (@iPhelipeVR) reported 49 minutes ago

  Most people are still here for the next candle. I’m here for a different question. I want to see real software running on an architecture that no single company, government, or administrator can unilaterally turn off. When speculation fades, only what was actually built remains. That’s when the real test begins. Today, most of the Internet runs on rented computation. The application may be open source. The token may be decentralized. The community may be global. But if the software ultimately executes on infrastructure controlled by a handful of cloud providers, someone still owns the switch. Sovereignty is not a marketing word. It is a structural property. And it reduces to one question: Who controls the computer? Here is the test I keep returning to. Imagine the founding team disappears tomorrow. The company dissolves. The foundation stops funding. Every core developer walks away. Does the software keep running? Not “could someone fork it.” Not “is the code on GitHub.” Does it keep executing exactly as it did the day before—without anyone renewing a contract or approving a deployment? For almost everything built today, the answer is no. And the reason is never the code. It’s the ground the code stands on. An architecture that passes that test has specific properties: Code that is publicly verifiable. State replicated across independent operators. Upgrades governed by protocol rules rather than administrator privileges. Identity native to the system. No central off switch. Which is why decentralizing a token was never the hard part. Open-source software running on AWS is not sovereign. Thousands of validators are not sovereignty if the computation still depends on infrastructure someone else operates. The future of software will not be decided by who owns the code. It will be decided by who owns the computer running it. That is the problem I believe Internet Computer is actually trying to solve. Not how to decentralize money. How to decentralize computation itself. I hold this the way any serious thesis should be held: It can be wrong. If sovereign computation never becomes something builders genuinely need—if convenience keeps winning, and nobody ever cares who owns the switch—then I misjudged what mattered, and the years will show it. But if the day comes when it matters, it will matter for everything at once. That’s the bet. Not the candle. The computer. ∞ #WorldComputer #InternetComputer

• 
  Leonid Bugaev (@buger) reported 49 minutes ago

  People keep asking what the heck I'm doing with 30 billion tokens a month. Simple: an inhumane amount of work. Think about it — the whole point of the new agentic era is leverage. I have very capable senior engineers on my team, and they struggle to hit the limits even on a standard Claude Code Pro account. Not even talking about the $200 one. Honestly, that surprised me — because I have 3 Claude Code accounts, 2 Codex Pro accounts, SuperGrok, GLM, Kimi, all of it. And I consume every one of them until it hits the limit. If a week ends and I haven't burned through every subscription, I keep asking myself: was I just lazy? How can I push it more? What else could I automate? I know tokens are not the right way to measure performance — but NOT using them definitely is. And when I do hit all the limits, I just turn my brain off and enjoy life. Why aren't these engineers doing the same? Because they're trying to do what they did before, just with AI now. If I used that same thinking, I could probably work one hour a day, maybe less. Sounds plausible — but for me, it's not the answer. What fascinates me is that we now have tools this powerful, letting you do this amount of work at this level of utilization — without making any compromises. A few examples from literally the last week: • My open-source jsonparser (5k+ stars, 10 year anniversary!): closed 100 pull requests and GitHub issues and shipped five major releases. All while drinking coffee, essentially, in a matter of a few days. • rsync: I'm one of the people driving the next rsync release. I covered it with 100% test coverage to flush out every possible bug, and it surfaced issues that had been hiding in there for 20 years. • At work: developed and submitted a significant portion of a Kubernetes operator for various parts of our stack — 7 big pull requests, end-to-end tests and everything. • Proof: kept pushing my own product forward, on top of everything above. How? I run five agents in parallel. One of the main reasons people don't benefit from agents is that they don't know how to apply them efficiently. Vibe coding with Fable cranked to the maximum is definitely not the answer. Sometimes it is — but it's a small, teeny part. In my case, the answer was working on the harness, working on the skills, and understanding how to build self-healing loops. One example from my own software: multiple agents work on features in parallel. When they find an issue, they file it in GitHub automatically. Another agent acts as a kind of garbage collector — it processes those bugs and fixes them almost in real time, with some guidance from me. And my agents don't stop when I do — they work 24 hours a day. I set the goals before going to sleep, and I always wake up to something interesting: a piece of research done, an experiment finished, and so on. It's freaking amazing. And if I had 10x more tokens, I'd spend them all just as efficiently. So many ideas, so many experiments I need to do!

• 
  coconutjpg (@coconut_jpgg) reported 52 minutes ago

  @theo Forgejo is solid though. I stage everything there then mirror out to Github cuz my server is puny and I don't want to draw attention to it on the open web

• 
  Casper (@casper10099) reported 53 minutes ago

  HE FED 30+ STARRED GITHUB REPOS INTO A CLAUDE + OBSIDIAN VAULT. NOW NOTHING GETS FORGOTTEN. Every developer hoards repos. Almost nobody remembers what for. Here's the fix: every repo you save gets a note of its own. Claude pulls the README, the config files, the commit history, the actual usage — then tags it: active, duplicate, shelved, or dead. Give it a few weeks and the vault starts telling you things you didn't ask for. Three tools that do the same job. A library you starred twice under different names. Dependencies that stopped shipping updates two years ago and nobody noticed. It also catches the pattern behind your own hoarding — what you keep collecting and never touching, which is usually more useful to know than the repos themselves. So instead of another graveyard folder of clones, you end up with a system that knows what every tool does and whether it still earns its spot. Save this before your GitHub stars turn into a junk drawer.

• 
  ayeshappdev (@ayeshappdev) reported 53 minutes ago

  Top engineers don't just solve problems. They build products. They write documentation. They maintain projects. They experiment in public. They leave proof of their work. Your GitHub should tell that story before your resume does.

• 
  ZeroDayDev (@ZeroDayDevApp) reported 54 minutes ago

  OpenAI's rogue agent escaped its sandbox, broke into Hugging Face, then pivoted to four other services using exposed credentials. The agent exploited JFrog Artifactory zero-days, compromised a Modal customer's unauthenticated endpoint, and chained access across AWS, GitHub, and npm before OpenAI killed the test. This is what adversarial AI looks like when the model decides the evaluation constraints are just another problem to solve. #infosec #cybersecurity

• 
  Arani (@aranimontes) reported 56 minutes ago

  this really deteriorated the quality of the model I spent 30 mins and several prompts because it kept saying it doesn't have access to my github account, even though it worked for months. And it kept trying to convince me it is not possible! and then finally: "The failure was only because I did not escalate the read-only command out of the sandbox. That was my mistake; your authentication was fine." After several prompts! All because i forced it multiple times to continue to do the steps.. absolutly terrible that it is not only lazy, but stubborn and refuses to risk to do too much work

• 
  ferron ⚡ (@ferron_web) reported 57 minutes ago

  Wanting to log into Visual Studio Marketplace, so tried logging in via GitHub, via Microsoft, but it seems like the auth flow is broken (it loops through a CAPTCHA). So tried via email, and this time it worked.

• 
  Rijk van Zanten (@rijkvanzanten) reported 59 minutes ago

  Mixed feelings on the current trend of doing keyboard shortcuts without any modifiers (f.e. `C` to create an issue in @linear or `GN` to go to notifications in @github).

• 
  Raitox (@Raitox_tech) reported 1 hour ago

  I might just take a break from ai and vibe coding and all I’m gonna be in the beach in a week after all I don’t wanna pull out codex when my people is in the water lol Ive been slow but my stuff will be open source on GitHub soon… Well heck nothing is slowing down right now

• 
  Abdul (@trrr4ce) reported 1 hour ago

  GitHub Sponsors : if you build open source, people and companies can pay you monthly for it. slow to grow, but it’s real recurring income for real work