GitHub Trending Weekly Digest — September 7–12, 2026

This week on GitHub was, more than anything, the week of the agent skill. Nearly half the repos that trended were some flavor of "teach your AI coding assistant to behave better" — skill catalogs, agent harnesses, workflow frameworks, and one gloriously blunt plugin that just tells the model to stop rambling. Alongside that, a couple of stunning browser-native visualization projects, a self-hosted CRM movement, and the usual sprinkle of anti-censorship and interview-prep classics.

I pulled the daily Top 5 from September 7 through 12, deduplicated everything by repository URL, and ranked what's left by trending persistence — how many separate days a project held its spot. Eighteen unique projects made the cut. Here's the rundown.

🏆 Chart-Toppers (3+ Days)

These are the repos that didn't just spike — they stuck around.

i-have-adhd

🔗 github.com/ayghri/i-have-adhd — on the board 4 days

What it does: A skill/plugin for AI coding assistants (Claude, Cursor, Gemini, Kimi, Qwen) that forces them to answer in a direct, actionable style — next step first, numbered steps, no filler.

Why it matters: We've all been there: you ask a coding question and the assistant buries the actual answer under "Great question!" and three paragraphs of preamble. This project fixes that with ten blunt communication rules — lead with the action, number multi-step tasks, cap lists at five items, kill the opening and closing pleasantries. It cuts your reading time and cognitive load, and it clearly struck a nerve: four straight days trending, including a monster +4,650-star day. The name is cheeky, but the underlying idea — that response format is a real UX problem — is dead serious.

Tech: Not really a codebase, more a prompt-engineering framework. Ten formatting rules live in a SKILL.md file, packaged with a JSON manifest (plugin.json, opencode.json) for cross-platform install. Platform-agnostic, MIT-licensed, and built to be forked and customized.

diagram-design

🔗 github.com/cathrynlavery/diagram-design — on the board 3 days

What it does: A skill for AI agents (Claude Code, Codex, Factory Droid, Pi) that generates 39 types of editorial-quality diagrams, output as self-contained, offline-ready HTML + SVG files styled to your brand.

Why it matters: The author's pain point is instantly relatable — ask Claude to draw a diagram and you get "a generic rounded box that clashes with your whole website." The alternatives were grinding away in Figma for half an hour or just not making the diagram at all. This skill removes that friction, producing on-brand visuals in minutes. It enforces taste through strict design constraints: one accent color, 1px hairlines, no drop shadows, coordinates snapped to a grid — a deliberate rejection of generic AI aesthetics.

Tech: HTML5 + SVG on the front (self-contained, no external scripts by default); Python for the extraction and validation scripts; Playwright/Chromium for optional PNG export. It parses draw.io, Mermaid, and Excalidraw files, auto-extracts brand colors and fonts from your website, and uses semantic routing so the agent only loads the specs it needs.

God's Eye View

🔗 github.com/bilawalsidhu/gods-eye-view — on the board 3 days

What it does: An open-source, browser-only spatial intelligence platform that overlays live global data — planes, ships, satellites, earthquakes, wildfires, traffic, public cameras — onto a photorealistic 3D globe.

Why it matters: Public geospatial data is scattered across a dozen sites — one for flights, another for ships, another for orbital tracking. God's Eye View fuses thirteen live data layers onto a single interactive Earth, effectively democratizing capabilities that used to live only in professional intelligence software. You can click to track a target, switch to night-vision or thermal sensor styles, fly along in "cockpit mode," and even drive the whole interface with AI voice commands. It's the kind of project that makes you lose an hour just poking around.

Tech: Vanilla JavaScript + CesiumJS for the 3D globe, built with Vite, using Google Photorealistic 3D Tiles and WebGL for rendering. The OpenAI Realtime API powers hands-free voice control (with 28 integrated tools). Data comes from open sources like OpenSky (flights), AISStream (ships), CelesTrak (satellites), USGS (earthquakes), and NASA FIRMS (fire). All API keys are brokered server-side so credentials stay protected.

📈 Multi-Day Risers (2 Days)

Repos that showed up twice — strong signal, still climbing.

ECC

🔗 github.com/affaan-m/ECC — on the board 2 days

What it does: An open-source "agent harness" that wraps AI coding with a full engineering workflow — planning, testing, implementation, review, and continuous learning — across multiple AI coding platforms.

Why it matters: Coding with a raw agent has a few chronic problems: the plan gets buried in chat history where you can't review it as a real artifact, the model forgets instructions like "use TDD" mid-session, the same context both writes and reviews the code (so it's grading its own homework), and hard-won lessons don't survive across sessions. ECC's philosophy is "optimize the context window, persist everything else to disk," turning rigorous engineering habits from suggestions into enforced structure.

