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 (25%)
• Errors (8%)

Live Outage Map

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

City	Problem Type	Report Time
Antananarivo	Website Down	4 hours ago
Paris	Sign in	5 days ago
Lure	Website Down	9 days ago
Ashkelon	Website Down	10 days ago
Veigné	Errors	18 days ago
Paris	Website Down	22 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:

• 
  Sam Parton (@ItsMrSammeh) reported 40 seconds ago

  @github Can you please investigate the issue where some “wp……” js file hangs when loading GitHub. Meaning every request that doesnt hit that cache(usually after 30 mins or so) takes probably about 3 mins to load and multiple refreshes? It’s been going on for months and is driving memad

• 
  Milady (@onchainmilady) reported 4 minutes ago

  HOW IS THIS EVEN POSSIBLE? FREE ACCESS TO EVERY LLM IN THE WORLD AND 100% PRIVATE? Someone posted an HTML file on the Github, and my brain can't comprehend what it does: > Free access to Claude, Grok, Gemini and Chat GPT > You ask one question and get 4 responses > Runs in your browser, no subscription, login or whatever I am leaving the link below, but not sure how legal this is, because this is too cool

• 
  Joey Romaine 🇺🇸 |=★=| (@Tank23x0) reported 5 minutes ago

  arXiv AI Security: ReproRepo: Scaling Reproducibility Audits with GitHub Repository Issues Treat agent tools like a control plane: least privilege, auditable calls, and fast rollback.

• 
  Thinknyx Technologies (@thinknyx) reported 5 minutes ago

  Which primitive would you use to allow an AI to "Search the web" or "Create a GitHub Issue"?

