GitHub Hot — 26 May 2026

Top 10 repos trending on GitHub this week — what they do, why they matter, and how to use them in your projects.

1. perplexityai/bumblebee

3,079 stars this week · Go · golang package-inventory supply-chain-security

Bumblebee is a zero-dependency Go binary that inventories every package, extension, and MCP server config on a developer's machine and flags exact version matches against a known-bad exposure catalog — read-only, no package-manager execution, output is queryable NDJSON.

Use case

When a supply-chain advisory drops (xz-utils backdoor, malicious npm package, compromised VS Code extension), you need to know within minutes which machines are affected — not what shipped in your container, but what's actually installed on each developer's laptop right now. Bumblebee answers this by walking lockfiles, dist-info directories, and extension manifests directly, without shelling out to npm/pip/go, and returns structured records you can filter instantly. Concrete example: a new advisory names lodash@4.17.20 — you run bumblebee scan --catalog=advisory.json across your team's machines via an MDM script and get a flagged NDJSON hit list in seconds, not hours.

Why it's trending

The MCP (Model Context Protocol) server ecosystem exploded in early 2025 and Bumblebee explicitly inventories MCP host configs as a scan source — making it one of the first tools to address supply-chain risk in AI tool configurations, a brand-new attack surface most dev teams haven't audited at all. Perplexity open-sourcing a Go-native, zero-dependency binary that requires no agent install also resonates strongly with ops and security teams burned by heavy CSPM tooling.

How to use it

Download the pre-built static binary for your platform from the releases page or go install github.com/perplexityai/bumblebee@latest.
Run a project-scoped scan: bumblebee scan --profile=project /path/to/your/repo — this reads lockfiles (package-lock.json, yarn.lock, go.sum, pnpm-lock.yaml) without executing any package manager.
Inspect the NDJSON output: each line is one component record with fields like {"name":"lodash","version":"4.17.20","ecosystem":"npm","source":"package-lock.json"}.
Build or download an exposure catalog (OSV-format JSON) and pass it: bumblebee scan --profile=project --catalog=osv-advisory.json ./ | jq 'select(.flagged==true)' — only matched records are emitted when a catalog is provided.
Pipe into CI: add a bumblebee scan --profile=baseline --output=inventory.ndjson step in GitHub Actions and diff against yesterday's snapshot to detect unexpected new packages on every push.

How I could use this

Write a deep-dive post titled 'I ran Bumblebee on my Next.js project and here's what it found' — scan Gradland's own package-lock.json, show the raw NDJSON output, cross-reference the flagged packages against the OSV database, and explain what each means. This is SEO gold for 'supply chain security Next.js' queries and directly ties into the existing Bumblebee post already in content/posts/.
Add a 'Dependency Risk' card to Gradland's resume analyser flow: when a user uploads their project's package.json, extract the dependency list server-side, query the OSV API for known CVEs against each pinned version, and have Claude Haiku write a one-sentence 'clean bill of health' or flag summary. Australian enterprise employers (Big4 consulting, banks) explicitly ask about supply-chain awareness in senior dev interviews — surfacing this as a talking point in the resume feedback increases the tool's career value signal.
Build a GitHub Actions composite action called 'gradland-supply-check' that runs Bumblebee on the repo, pipes the NDJSON into a Claude Haiku call that maps any flagged packages to their OSV advisory summaries, and posts a formatted PR comment with a risk brief. Ship it as a public reusable action — it's a credible open-source portfolio piece that demonstrates both Go tooling integration and AI-powered security automation, directly relevant to DevSecOps roles that are well-represented in Australia's 482/494 sponsored tech positions.

2. thananon/9arm-skills

2,339 stars this week · Shell

A curated, installable collection of Claude Code skills (slash commands) covering engineering, productivity, and debugging workflows — shareable via npx.

Use case

Claude Code's skills system lets you define reusable slash commands that inject structured prompts and scripts into any Claude session. Without a community library, you'd hand-write every custom workflow from scratch and lose them when you switch machines. This repo solves the 'where do I find real-world skill examples?' problem — e.g., instead of ad-hoc debugging prompts, you run /debug-mantra and Claude follows a four-step structured discipline (reproduce → trace fail path → falsify hypothesis → cross-reference breadcrumbs) before touching any code.

Why it's trending