Tech: Multi-language (TypeScript/JavaScript, Python, Shell, Go) with a plugin architecture that natively hooks into the Claude Code plugin marketplace, plus adapters for Codex, Cursor, Gemini, and Zed. It ships 68 specialized agents, 286 skills, and 94 commands, along with AgentShield security scanning and a Memory Vault, backed by SQLite state storage and MCP support. Requires Node.js 18+.

skills (OpenAI)

🔗 github.com/openai/skills — on the board 2 days

What it does: OpenAI's official Agent Skills catalog for Codex — packaging instructions, scripts, and resources into reusable folders so the agent completes specific tasks in a consistent way.

Why it matters: It tackles the standardization problem of packaging and distributing AI capabilities: a unified, discoverable format so teams can reuse ready-made skills instead of rewriting code. Worth noting — this repo is now deprecated, with the README steering people toward the newer openai/plugins repository. Still trended for two days on the strength of the idea alone.

Tech: Mostly Python. Skills come in three tiers (.system / .curated / .experimental) and install via the $skill-installer command inside Codex — curated ones by name, experimental ones via GitHub URL — with a Codex restart to activate.

Superpowers

🔗 github.com/obra/superpowers — on the board 2 days

What it does: A software-development framework built for coding agents that combines reusable "skills" with bootstrap instructions to walk an AI through the full development lifecycle — design, implementation, code review.

Why it matters: Agents tend to jump straight into writing code with no plan and no design validation. Superpowers enforces discipline: nail down requirements first, hand the design to a human for approval, write a detailed plan, implement with TDD, run a code review, and only then deploy. It fills in the methodology and quality gates that AI-assisted development usually skips.

Tech: A composable set of workflow skills — Socratic-style brainstorming, the red-green-refactor TDD loop, task decomposition, two-phase subagent review, systematic root-cause debugging, and Git worktree-based parallel development. Supports Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot CLI, Kimi Code, and more. MIT-licensed.

iloader

🔗 github.com/nab138/iloader — on the board 2 days

What it does: A user-friendly iOS sideloader that helps you install apps like SideStore onto your iPhone or iPad without going through the App Store.

Why it matters: iOS sideloading is normally a fiddly ordeal — you're manually wrangling certificates and pairing files. iloader automates the whole thing: plug in over USB, sign in with your Apple ID, pick an action, and it handles certificate management, pairing-file placement, and app installation for you. It also imports IPAs and gives you smart diagnostics when something goes wrong.

Tech: Tauri desktop framework with a TypeScript/React front end and a Rust core for low-level iOS device communication. Built with Vite, packaged with Bun (or npm), and cross-platform across Windows, macOS, and Linux. Key dependencies include idevice, isideload, and apple-codesign-quick. MIT-licensed, already translated into 25+ languages by the community.

DeskcommCRM

🔗 github.com/melgarafael/DeskcommCRM — on the board 2 days

What it does: An open-source, self-hostable "AI sales operating system" — a CRM with native AI agents and deep WhatsApp integration, positioned as an alternative to paid platforms like Kommo, Octadesk, and Intercom.

Why it matters: Businesses that sell through chat channels (especially WhatsApp) need customer management and smart automation fused together. DeskcommCRM runs entirely on your own server — no vendor lock-in, no monthly fees, full data ownership — and the AI agents genuinely operate the CRM (qualifying leads, routing them, moving deals down the funnel), not just chat. It also ships WHEN/IF/THEN automation rules, RAG-based organizational memory, sentiment analysis, and human takeover.

Tech: Next.js 16 + React 19 + TypeScript + Tailwind + shadcn/ui, with the backend on the Next.js App Router. Supabase (PostgreSQL + pgvector for RAG, RLS for multi-tenant isolation) handles data. WhatsApp connects via WAHA Plus or the Meta Cloud API, and the AI layer uses the Vercel AI SDK v7 (pluggable across OpenRouter, Anthropic, OpenAI, Google). Deployed via Docker with a one-click install script.

⚡ One-Day Wonders

Single-day appearances — some niche, some just early.

skills (mattpocock)

🔗 github.com/mattpocock/skills — on the board 1 day

What it does: A set of composable AI agent skills "for real engineers," lifted straight from the author's own .agents directory to help you work more effectively with coding agents like Claude.

Why it matters: It mainly targets human-AI misalignment — the gap between what you want and what the AI actually builds. Skills like /grill-me pin down requirements before any code is written; a shared CONTEXT.md domain-language file cuts token waste and keeps style consistent; and /tdd plus /diagnosing-bugs build a tight feedback loop to stop the AI from writing its way into architectural decay.