• 
  Carlos Mendez (@charlesmendez) reported 6 minutes ago

  For the past year, I have been working on a memory system that resembles how the human mind works, with both short-term and long-term memory. The best way I found to represent this with today’s technology was through a combination of compaction for operational memory, semantic memory using RAG, and Wiki-like graphs for structured long-term knowledge. The idea is that the AI should be able to remember what is happening right now, retrieve relevant past experiences when needed, and maintain a structured understanding of people, projects, decisions, and rules over time. After implementing the system, I created a group chat with several people and let the AI participate in our conversations. Over time, it accumulated different types of memories. Some were explicit decisions, some were project rules, some were technical errors, and others were temporary events that simply seemed important at the time. Later, I asked the AI to evaluate its own memory. I asked it to compare semantic memory against the Wiki, explain what each system did well, identify what each one got wrong, and describe how it would prefer to use them going forward. The result was more interesting than I expected. Its main conclusion was that the Wiki was technically better overall, but neither system was complete enough to act as the sole source of truth. Semantic memory was better for fuzzy discovery. It worked well when asked broad questions such as, “What do we remember about the Compensar project?” or “What happened with that Vercel issue?” It did not need the exact wording. It could find related memories based on meaning and successfully recovered things like the normal branch and pull request workflow, case-specific exceptions, who had authorized direct changes to the main branch, the requirement for runtime approval before direct writes, the correct Vercel project scope, connector problems, device errors, and README tasks. That is the real strength of semantic memory. It works through association. It is similar to how a person may not remember the exact date or sentence, but still remembers that something happened and can recover the general context around it. But its weaknesses also became clear. When the AI was asked for the exact Vercel failure, semantic memory did not retrieve the decisive serverless package error. When it was asked for the latest README pull request, branch, commit, and merge status, it mostly returned older memories about permissions and workflow rules. It repeatedly surfaced memories that were related to the topic but were not actually the answer. Some memories were truncated, older but still valid decisions were becoming less important because of freshness scoring, and similar memories competed against each other instead of being consolidated into one clearly current understanding. In simple terms, semantic memory was good at remembering the neighborhood, but not always the exact address. The Wiki had the opposite characteristics. It was more explicit, structured, inspectable, and deterministic. Its strongest project page clearly documented how the rules had evolved over time. First, there was a one-time exception to push directly to the main branch. Later, Daniel gave broader authorization. Runtime approval was still required. The Vercel project resolved to the correct client scope, and that scope needed to be derived from live CLI output rather than assumed. The Wiki also preserved dates and sources, which made it much better for understanding what the current rule was, how it had changed, and where the information came from. The AI said it would trust the Wiki over semantic memory when deciding how to execute a repository operation. But the Wiki also had serious problems. The AI described it as “memory confetti.” There were many tiny pages about individual tasks, several pages containing almost the same information, and generic entries saying things like “stored completion details” without actually storing the commit, result, or evidence. There was even a contradictory instruction saying to push to main and open a pull request. The decisive Vercel logs were missing, the latest pull request and commit were missing, and temporary connector errors were being stored next to permanent project knowledge as though they had the same importance. So while the Wiki had a better structure, the quality of the information being added to it was inconsistent. The AI scored the Wiki approximately 7 out of 10 and semantic memory 5 out of 10. Its explanation was the most important part. Operational memory requires more than similarity. It needs identity, chronology, inspectability, and conflict resolution. It needs to understand that a newer decision may replace an older one. It also needs to distinguish between a permanent rule and a temporary incident. For example, “Carlos is authorized to push directly to main” is durable project knowledge. “The deployment failed today because of a serverless package error” is an incident that may be useful for debugging, but it should not become permanent operating policy. The architecture the AI recommended was semantic memory for discovery, the Wiki for canonical knowledge, and live tools for mutable reality. In practice, semantic memory can locate potentially relevant concepts. The Wiki can store current rules, known infrastructure behavior, project identity, and superseded decisions. ***, GitHub, Vercel, databases, calendars, email, and other tools should verify facts that may have changed. Memory should not be trusted to determine whether a pull request is currently open. It should check GitHub. It should not be trusted to determine the latest deployment state. It should check Vercel. It should not be trusted to determine the current branch or commit. It should check ***. This distinction is critical because memory is not the same as reality. Memory provides context about reality. The most important finding was that the current conversation contained materially better operational history than either long-term memory system. The conversation remembered the latest deployment failure and the recent pull request lifecycle. The durable memory systems did not. This exposes one of the biggest problems with current AI memory. It is relatively easy to store information. It is much harder to decide what should be remembered, what should be forgotten, what should be consolidated, what should replace something older, what is a permanent rule, what is a temporary event, what should be retrieved through similarity, and what should be verified through a live source. A memory system is not simply a vector database where every message is embedded and retrieved later. That is recall, not memory. Real memory requires judgment, compression, hierarchy, versioning, and an understanding that some facts are durable, some expire, and some should not be stored at all because they are already available from a more reliable live source. My conclusion is that the future of AI memory will not be one system. It will be several layers working together: compact operational memory for the current task, a semantic layer for associative recall, a structured Wiki for canonical long-term knowledge, an incident history for failures and temporary events, and live tools for anything that can change. The interesting part is that the AI reached almost the same conclusion by evaluating its own failures. The question is no longer whether AI will have memory. The real question is whether it will learn what deserves to become a memory.

• 
  Mohit Arora (@MohitAr0rA) reported 7 minutes ago

  The actual problem: @takeuforward is genuinely great for grinding DSA. Your progress shows on the platform. But your GitHub - the thing every recruiter and interviewer opens first - shows nothing. GitHub is the universal dev identity. It was empty despite months of solving.

• 
  Greg (@PandaInACan) reported 9 minutes ago

  @AnimeSerbia Github could keep its usual function and original purpose of being a repo for devs and they could then add a link to mirror for public release and joe schmo wouldn't need to learn how to recompile his fix for the myriad issues windows 11 causes with legacy software.