Claude Code's skills/slash command feature is newly GA and the ecosystem is still thin — this is one of the first community-maintained skill packs, so it's getting outsized attention as the reference implementation for how to structure and distribute skills. The npx skills CLI for installing them is also brand new tooling.

How to use it

Install the skill pack: npx skills add thananon/9arm-skills — this drops SKILL.md files into ~/.claude/skills/,2. Restart Claude Code (or open a new session) — skills are picked up automatically at session start,3. Use a skill in any Claude Code session: type /debug-mantra to activate structured debugging, or /scrutinize to trigger an outsider-perspective code review,4. Fork the repo and add your own skill: create skills/engineering/my-skill/SKILL.md with frontmatter name: my-skill and description: what it does, then symlink via ./scripts/link-skills.sh,5. Publish your own pack: npx skills publish your-github-handle/your-skills-repo — others can install it with the same npx command

How I could use this

Build a gradland-content skill that encodes your exact frontmatter schema (from lib/posts.ts) and SEO rules — so any Claude session can generate a new post/digest/githot entry that passes your validate-content.ts script on the first try, without you pasting the schema each time.
Write a supabase-migration skill that enforces your §10 database rules (RLS template, index checklist, no-drop guard, sequential migration numbering) — Claude invokes it before writing any .sql file and refuses to proceed if the migration would drop columns without flagging it for human review.
Create a rate-limit-audit skill that runs a scrutinize-style pass specifically over new API route files, checking for the exact three-step pattern from AGENTS.md §5.1 (requireSubscription → checkEndpointRateLimit → recordUsage) — catches billing liabilities before they hit CI.

3. open-gsd/get-shit-done-redux

1,058 stars this week · JavaScript · claude-code context-engineering meta-prompting spec-driven-development

A lightweight system for maintaining high-quality AI context and prompts, solving 'context rot' in tools like Claude, Copilot, and GPT-based systems.

Use case

This repo addresses the issue of 'context rot,' where the quality of AI responses degrades as the context window fills up. For example, if Henry's blog uses AI to generate posts or summaries, the AI's performance may drop over time without proper context management. This tool ensures consistent quality by optimizing meta-prompting and context engineering.

Why it's trending

It's gaining attention due to its focus on solving a critical issue in AI workflows—context degradation—which is increasingly relevant as developers integrate large language models into production systems. The recent security audit and migration announcement also boosted visibility.

How to use it

Install the package: npm install @opengsd/get-shit-done-redux.,2. Import the library into your project: import { GSD } from '@opengsd/get-shit-done-redux';.,3. Initialize GSD with your AI tool configuration: const gsd = new GSD({ model: 'Claude', maxContext: 8000 });.,4. Use GSD to manage context dynamically: gsd.updateContext('new prompt or user input');.,5. Integrate into your AI workflows, e.g., blog post generation or summarization pipelines.

How I could use this

Use GSD to optimize AI-generated blog posts by dynamically managing context, ensuring high-quality content even for long-form articles.
Integrate GSD into a portfolio tool that uses AI to generate tailored resumes or cover letters, maintaining consistent tone and relevance across iterations.
Leverage GSD for an AI-powered feature that provides real-time editorial feedback or suggestions while writing, ensuring the AI doesn't lose track of the user's intent.

4. Tong89/smartNode

1,021 stars this week · Python

A local simulation platform that models satellite constellations, ground stations, and relay scheduling with a live REST API — useful for anyone building spatial network visualizations or studying LEO data-relay architectures.

Use case

The real problem: there's no lightweight, zero-auth local tool to prototype and visualize how satellite relay networks schedule data transmission tasks across dynamic resource pools. Concrete scenario — a researcher wants to demo how a LEO constellation degrades gracefully when two ground stations go offline; they POST tasks to /api/request, adjust satellite count via /api/update_leo_satellites, and watch resource utilization shift in the 3D frontend without touching a cloud provider or signing an NDA.

Why it's trending

Starlink's developer API and the proliferation of small-sat programs (Amazon Kuiper, SpaceX gen2) have pushed satellite network simulation from niche academia into mainstream dev tooling; SmartNode is one of the few MIT-licensed, runnable-in-5-minutes options that doesn't require a MATLAB license or a NASA account.

How to use it