Tech: Targets Claude Code / Codex-style coding agents; installs via Node.js/npm (npx skills@latest). Markdown docs plus ADRs (architecture decision records), a Bash interactive wizard, and integration with GitHub / Linear issue trackers.

hermes-agent

🔗 github.com/NousResearch/hermes-agent — on the board 1 day

What it does: An autonomous AI agent that "grows with you" — it has a built-in learning loop that lets it create and refine its own skills from experience, runs on all kinds of infrastructure, and connects across multiple messaging platforms.

Why it matters: It goes after several agent pain points at once: API fragmentation (a separate key for the model, search, image gen, and speech), context loss between sessions, infrastructure lock-in (most agents need your laptop running), single-platform limits, and rigid behavior with no capacity for self-evolution.

Tech: Multiple LLM providers (Nous Portal / OpenRouter / OpenAI / custom endpoints); platform backends spanning terminal UI, Telegram, Discord, Slack, WhatsApp, Signal, and Email; infrastructure support for Docker, SSH, Modal serverless, Daytona, and Vercel Sandbox. Memory uses SQLite + FTS5 full-text search + LLM summarization + procedural skill storage. Python/Node.js runtime with cron scheduling, MCP integration, and a tool-calling framework.

hyperframes

🔗 github.com/heygen-com/hyperframes — on the board 1 day

What it does: "Write HTML, render a video" — it deterministically converts HTML/CSS/animation into MP4 video, designed for agents.

Why it matters: It bridges the gap between how developers already like to create (HTML/CSS) and the video production pipeline. Compared to React-based approaches, there's no build step, and it drops cleanly into AI coding agents that already understand HTML.

Tech: Puppeteer / headless Chrome captures frame-by-frame, FFmpeg handles encoding. Supports GSAP, Lottie, Three.js, and CSS animation. Built on Node.js 22+, distributed as a CLI tool, with optional AWS Lambda for rendering at scale. TypeScript, Apache 2.0.

teamai-cli

🔗 github.com/Tencent/teamai-cli — on the board 1 day

What it does: A Tencent command-line tool that distributes a team's skills, rules, and knowledge to various AI coding assistants through a centralized git repository.

Why it matters: When a team uses several AI assistants at once (Claude Code, Cursor, and so on), there's no unified way to share coding standards, custom skills, and accumulated team knowledge. teamai-cli makes every agent "work the team's way" and automatically recalls team context.

Tech: TypeScript / Node.js (npm CLI), distributing via Git (GitHub, GitLab, GitCode, private Git). Knowledge retrieval uses BM25 + graph-boosted re-ranking; code parsing uses Tree-sitter WASM for AST extraction across JS/TS, Python, and Go.

editor (Pascal)

🔗 github.com/pascalorg/editor — on the board 1 day

What it does: A browser-based 3D architecture editor (Pascal) with real-time rendering and collaboration, letting users create and share 3D building projects.

Why it matters: Traditional CAD software is expensive and has a steep learning curve. Pascal offers an out-of-the-box, browser-based parametric modeling tool — draw floor plans, walls, and zones, and place furniture for architectural visualization.

Tech: React 19 + Next.js 16 + React Three Fiber; Three.js with WebGPU rendering; Zustand for state (with Zundo for undo/redo); Zod for validation; three-bvh-csg for Boolean geometry operations; Turborepo + Bun managing the monorepo. Plugin architecture split into core / viewer / editor packages.

text-to-cad

🔗 github.com/earthtojake/text-to-cad — on the board 1 day

What it does: An agent skill library that lets AI generate, inspect, slice, and deliver CAD and robot-description files from local project files.

Why it matters: It bridges natural-language requirements and professional engineering output — letting an AI agent take part directly in CAD modeling, robot structural design, simulation management, and prepping files for fabrication.

Tech: Python 3.11+ generates geometry, exporting STEP / STL / 3MF / GLB; robot descriptions use URDF / SRDF / SDF. The manufacturing side supports G-code slicing and DXF 2D drawings, with hooks into vendors like SendCutSend and Bambu Labs. Plugs into Codex, Claude Code, and Grok Build via a plugin architecture; skills are managed with the npm Skills CLI.

System Design Notes

🔗 github.com/liquidslr/system-design-notes — on the board 1 day

What it does: Complete study notes for Alex Xu's System Design Interview Volumes 1 and 2 — 28 chapters, from fundamentals all the way to complex distributed systems design.

Why it matters: People prepping for system design interviews lack a well-organized, searchable reference; the complex architecture concepts are scattered across the books and tough to grind through. This repo breaks the whole thing into structured, searchable notes.