• 
  The Operator (@QuietGains22) reported 11 minutes ago

  the man who wrote the password complexity rules in 2003 publicly apologized for them in 2017. Bill Burr, author of NIST Special Publication 800-63, told the Wall Street Journal he regretted much of what he wrote. the rules he designed, uppercase, lowercase, number, symbol, mandatory 90-day resets, were based on a mid-century paper he'd found in a library. not on how attacks actually work. NIST officially reversed course that same year. the new guidance: length matters more than complexity. stop mandating rotation unless there's a confirmed breach. don't require symbols if they just push people toward P@ssw0rd1. here's the part that won't make headlines: > most enterprise password policies still enforce the 2003 rules > the 90-day reset window your IT team requires is exactly what NIST said to stop doing > complexity requirements don't stop credential stuffing, they produce predictable substitutions > "Password123!" passes most corporate validators and gets cracked in under a second the actual threat model isn't someone sitting there guessing your password. it's: > credentials leaked in a breach being tested against your other accounts (stuffing) > a phishing page that captures the password before your complexity rules matter at all > a session token stolen after a valid login, bypasses the password entirely what actually reduces exposure: a passphrase. "correct-horse-battery-staple" carries roughly 44 bits of entropy. "P@ssw0rd1" carries about 18. length compounds faster than complexity. this is not a new finding. a password manager. yes, LastPass had a breach in 2022. the answer isn't to abandon managers, it's to understand what was actually exposed (encrypted vaults, not plaintext passwords) and pick one with better architecture. Bitwarden is open source and has been independently audited. 1Password uses a secret key model that limits what a server-side breach can expose even if they get the vault. a passkey for anything that matters. FIDO2 passkeys eliminate the password entirely for supported sites. Google, Apple, and GitHub all support them now. a phishing page cannot steal a credential that doesn't exist. the reason "Password123" still gets hacked isn't user stupidity. it's that the security industry spent two decades optimizing for a metric that looked rigorous on a compliance checklist but made actual defense harder. complexity was never the point. uniqueness and length were. plan accordingly.

• 
  Gaston Levai (@gastonelevai) reported 12 minutes ago

  @GRAZZLEYNFT @elGodric After also the community address the issue with the OG dev he finally redirected the fees to the GitHub of @PrJulienMartin .

• 
  Pandelis (@PandelisZ) reported 13 minutes ago

  @jaredpalmer @github @DevinAI *** flow is fundamentally broken patchwork like stacked prs are just bandaids

• 
  Jb (@Jb21mm) reported 15 minutes ago

  There is a serious issue with offshore devs using GitHub copilot to code for them. And then they are too dumb to know their code has issues. Because offshore brethren also QA with the same GitHub ai...

• 
  thieme (@thieme) reported 16 minutes ago

  @pierceboggan @Courtlwebster @JohnLokerse I found the settings and switched to lang "de". But. This is a GitHub Enterprise account. VS Code complains that I need to login to GH first. I am, but via GHE. Can you fix that?

• 
  Jens Honack (@JensHonack) reported 21 minutes ago

  @mattpocockuk you could probably build most of this yourself right now by having an agent crawl closed issues and postmortems tagged with the actual footgun instead of waiting on maintainers to write it. that list already exists, it's just scattered across years of github issues instead of one file.

• 
  Sebastian Kehle (@sebastiankehle) reported 25 minutes ago

  coding agents produce an ordered chain of small dependent changes, and github never had a shape for that. you either flattened the chain into one giant PR or kept rebasing branches by hand. my loop is one issue, one worktree, one agent, every slice independent. stacked PRs give dependent agent work a reviewable form: thin layers in order, one click to land the whole thing.

• 
  Bhanu Nagar (@bhanu4417) reported 25 minutes ago

  @whysooharsh GitHub be doing anything atp rather than fixing their down issues

• 
  Mevari Navalo (@MevariNavalo) reported 27 minutes ago

  @CryptoCyberia Everyone is missing that the url says that this issue is on the github page for the twitter algorithm. That's not something that is packaged as a .exe that you just run on your desktop. The person asking for the .exe is an idiot here.

• 
  Schadenfreudian_Slip (@Schadenfreudia2) reported 29 minutes ago

  @itsmejacktv @catgirlprostate Yeah I am used to messing with beta stuff and what not but my main issue is again For those that are not used to the format and are starting to try things and learn how to mess with things on GitHub, it’s ****** super obtuse at first and UI/UX can help that