Clone and spin up: git clone https://github.com/Tong89/smartNode.git && cd smartNode && python -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt && python backend/app.py
Open http://127.0.0.1:5000/frontend/ — you get the live 3D constellation view immediately.
Poll real-time state: curl http://127.0.0.1:5000/api/data returns JSON with satellite positions, ground station health, and relay link status.
Submit a data-relay task: curl -X POST http://127.0.0.1:5000/api/request -H 'Content-Type: application/json' -d '{"data_type": "imagery", "priority": "high", "size_mb": 200}'
Stress-test the scheduler by reducing LEO satellites: curl -X POST http://127.0.0.1:5000/api/update_leo_satellites -d '{"count": 3}' — watch utilization spike in /api/resource_utilization.

How I could use this

Write an interactive blog post titled 'How Starlink Actually Schedules Your Data' — embed a live iframe of SmartNode running on a cheap VPS (add nginx basic-auth as the README warns), then annotate the 3D view with callouts explaining LEO handoff windows. It's a visceral explainer that no static diagram can match and will rank for satellite networking searches.
Build a 'Satellite Career Readiness' metaphor tool: map Henry's visa/job readiness checklist onto the SmartNode scheduler model — each 'ground station' is a requirement (skills, visa status, references), each 'relay task' is a job application. Use /api/resource_utilization data structure as inspiration for a Supabase-backed readiness score that shows which bottlenecks are blocking the user's 'data relay' (job offer) from completing. It's a memorable UI hook that differentiates Gradland from plain checklists.
Wrap SmartNode's core.py scheduling engine in a Claude tool-use call: let users describe a network constraint in plain English ('I have 4 satellites, 2 ground stations, and 50GB of imagery to downlink in 6 hours — is that feasible?') and have Claude call /api/request + /api/resource_utilization in a loop, then summarize the simulation result. This gives Henry a concrete 'AI + simulation API' portfolio demo showing agentic tool use against a real stateful backend — more impressive than yet another chatbot.

5. run-liyi/wechatpay

736 stars this week · JavaScript

A local Electron app that parses WeChat Pay CSV exports and renders spending analytics — no data leaves your machine.

Use case

Chinese developers living in Australia often maintain dual financial lives — WeChat Pay for remittances, local transfers, and purchases from Chinese merchants, plus Australian bank accounts. Reconciling WeChat spending manually is painful because the CSV export is raw and hard to read. This app ingests that CSV, auto-classifies transactions by merchant/type/payment method, and renders trend charts, merchant rankings, and exportable Excel summaries — giving you a clean picture of your WeChat cash flow in minutes.

Why it's trending

736 stars in a week suggests viral sharing within Chinese developer communities, likely driven by tax season and the growing population of international students and 482/485 visa holders who need to reconcile WeChat Pay for Australian tax returns or bank loan applications.

How to use it

Export your WeChat bill: WeChat → Me → Services → Wallet → Bill → (...) → Download Bill → select '用于个人对账' (personal reconciliation) → enter email → decrypt the zip with the password WeChat sends via notification.
Clone and run the app locally:

git clone https://github.com/run-liyi/wechatpay
npm install
npm start

In the Electron UI, import the decrypted Excel/CSV file.
Explore the dashboard: overview stats, merchant rankings, daily/weekly/monthly trend charts, and payment method breakdown.
Export the analysis to a multi-sheet Excel file for tax records or bank submissions.

How I could use this

Write a 'WeChat Pay for Australian visa applications' guide on the blog — explain how to use this tool to produce a clean 12-month spending summary that satisfies 482/485 financial evidence requirements, with screenshots of the export workflow. High-intent SEO for the exact audience Gradland serves.
Build a lightweight server-side version of this CSV parser (no Electron, just a Next.js API route) that accepts a WeChat CSV upload, runs the same classification logic, and feeds the output into Gradland's salary/budget tool — letting users compare their actual WeChat spending against the ACS salary benchmarks for their visa subclass.
Feed parsed WeChat transaction data into Claude Haiku to generate a personalised 'financial narrative' — e.g. 'You spent 68% of your WeChat budget on food delivery, which is 2x the median for your city. Here are three ways to reduce it.' Position it as an AI finance coach feature gated behind the Pro subscription.

6. MoonshotAI/kimi-code

704 stars this week · TypeScript

Kimi Code CLI is a terminal-based AI coding assistant that can analyze, edit, and execute code, making it a powerful tool for developers working on complex projects.