Tech: Covers distributed-systems fundamentals (scaling, capacity estimation, design frameworks) and concrete implementations — rate limiting, consistent hashing, unique ID generation, search, real-time messaging, video processing, geolocation, monitoring, financial transactions. Cites production systems from Amazon (DynamoDB), Google (BigTable, Maglev), Twitter (Snowflake), Discord, Netflix, and Slack as case studies.

PI-Desktop

🔗 github.com/vastsa/PI-Desktop — on the board 1 day

What it does: A local-first AI coding agent desktop app that gives the agent its own workbench — spanning multiple projects and long-running sessions, instead of being boxed into a terminal or editor plugin.

Why it matters: Traditional coding agents are trapped in constrained environments — the editor, the terminal, or a cloud platform. PI-Desktop gives them a dedicated space to manage projects, conversations, file review, and notifications, while permission gates keep the user in control. It offers three modes: Agent (autonomous execution), Plan (approval before implementing), and Goal (figures out its own approach to hit the target).

Tech: React + TypeScript + Tailwind + Vite on the front; Electron + Node.js for the desktop layer; a Rust host core (managing permissions, files, credentials) with SQLite for persistence. The agent runtime is built on pi-mono's pi-ai / pi-agent-core, with MCP, plugins, a skill framework, and subagents. LGPL-3.0, data stored locally with no forced cloud relay.

system_prompts_leaks

🔗 github.com/asgeirtj/system_prompts_leaks — on the board 1 day

What it does: A repository that collects and archives the "system prompts" — the hidden instructions models get fed before a conversation — of major AI chatbots.

Why it matters: It makes the AI's unwritten rules transparent, revealing exactly what behavioral constraints each model is configured with, so users and researchers can understand how the AIs they use daily are actually tuned.

Tech: Essentially a Markdown document library, with plain-text prompts stored in per-vendor folders. Covers 20-plus systems including Anthropic (Claude), OpenAI (ChatGPT / Codex), Google (Gemini), xAI (Grok), Meta, Microsoft Copilot, Mistral, Perplexity, and DeepSeek.

zapret-discord-youtube

🔗 github.com/Flowseal/zapret-discord-youtube — on the board 1 day

What it does: A Windows tool that bypasses network restrictions, using traffic filtering and tampering to defeat DPI (Deep Packet Inspection) blocking and restore access to YouTube, Discord, and Telegram.

Why it matters: It's a response to network censorship and service blocking. Because "strategies stop working over time," it bundles several switchable bypass methods (FAKE TLS, SIMPLE FAKE, ALT, and other variants) — if one stops working, you switch to another.

Tech: At its core, WinDivert (Windows packet filter/redirect driver) + nfqws (network filter queue tool), with Batch (.bat) scripts for automation and service management. Integrates Windows startup autorun and hosts-file modification, packaging the upstream zapret project into a ready-to-run Windows build.

Themes of the Week

A few patterns jumped out across the six days:

The agent-skill ecosystem went vertical. Nearly half the board was "make your coding agent work better" tooling — skill catalogs (mattpocock/skills, openai/skills), full agent harnesses (ECC, Superpowers), team distribution (teamai-cli), domain-specific skill packs (diagram-design, text-to-cad), and standalone agents (hermes-agent, PI-Desktop). The category has clearly moved past novelty into infrastructure.

Response format is a real UX problem. i-have-adhd topping the charts for four days — largely a SKILL.md full of "stop rambling" rules — says something. People don't just want smarter models, they want models that respect their attention.

Self-hosted and local-first is a movement, not a niche. DeskcommCRM (own your CRM), PI-Desktop (local agent workbench), and iloader (install what you want on your own device) all rode the same "own your stack, no lock-in" energy.

Browser-native visualization keeps raising the bar. God's Eye View and Pascal's editor both pack serious 3D — photorealistic globes, WebGPU CAD — into a plain browser tab, no install required.

Transparency and access still resonate. system_prompts_leaks (peek behind the AI curtain) and zapret-discord-youtube (route around censorship) show the perennial pull of tools that pry things open.

Fundamentals never go out of style. System Design Notes trending alongside all the bleeding-edge AI stuff is a nice reminder that people are still just trying to pass their interviews.

Takeaway

If you read one signal out of this week, make it this: the agent layer is standardizing. We've moved from "look, the AI can write code" to "here's the disciplined workflow, the reusable skills, and the guardrails that make it trustworthy." Harnesses like ECC and Superpowers, and skill catalogs from OpenAI, Tencent, and independent engineers alike, are all converging on the same insight — the model is only as good as the structure around it.

And beneath the AI headline, the quieter story is ownership: self-hosted CRMs, local-first agents, and censorship-routing tools all trending in the same week. People want capability and control. The projects that give them both are the ones sticking around.

See you next Sunday.

Compiled by Tommy Zhang | September 13, 2026