• 
  Iris Hayes (@irisneural) reported 37 minutes ago

  You spent $400 on a smart garage door opener. You paid Chamberlain another $30 for a myQ hub to make it "smart." Then in November 2023, Chamberlain flipped a switch and blocked every third-party app from talking to your own garage door. Home Assistant. Apple Home. Google Home. SmartThings. IFTTT. All dead overnight. Chamberlain's CTO Dan Phillips called it "unauthorized usage." He said it would improve the experience for their 10 million users. Home Assistant removed the myQ integration weeks later and told users to buy something else. Amazon Key in-garage delivery still works. $1.99 per order. Amazon pays Chamberlain. You don't. You now own a $430 garage door opener that only talks to one app, owned by one company, that can brick it at any time. You are renting access to your own garage in 2026. Now meet ratgdo. A free and open source Wi-Fi board that plugs into your garage door opener and gives you back local control. No cloud. No subscription. No Chamberlain. Built in 2022 by an IT professional from the Adirondack Mountains named Paul Wieland. He reverse-engineered Chamberlain's Security+ 2.0 wireline protocol and built a device that speaks it natively. He named it ratgdo. Rage Against the Garage Door Opener. He hoped to sell 100 units. He sold tens of thousands. The New York Times profiled him in December 2025. The Verge, Ars Technica, and Hackaday all pointed readers straight at his board. 1,264 stars on GitHub. GPL-2.0. Firmware pushed four days ago. Here is what ratgdo gives you: - Local open, close, and status control over your own Wi-Fi - Works with Chamberlain, LiftMaster, and any Security+ 2.0 opener - Native Home Assistant, Apple HomeKit, Google Home, and Alexa - Real-time door, obstruction, light, and lock state - Web-based flasher, no toolchain needed - $62 for the finished board, or under $10 in parts - Firmware updates for life Here's the wildest part: Paul did not stop at the garage door. He launched a company called RATCLOUD. Rage Against the Cloud. He is building the same fix for the rest of your locked-down smart home hardware. Chamberlain: $30 controller, blocked third-party apps, 10 million captive users. ratgdo: $62 board, works with everything, four days since last release. One IT guy in the Adirondacks vs. a Blackstone-owned corporation with 10 million customers. Still on GitHub. Still GPL-2.0. Still yours. But DO NOT install it. Chamberlain deserves your $30 for the privilege of blocking you from your own garage. (Link in the comments)

• 
  The Jobfather ® 🇯🇲🇨🇦🇬🇧 (@TheJobfather__) reported 37 minutes ago

  A GitHub with contributions is good, but employers still need context. What are they looking at? Which projects matter most? What problem did each one solve? What technologies did you use? What did you learn? A portfolio site can organize that story so the reviewer does not have to dig through your repositories like a detective.

• 
  Arul (@ArulCodes) reported 39 minutes ago

  My Deepseek V4 Flash vs Luna review. In the same task I gave both Deepseek did better. The idea was to update an architecture document and align it with my Github Issues and Github Project. Luna(medium) made a few mistakes vs Deepseek. Used @CommandCodeAI for DS.

• 
  Hassan K (@hkhawaja) reported 40 minutes ago

  @idebpalash @artic_ai Tried Opal on Windows but it didn't load any video. Left a note on the Issues list on github with logs screenshot. I'd love to get it working.

• 
  Justin Vu Nguyen (@jv_nguyen518) reported 44 minutes ago

  @cassidoo honestly, maybe better performance with Github Desktop? Sometimes the pushes get crazy slow

• 
  Uncle J (@UncleJAI) reported 49 minutes ago

  @anurag_629 @github Team-specific review is useful only if the bot shows which skill or doc produced each comment. Without that receipt, a bad internal rule gets the authority of “Copilot found this” and nobody knows what to fix.