Use case

Kimi Code CLI solves the problem of context-switching and repetitive coding tasks by allowing developers to interact with an AI agent directly in their terminal. For example, if you're debugging a Next.js app, Kimi can analyze your codebase, suggest fixes, and even execute commands to test changes without leaving the terminal.

Why it's trending

The repo is gaining traction due to its seamless integration of AI into the terminal workflow and its support for Moonshot AI’s advanced models. Its recent release with a polished TUI and unique features like video input has generated buzz in the developer community.

How to use it

Install Kimi Code CLI using the provided script for your OS:,For macOS/Linux: curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash,For Windows: irm https://code.kimi.com/kimi-code/install.ps1 | iex,Navigate to your project directory: cd your-project,Run the CLI: kimi,Log in using /login and follow the prompts to authenticate with Kimi Code OAuth or an API key.,Start interacting with the AI by typing commands like: Take a look at this project and explain its main directories.

How I could use this

Integrate Kimi Code CLI into the blog's backend development workflow. Use it to automate code reviews or generate documentation for your Next.js and TypeScript components, then showcase this process in a blog post about 'How AI Can Assist in Modern Web Development.'
Build a career tool where Kimi Code analyzes a developer's GitHub repositories and generates personalized suggestions for improving their code quality or portfolio projects. This could be a feature on your blog or a standalone tool.
Leverage Kimi Code's ability to fetch web pages and analyze code to create an AI-powered blog post generator. For example, it could analyze trending GitHub repositories and auto-generate blog drafts summarizing their features and use cases.

7. kageroumado/phosphene

686 stars this week · Swift · animated-wallpaper desktop-wallpaper macos macos-wallpaper

Phosphene turns any MP4/MOV into a live macOS desktop/lock-screen wallpaper by plugging into Apple's private WallpaperExtensionKit — the same framework that powers Aerials.

Use case

macOS has never had a first-party way to use custom videos as wallpapers. Phosphene solves this by reverse-engineering Apple's private Aerial infrastructure so your videos appear natively in System Settings → Wallpaper — not as a janky window sitting behind your desktop, but as a real OS-managed wallpaper that survives sleep, lock, and app quits. Concrete scenario: you shoot a 4K timelapse of your city and want it as your lock-screen wallpaper with the same smooth fade-in that Apple's own Aerials use.

Why it's trending

macOS 26 (Tahoe) just shipped WallpaperExtensionKit as a new private framework, and Phosphene is the first public project to reverse-engineer and document its XPC interface — so it's the go-to reference for any macOS dev curious about what Apple built. The 686 stars in a single week suggest it's riding the Tahoe beta hype cycle hard.

How to use it

Clone and open in Xcode 16+: git clone https://github.com/kageroumado/phosphene && open Phosphene.xcodeproj
Build and run the menu bar target — macOS will prompt you to allow the wallpaper extension in System Settings.
In the menu bar icon, click 'Import Video' and select an MP4 or MOV file.
Open System Settings → Wallpaper — your video now appears alongside Apple's Aerials; select it per-display.
Tune power policy in the menu bar (e.g., pause on battery, drop to 720p when thermals spike) via the PlaybackPolicy config panel.

How I could use this

Write a teardown post for your blog: 'How Phosphene reverse-engineered WallpaperExtensionKit' — walk through the dlopen + Mirror-based introspection technique with annotated Swift snippets. This is catnip for iOS/macOS devs and will rank for 'WallpaperExtensionKit macOS Tahoe' searches for months.
For your career tools: build a 'portfolio screencaster' CLI that records a short screen capture of a candidate's terminal/IDE workflow and exports it as an MP4 — then document how to set it as a Phosphene wallpaper during a live interview to flex their environment. Niche but memorable as a 'show your setup' feature on a resume/portfolio page.
AI angle: use Claude + AVFoundation to auto-generate a 30-second ambient loop from a single still image (via a diffusion API like Replicate's img2video), then auto-import it into Phosphene via its import path — a 'generate my wallpaper from a prompt' feature that chains Claude (for visual description) → img2video → Phosphene import script. Blog it as a full walkthrough.

8. 0xSero/codex-shim

631 stars this week · Python

A local Python proxy that translates Codex Desktop's OpenAI Responses-API calls into whichever upstream model you actually want to use — Claude, Gemini, DeepSeek, or local — without touching the Codex binary.

Use case

Codex Desktop hardcodes which models appear in its picker via server-side config; if you have Anthropic or Gemini API keys, you can't route Codex's native agent loops through them without rebuilding the app. The shim runs on loopback, intercepts every /v1/responses call Codex makes, rewrites it for the configured upstream (Anthropic Messages API, OpenAI chat completions, OpenRouter, etc.), and translates the streaming response back into the SSE shape Codex expects — including function calls, tool outputs, and reasoning blocks. Concretely: you point Codex at http://localhost:9099, add Claude Sonnet to models.json, and it appears as a first-class picker entry with full agent-loop fidelity.

Why it's trending

OpenAI released Codex Desktop as a native coding agent this month, and developers immediately ran into the BYOK wall — the app only surfaces OpenAI-approved models while Claude 4 and cheaper alternatives sit idle. This shim is the first clean answer to that gap, which is why 600+ stars landed in one week.

How to use it

Clone and install: git clone https://github.com/0xSero/codex-shim && cd codex-shim && pip install aiohttp
Create ~/.codex-shim/models.json with your upstream — e.g. {"models": [{"id": "claude-sonnet-4-6", "provider": "anthropic", "apiKey": "sk-ant-..."}]}
Start the shim: python shim.py --port 9099
In Codex Desktop settings, set API base URL to http://localhost:9099
Your custom models now appear in the picker with native tool-call and streaming support intact.

How I could use this

Wire Claude Sonnet into Codex Desktop via the shim for writing and editing blog posts in content/posts/ — Codex's agent loop handles multi-file edits (frontmatter, slug, image alts) while the shim routes the actual inference to Anthropic, letting Henry use his existing ANTHROPIC_API_KEY quota instead of paying OpenAI rates.
Adapt the shim's provider-routing pattern for Gradland's interview prep feature: build a thin request classifier in app/api/interview/mentor/route.ts that inspects question complexity and routes to claude-haiku-4-5-20251001 for simple follow-ups and claude-sonnet-4-6 for full mock answers — same UX, halved token cost on high-volume sessions.
Use the shim's prompt-injection hook as the blueprint for a system-prompt middleware in Gradland's API layer: before every Claude call in lib/claude.ts, inject a career-context header (target role, visa subclass, years-of-experience) derived from the user's profile row, so every AI feature personalises automatically without each route handler needing to re-fetch that context.

9. zhaoyue4810/pianke

435 stars this week · Python

A local-first, AI-powered photo culling tool that groups burst shots by visual similarity using DINOv2 + face recognition, then forces you through A/B matchups to pick winners — all without uploading a single pixel to the cloud.

Use case

After a wedding or portrait session you might have 800 near-identical shots from a 10-second burst. Pianke clusters them into 'same moment' groups using DINOv2 semantic embeddings fused with EXIF timestamps and face identity, auto-rejects technically broken frames (blurry, closed eyes, blown highlights), then runs you through left/right keyboard duels within each group. You only make decisions on the interesting comparisons — not on 800 individual images.

Why it's trending

DINOv2-powered local tooling is hitting a sweet spot right now: people want AI quality without cloud dependency or per-image API costs. The 'Tycoon' mode — where a multimodal LLM explains rejections in plain language ('the kid on the left blinked') — demonstrates a sharp UX pattern that's landing at the same moment GPT-4V and Qwen-VL have become cheap enough to use on media assets.

How to use it

Clone and install: git clone https://github.com/zhaoyue4810/pianke && cd pianke && pip install -r requirements_fast.txt (Fast mode, ~200MB) or requirements_expert.txt for DINOv2 (~2-3GB + 600MB model download on first run).,2. Launch the web UI: python app.py — opens a localhost page where you pick a mode (Fast / Expert / Tycoon) and point it at a local photo folder.,3. Let the pipeline run: it scans EXIF, extracts embeddings, clusters into moment groups, and auto-rejects technical rejects. First Expert run downloads the DINOv2 checkpoint.,4. Enter the A/B arena: use ←/→ keys to pick the better of two side-by-side photos. Undo with Ctrl+Z, redo a whole group, or skip — progress saves to the folder so you can quit mid-session.,5. For Tycoon mode, set an API key (VOLCENGINE_API_KEY, OPENAI_API_KEY, or DASHSCOPE_API_KEY) in .env — the LLM will annotate each reject with a plain-language reason you can review before confirming.

How I could use this

Write a deep-dive post on the DINOv2 grouping pipeline: extract the core embedding + clustering logic from Pianke, adapt it to a Python script that groups a folder of screenshots or UI mockups, and publish it as 'I used Meta's DINOv2 to auto-organise 500 dev screenshots' — concrete enough to rank for developer image-AI searches and demonstrate hands-on ML work.
Port the A/B tournament UI pattern to Gradland's resume bullet editor: present two phrasings of the same bullet side-by-side ('Led migration of legacy auth system' vs 'Cut auth load time 40% by migrating to JWT + Redis'), let users pick the stronger one with a single keypress, and log wins to surface the best bullet variant — the same elimination logic Pianke uses, applied to text.
Implement a 'Tycoon-style' rejection explainer in the resume analyser: instead of returning a score, call claude-haiku with the resume section and job description and return a one-sentence plain-language verdict ('This bullet reads as a task list, not an achievement — add a metric') — mirrors how Pianke's Tycoon mode explains 'left subject has eyes closed' rather than outputting a confidence float.

10. KNG7-P/Se7en-Pro

376 stars this week · C#

A clean-room C#/WPF/.NET 8 UI shell for Psiphon's censorship-circumvention tunnel — a reference implementation showing how to wrap a headless network proxy binary with a polished MVVM desktop app.

Use case

Building a consumer-grade Windows app around a tunneling binary (Psiphon, Xray, WireGuard, etc.) normally means wiring up process management, tray icons, settings persistence, and IPC from scratch. This repo solves that: it's a production-ready scaffold — single-instance mutex, system tray, named EventWaitHandle for re-launch, CDN-fronting helpers — so you can drop in any tunnel binary and get a Material Design 3 UI for free. Concrete example: a company deploying a custom WireGuard client for remote staff could fork this instead of writing 3,000 lines of WPF boilerplate.

Why it's trending

Xray-core (XTLS) + wintun system-wide tunneling integration is newly included, which is exactly what developers building 'next-gen' VPN UIs in China and Iran are searching for right now. The combination of a legitimate MIT-licensed UI scaffold with Xray's VLESS/XTLS transport hit the circumvention developer community at the right moment.

How to use it

Clone the repo and open PsiphonUI.sln in Visual Studio 2022+ with .NET 8 SDK installed.
Obtain a Psiphon sponsor config (psiphon_config.json with your credentials/server list) from Psiphon Labs and drop it into Resources/.
Build in Release mode — the bundled psiphon-tunnel-core.exe and xray.exe are already embedded as resource files.
To swap in your own tunnel binary, replace the Process.Start call in Services/TunnelService.cs and wire up your binary's stdout JSON notices to the existing INoticeParser interface.
Extend the Settings page (ViewModels/SettingsViewModel.cs + Views/SettingsPage.xaml) with your own config fields — CommunityToolkit.Mvvm's [RelayCommand] and [ObservableProperty] attributes keep the boilerplate minimal.

How I could use this

Write a deep-dive post for Gradland's blog: 'How international students in restricted countries can access Australian job boards and career tools' — PSiphon/Xray are the actual tools many 485 visa holders used before arriving in Australia. This targets a real SEO gap (people searching 'access seek.com.au from China') and positions Gradland as a resource that understands the actual lived experience of your audience, not just the visa paperwork.
No direct career-tool integration — this is a Windows desktop app in C#, orthogonal to your Next.js stack — but the CDN-fronting pattern (routing requests through Akamai/Cloudflare edge nodes to bypass deep-packet inspection) is directly applicable if you ever need Gradland's API to be reachable from countries that block Australian SaaS. Document how you'd add a Cloudflare Worker reverse-proxy as a 'fronting' layer for your Supabase edge functions, framed as a reliability feature for users still based overseas.
Build a 'connectivity checker' micro-feature in Gradland: a lightweight Next.js API route that probes whether common Australian job/visa sites (seek.com.au, immi.homeaffairs.gov.au, acs.org.au) are reachable from the user's IP, then surfaces a banner suggesting circumvention tools if latency exceeds a threshold. Use Claude Haiku to generate a one-paragraph plain-English explanation of why a specific site might be blocked in the user's detected country — turns a dry network diagnostic into genuinely useful onboarding content.