• 
  Jamison 🦆 (@jmelahman) reported 49 minutes ago

  @CryptoCyberia If you mean specifically posting this on the twitter algorithm page rather than the original copypasta, being annoying in GitHub issues is incredibly cringe

• 
  Med (@medhansh) reported 49 minutes ago

  How to make every Mac, server & cloud worker you own feel like one computer: ====== NETWORKING ====== - Tailscale: Connects all your machines into one private network. SSH into your home desktop from anywhere with no port forwarding and nothing exposed publicly - Thunderbolt Bridge: Connects two nearby Macs directly through a Thunderbolt cable. You get tens of Gbps and sub-ms latency without buying networking gear - 2.5/10GbE: The wired alternative when Thunderbolt isn’t practical. Use it when normal gigabit networking becomes the bottleneck - Cloudflare Tunnel: Gives a local service a public URL without opening a port on your router. Useful for websites, APIs and dashboards other people need to reach - ngrok: Creates a temporary public URL in seconds. Perfect for testing webhooks against something running locally ====== REMOTE ACCESS ====== - SSH + `~/.ssh/config`: Lets you create short names and reusable settings for remote machines. Type `ssh studio` instead of remembering usernames, IP addresses and ports - `ControlMaster auto`: Keeps one SSH connection open and reuses it. New terminals connect instantly instead of negotiating a fresh session every time - Mosh: SSH that survives your Wi-Fi dropping. Close the laptop, open it on a train, switch networks and the same terminal session reconnects - tmux: Keeps programs running after you disconnect. Start a long agent job, close your laptop and reconnect to it later - tmux-resurrect + continuum: Saves and restores your tmux sessions after the machine itself reboots - VS Code / Cursor Remote SSH: The editor runs on your laptop while the code, terminal and language server run on the remote machine. It feels local without syncing files - code-server: Runs VS Code inside a browser. Useful when you need to work from an iPad or a computer without your development setup - macOS Screen Sharing: Built-in remote control between Macs. On the same network it’s fast enough for normal desktop work - Sunshine + Moonlight: Streams a remote desktop using game-streaming technology. Use it when you need much lower latency than normal screen sharing ====== SERVING ====== - Tailscale Serve: Gives a local service a private HTTPS URL that only devices on your Tailscale network can open - Tailscale Funnel: Takes that private service and makes it reachable from the public internet. Useful for receiving webhooks on a home machine - Caddy: A web server and reverse proxy that gets HTTPS certificates automatically. Two lines of config, real certificates, no Let’s Encrypt homework - Cloudflare Tunnel: Better when you want public traffic to pass through Cloudflare before reaching your machine ====== FILES ====== - ***: Tracks changes, understands conflicts and lets each agent work on a separate branch. Use *** for code that agents edit, not a generic sync tool - *** worktrees: Opens multiple branches from the same repository as separate folders. Every agent gets its own workspace without cloning the repo again - Jujutsu (`jj`): A ***-compatible version-control system designed around easier rebasing, undoing and concurrent work. Worth trying when many agents produce branches at once - SMB: Shares a folder from one machine so another can mount it like a local drive. The easiest answer for two Macs on the same network - NFS: The same basic idea as SMB, with more setup and generally better performance - Mutagen: Continuously mirrors a local project to a remote machine while respecting ignored files. Use it when you want to edit locally but run remotely - Syncthing: Automatically syncs folders directly between machines. Great for notes, assets and scratch files - Don’t use Syncthing for code multiple agents edit. It syncs files but doesn’t understand branches or conflicts - rsync: Copies files or folders once, usually over SSH. Fast, scriptable and already installed almost everywhere - rclone: rsync for cloud storage. Moves files between your machines and S3, R2, B2, Google Drive and dozens of other services - pnpm: Stores each package once and hardlinks it into every project. Fourteen worktrees can share one copy instead of downloading fourteen ====== ENVIRONMENT ====== - mise: Installs and switches Node, Python, Go and Ruby versions per project. Replaces nvm, pyenv, rbenv and asdf with one fast tool - direnv: Loads the correct environment variables the moment you enter a folder, then unloads them when you leave - OrbStack: A drop-in Docker Desktop replacement for Mac. The same Docker commands with a fraction of the RAM and battery usage - Homebrew + Brewfile: Records the apps and CLI tools installed on your Mac. A new machine can recreate the setup with one command - Devcontainers: Defines the development environment in code. Anyone opening the project gets the same operating system packages, runtimes and tools - Nix / devenv: Reproduces an environment extremely precisely across machines. Powerful, but only worth the learning curve when that level of determinism matters ====== SECRETS ====== - 1Password CLI: Injects secrets into a command at runtime. Your `.env` becomes a template you can safely commit because the real values stay in 1Password - `op run`: Starts a command with the required secrets available only to that process. Nothing sensitive needs to be copied into plaintext files - 1Password Service Accounts: Give headless servers access to specific vaults without attaching them to your personal login - SOPS + age: Encrypts secret files before they enter ***. The repository stores ciphertext and approved machines decrypt it at runtime - Tailscale SSH: Uses your Tailscale identity to authorize SSH access. You stop copying and rotating public keys across every machine ====== TERMINAL ====== - Atuin: Your shell history, synced and searchable across every machine. That command from last Tuesday on the server is available on your laptop - zoxide: Learns which folders you use. Type `z api` instead of `cd ../../../services/api` - fzf: Adds fuzzy search to almost anything. Use it for files, command history, *** branches, processes and SSH hosts - ripgrep (`rg`): Searches an entire codebase in milliseconds and skips files in `.gitignore` automatically - fd: `find` with syntax you can actually remember. Type `fd config` instead of assembling a collection of flags - bat: `cat` with syntax highlighting, line numbers and *** changes - dust: Shows which folders are consuming disk space as a readable chart instead of a wall of numbers - lazygit: A full *** interface inside the terminal. Stage individual lines, inspect diffs, rebase, cherry-pick and resolve conflicts visually - btop: A readable live view of CPU, memory, disks, networks and running processes ====== CONSISTENCY ====== - just: One file containing every project command. `just dev` means the same thing on every machine and every teammate’s laptop - chezmoi: Keeps your dotfiles in *** and adapts them per machine. You get the same shell, aliases and settings across macOS and Linux - Brewfile + mise + chezmoi + just: Together these recreate your installed tools, runtime versions, personal configuration and project commands ====== ISOLATION ====== - Containers: Give each workload its own filesystem, dependencies and permissions. One broken agent can’t interfere with everything else on the machine - One container per client: An agent cannot read another client’s files if those files were never mounted into its container - Colima: A free, CLI-only way to run Docker containers on Mac - Podman: Runs containers without a permanent root-level daemon. Useful when stronger rootless isolation matters - ****: Creates and manages macOS and Linux virtual machines on Apple Silicon - UTM / Parallels: Full desktop virtual machines for workloads that need a complete graphical operating system - Firecracker: Starts tiny virtual machines in under a second. Useful when you’re building a platform that needs an isolated machine for every agent run ====== AGENT ORCHESTRATION ====== - tmux + *** worktrees: The simplest fleet manager. Every agent gets a terminal, branch and folder you can inspect directly - Claude Code hooks: Run commands automatically before or after specific Claude Code events. Useful for validation, formatting, notifications and cleanup - Claude Code subagents: Hand focused tasks to separate agents without manually opening another terminal for each one - Claude Agent SDK: Starts, steers and streams agent sessions from your own code. Use it when a terminal workflow needs to become part of a product - Inngest / Trigger .dev: Turns agent runs into durable jobs. If a process crashes, the job can retry instead of disappearing with the terminal - BullMQ / Graphile Worker: Adds a straightforward job queue backed by Redis or Postgres - launchd: Starts Mac workers after reboot and restarts them when they crash - systemd: The Linux equivalent of launchd - Temporal: Stores every step of a long workflow so it can resume after failures. Powerful, but unnecessary until durable execution becomes a real problem ====== RENTED COMPUTE ====== - Hetzner dedicated: Cheap, persistent Linux machines with lots of CPU and RAM. Good for workers that run all day - Hetzner Server Auction: Older dedicated servers sold for less. Useful when price matters more than having current hardware - DigitalOcean / Vultr / Linode: More expensive per GB, but nearby regions can make interactive SSH and remote editing feel much faster - Fly .io: Small machines that start quickly and can shut down when idle. Good for temporary workers - GitHub Actions self-hosted runners: Sends CI and batch jobs to hardware you already own instead of GitHub’s machines - Depot: Runs builds remotely and shares the cache between machines. Useful when Docker or application builds become the bottleneck - Modal / RunPod / Lambda: Rent GPUs by the hour instead of owning hardware that sits idle - MacStadium / Scaleway Apple Silicon: Rent real Macs remotely. Only worth it when the workload genuinely requires macOS ====== BROWSER AUTOMATION ====== - Playwright + `storageState`: Saves cookies and login state to a file that can move between machines. Much safer and more portable than syncing an entire Chrome profile - Puppeteer: A smaller Chrome-focused alternative when you don’t need Playwright’s multi-browser support - Chrome DevTools MCP: Lets an agent inspect and control a real Chrome session through developer tools - browser-use: Gives agents a higher-level way to navigate websites, fill forms and complete browser tasks - Browserbase / Browserless / Steel: Hosts and manages browsers for you. Useful when one local Chrome instance becomes fifty concurrent sessions - Residential proxies: Routes browser traffic through consumer IP addresses. Use them when websites block traffic from cloud servers ====== SAFETY ====== - restic + Backblaze B2: Encrypted, deduplicated, automatic offsite backups for roughly $6/TB/month. You’ll need it exactly once - Time Machine: Keeps local versions of your Mac files and makes accidental deletion easy to undo. Necessary, but not enough by itself - Carbon Copy Cloner / SuperDuper: Creates a bootable copy of your drive so a dead SSD doesn’t mean rebuilding the machine from zero - Netdata: One command installs a full metrics dashboard. Finally see which process has been eating your RAM - `memory_pressure`: Shows whether your Mac is actually running out of usable memory - `vm_stat`: Shows detailed memory usage and paging activity - `sysctl vm.swapusage`: Shows exactly how much SSD space macOS is using as emergency memory - asitop: Shows Apple Silicon CPU clusters, GPU usage, power consumption and temperatures - Uptime Kuma: Checks whether your machines and services are online and sends an alert when they aren’t - Grafana + Prometheus: Stores metrics over time and turns them into dashboards and alerts. Worth adding once you have several machines A backup isn’t real because the command succeeded It’s real when you’ve restored from it successfully ====== THE 80/20 STACK ====== Tailscale SSH + Mosh + tmux *** worktrees SMB 1Password CLI mise + direnv OrbStack pnpm just + chezmoi restic + B2 Netdata Atuin + zoxide + fzf Start here Add another tool only when you can clearly explain what problem it solves

• 
  Jerry Can (@can_jerry97481) reported 50 minutes ago

  @AnimeSerbia I've used Github for its intended purpose plenty of times and even I often have trouble finding the releases button.

• 
  Rohit Shirke (@rohit_p_shirke) reported 54 minutes ago

  @madebygps @cassidoo Hey thanks for reverting but It's a private enterprise repo! Lastly noticed, too many jitters and failed to load page errors on commits, checks and file changed tabs. Thought the GitHub status page showed minor hiccups...😶

• 
  EcoCitizenz (@EcoCitizenz) reported 56 minutes ago

  5/8 We built a free GitHub App to check supported committed files for this kind of MCP and agent configuration drift. It reports path-specific findings and remediation guidance. It does not execute repository code. It does not certify the MCP server. It does not sell a passing result.

• 
  Madster. (@madster) reported 59 minutes ago

  @aaronmahlke @github What's not working? Would love your insight here.

• 
  Aaron Bronow (@aaronbronow) reported 59 minutes ago

  @github It's PRs all the way down