GitHub Trending Weekly Digest — October 5–10, 2026
Another week, another avalanche of agent tooling. If you blinked, you missed roughly ten new ways to bolt skills, plugins, and memory onto your coding assistant. But the real story of the week wasn't tooling at all — it was two projects that have nothing to do with "vibe coding" and everything to do with taking things apart: one that reverse-engineers any binary, and one that ports PS5 games to your Linux box. Those two sat at the top of the charts for days while the agent-skills crowd fought it out below.
Here's the deduplicated rundown, ranked by how many days each repo managed to hold its spot on the trending list over October 5–10.
Persistent Chart-Toppers (4+ days)
AnyPS5
🔗 github.com/boykopovar/AnyPS5
What it does: AnyPS5 automatically ports PS5 executables to run on Linux and Windows. It ships a relinker that converts the executable into the target system's native format, plus a set of system PRX library implementations suited for dynamic linking. No emulation, no separate runtime process. The repo includes build docs, a technical-debt list, code-style conventions, contribution guidelines, and a compatibility list of verified games — it claims the 2D platformer Dreaming Sarah runs at a steady 60 fps on a GTX 1050 Ti with an i5-7500.
Why it matters: This is the week's longest-running trending repo, and it's not hard to see why — native PS5-to-PC porting without emulation is the kind of thing people assumed wasn't practical. The project is careful to frame itself around interoperability, research, and preservation, and states plainly that it bundles, distributes, and requires no copyrighted software, firmware, encryption keys, or proprietary libraries — you bring your own binaries and stay within the law. Whenever it hits an unsupported or unexpected state, it throws a hard std::runtime_error, prints what() to stderr, and bails.
Tech: Mostly C++. The shader recompiler emits SPIR-V, validated through SPIRV-Tools when built with ANYPS5_ENABLE_SPIRV_TOOLS. It supports SDL-mapped game controllers (sticks and triggers included), with keyboard and mouse remapping via an anyps5-input.ini file. System PRX implementations live under core/libs/prx. Licensed GPL version 2 only.
rea (Reverse Engineer Anything)
🔗 github.com/morluto/rea
What it does: REA wires your coding agent into a full reverse-engineering toolkit for inspecting native binaries, JavaScript and Electron apps, .NET assemblies, and websites — and the same capabilities work straight from the terminal. Its investigation model has three steps: Decompile (recover readable code, strings, and symbols from an app), Understand (follow the code to see how a feature works), and Recreate (rewrite the findings into a feature that fits your own stack). Everything runs locally on a supported host; REA never uploads apps to a hosted analysis service, and every conclusion comes with the evidence and limitations behind it.
Why it matters: This one went vertical — a jaw-dropping +25,784 stars on its final day alone. It targets the universal developer itch: "I saw a feature in another app and want to know how it's built." REA explains how something works without source, shows its evidence, and implements a version for your project in the same coding session. It's also useful for reconstructing an app's auth, storage, update, or network flow, reverse-engineering undocumented formats, or tracing suspicious behavior from a string back to the code behind it. It's explicit about what it doesn't do: it makes no claim to recover original source, won't auto-clone an app, and produces pseudocode rather than real source.
Tech: Mostly TypeScript, shipped as the npm package rea-agents. Needs Node.js 22.x (>=22.19), 24.x (>=24.11), or 26+, and runs on macOS 12+, Ubuntu 24.04+, Fedora 41+, or 64-bit Arch. Native binary analysis requires Hopper or Ghidra (the Ghidra provider wants Ghidra 12.1.4 and a 64-bit JDK 21). Windows Ghidra support is flagged experimental, scoped to native x86-64 PE apps on local NTFS, with a Job Object, private-DACL, and path admission controls bundled in. Capabilities are exposed as both a CLI and an MCP server.
skills
🔗 github.com/mattpocock/skills
What it does: This is the set of agent skills Matt Pocock pulled out of his own .agents directory — the stuff he uses daily for engineering work. Skills split into Engineering and Productivity buckets and by invocation style: user-invoked skills only fire when you type them and act as orchestrators, while model-invoked skills can be called by you or triggered automatically when a task matches, carrying reusable discipline. A user-invoked skill can call a model-invoked one, but never another user-invoked skill. The lineup includes grill-me, grill-with-docs, tdd, diagnosing-bugs, to-spec, to-tickets, implement, wayfinder, triage, code-review, domain-modeling, codebase-design, prototype, research, and more.
Why it matters: Pocock built these to fix the failure modes he kept hitting with coding agents: the agent doesn't do what you wanted (fixed by a "grilling session" to align before any work starts); the agent is too verbose (fixed with a shared-vocabulary CONTEXT.md); the code doesn't work (fixed with feedback loops — static types, browser access, automated tests, and a tdd skill that drives red-green-refactor); and the codebase turns into a big ball of mud (fixed by focusing on design). He argues that frameworks like GSD, BMAD, and Spec-Kit help by taking over your process — but also take away your control and make their own bugs hard to fix. His skills are deliberately small, easy to edit, composable, and model-agnostic.
Tech: Mostly Shell. Two install paths: the Claude Code plugin (claude plugins install mattpocock-skills) installs the whole set as a managed, auto-updating read-only bundle; the skills.sh installer (npx skills@latest add mattpocock/skills) copies editable skill files into your project. Install both and you'll get a duplicate of every skill. Skills are organized as SKILL.md files, with architecture decision records under .agents/adr. A native Codex plugin is on the roadmap.
diagram-design
🔗 github.com/cathrynlavery/diagram-design
What it does: diagram-design is an Agent Skill for drawing editorial-style diagrams, targeting Claude Code, Codex, GitHub Copilot, Factory Droid, Pi, and any Agent Skills–compatible host. It offers 42 diagram types, outputs self-contained HTML + SVG, and uses no shadows and no Mermaid. Every visual type ships three static variants — minimal light, minimal dark, and full-editorial — that open straight in a browser. A semantic layer describes behavior separately from layout, so things like queues, policy traces, or trust boundaries reuse the closest existing type instead of inflating the type count. It can also redraw draw.io, Mermaid, or Excalidraw source files at a chosen format, size, and detail level.
Why it matters: The author's gripe is relatable: every time she needed an architecture sketch, flowchart, or priority pyramid, Claude handed back generic rounded boxes that clashed with the rest of her site — leaving a choice between 30 minutes of fighting Figma or just not drawing anything. This skill reads your website and claims to match your brand in 60 seconds. Its design philosophy leans austere: "the highest-quality action is usually deletion" — every node earns its place, accent color is reserved for the one or two things a reader should see first, and the target density is a deliberate 4 out of 10.
Tech: Mostly HTML, output as self-contained HTML + SVG with no build step, no JavaScript, and no external image dependencies. Each client installs it through its own plugin or skill mechanism (Claude Code, Codex, Copilot, Droid, Pi, Kiro, OpenCode). Customizable files include references/style-guide.md, and saved profiles live under ~/.diagram-design/profiles/.
Multi-Day Appearances (2 days)
e2e
🔗 github.com/tester-army/e2e
What it does: e2e is an end-to-end testing framework for web and mobile apps, built by TesterArmy. You describe the goal of a test in natural language, an agent drives the app to achieve it, and then the same test's locators and assertions verify the result. It's still in active development on the way to 1.0, so the API and config can shift between minor versions.
Why it matters: The clever bit is that agent steps verified by a later assertion get recorded, and the next run replays those recorded actions — no model call until the app actually changes. Tests with no agent steps need no model at all, and when a model is needed you can bring your own subscription, API key, or a local model. npx e2e init asks for your engine (web or mobile) and model provider, then writes out the config and a sample test. It's a pragmatic take on AI testing: use the model to figure things out once, then cache the deterministic result.
Tech: Mostly TypeScript, published as npm packages: e2e holds the SDK, runner, and CLI; @e2e-dev/web drives Chromium, Firefox, and WebKit through Playwright; @e2e-dev/mobile drives iOS and Android simulators via agent-device; @e2e-dev/github posts results as pull-request comments; and there are hosted-browser and hosted-simulator packages on top. Telemetry is anonymous and can be disabled with npx e2e telemetry disable or E2E_TELEMETRY_DISABLED=1.
claude-mem
🔗 github.com/thedotmack/claude-mem
What it does: claude-mem is a persistent memory-compression system built for Claude Code, with support for a long list of other agent environments too. During a session it automatically captures observations of tool usage, generates semantic summaries, and injects the relevant context back into later sessions.
Why it matters: It solves the amnesia problem — keeping context across sessions after you end or reconnect, so your assistant maintains continuity of knowledge about a project. Features include tiered memory retrieval with token-cost visibility, a mem-search skill to query project history, a web viewer for a live memory stream, and a <private> tag to keep sensitive content out of storage entirely. The installer sets things up and then has you log in via an email magic link, which provisions a memory key and unlocks the claude-mem observer — framed as running off-plan and free for up to 14 days before falling back to your Anthropic plan unless you subscribe. You can skip login by passing an explicit --provider, setting CLAUDE_MEM_ONLINE_OPTIN=false, or running in a CI/non-interactive shell.
Tech: Mostly TypeScript, installed via npx claude-mem install or the in-editor /plugin command. The core is five lifecycle hooks (SessionStart, UserPromptSubmit, PostToolUse, Stop, SessionEnd) plus a pre-install dependency check. A worker service exposes an HTTP API managed with Bun, backed by a SQLite schema with FTS5 search and hybrid search via a Chroma vector database. Note that npm install -g claude-mem only installs the SDK — it does not register the plugin hooks or set up the worker.
text-to-cad
🔗 github.com/earthtojake/text-to-cad
What it does: text-to-cad is a plugin that gives agents a local CAD workflow for generating 3D models in STEP, GLB, STL, or 3MF formats. It also runs design-for-manufacturing checks, generates engineering drawings, and connects to common 3D-printing, sheet-metal, and CNC services. It supports every common agent that speaks plugins or the Skills framework — Claude Code, Codex, Cursor, Gemini, and Grok.
Why it matters: It brings model generation and inspection fully local. Ask the agent to show a model, and in environments that can render app views you get a rotatable viewer card (in Claude Desktop, Claude can even read what you've selected); in text-only environments like a terminal, you get a link to open the CAD Viewer in your browser. One install rule to remember: in a single app, install either the plugin or the skills — never both, or you'll get two copies of every skill.
Tech: Mostly Python. CAD runs through uv, with the core package cadgen on PyPI. The plugin starts a local cadgen mcp server; without the plugin, the skills call cadgen through uv with the same pinned command and open models in the browser-based CAD Viewer. Update checks hit api.texttocad.dev/v1/versions at most once a day and can be disabled with CADGEN_UPDATE_CHECK=0; anonymous usage counts are off by default until you opt in (toggle with uvx cadgen analytics on|off or DO_NOT_TRACK=1).
Single-Day Appearances (1 day)
artcraft
🔗 github.com/storytold/artcraft
What it does: ArtCraft is a desktop app for AI image and video creation that bills itself as "the IDE for artists." You compose on a 2D canvas, block out scenes in 3D, and pick which models to use. Features span Image to Location, 2D/3D image composition, Image to 3D Mesh, character posing, scene blocking with kitbashing, character identity transfer, background removal, text-to-image, prompt-based editing, canvas masking and inpainting, and image-to-video — with more previews (scene relighting, image ingredients) on the way. Stable builds exist for Windows and macOS, you can build from source (Linux included), and it's dual-licensed MIT or Apache-2.0.
Why it matters: The pitch is control — artists need a grip on composition, character identity, and camera angle, so ArtCraft has you block out the scene before generating, turning prompting into crafting for precise, repeatable results. You can still explore ideas fast with prompts, then refine with the canvas and scene tools.
Tech: Mostly Rust. Its own model catalog spans 62 models — 16 image (Nano Banana, GPT Image, FLUX, Seedream), 25 video (Seedance, Kling, Veo, Sora, Vidu, MiniMax), 5 music/audio (Suno, Seed Audio), 11 3D mesh (Hunyuan 3D, Tripo3D, Meshy, Rodin), and 5 worlds/Gaussian-splat models (Marble, TripoSplat) — alongside Grok, Midjourney, Sora, and World Labs, with Kling, Google, Runway, and Luma planned.
impeccable
🔗 github.com/pbakaus/impeccable
What it does: Impeccable is design guidance for AI coding agents — 1 skill, 24 commands, live browser iteration, and 61 deterministic detection rules, plus LLM-only critique checks. Everything runs through /impeccable (init, craft, shape, critique, audit, polish, bolder, quieter, distill, harden, animate, live, generate, and more), and you can pin frequently used commands as standalone shortcuts. /impeccable init inspects your project, asks only about gaps in durable product facts, and writes a PRODUCT.md, keeping the visual system separately in DESIGN.md.
Why it matters: The premise: because every model trained on the same SaaS templates, skipping design guidance gives you the same fingerprints on every project — Inter everywhere, purple-to-blue gradients, cards nested in cards, gray text on colored backgrounds, a rounded-square icon block above every heading. Impeccable builds on Anthropic's frontend-design skill and spells out what to avoid: no overused fonts, no gray-on-color, no pure black or gray without a tint, not everything wrapped in a card, no bounce or elastic easing. A design hook runs the detectors as you edit UI files and feeds the findings back into the agent loop.
Tech: Mostly JavaScript, but the skill needs no runtime of its own — each skill ships a launcher that runs the Impeccable engine, a standalone binary bundled or downloaded on first run. Node only enters the picture if you use the npx impeccable installer. The CLI and browser extension run the deterministic rules with no LLM or API key required. Supported tools run the gamut from Cursor and Claude Code to Gemini CLI, Codex, Grok Build, OpenCode, Pi, and GitHub Copilot via a VS Code extension.
t3code
🔗 github.com/pingdotgg/t3code
What it does: T3 Code calls itself an "agent harness control surface" — a way to control the agents on your own machine, with mobile apps (iOS, Android), a web app, and an Electron desktop app. It drives your existing subscriptions to Claude Code, Codex, Cursor, Grok Build, OpenCode, and Google Antigravity, as long as those tools are already configured on your computer. The project is upfront that it's very early, expects bugs, and is mostly not accepting contributions right now — small fixes maybe, big features no.
Why it matters: The team wanted the best possible experience working with agents. They were inspired by the Codex desktop app, Conductor, Claude Desktop, and Cursor Glass, but felt none of them hit the mark — so they built something performant, usable remotely, and genuinely open, with the promise that if they steer it wrong, you have everything you need to fork and build your own editor. Before using it you authenticate at least one provider (e.g., codex login, claude auth login, agent login for Cursor).
Tech: Mostly TypeScript, with an Electron desktop app. Install via curl -fsSL https://t3.codes/install.sh | sh (or a PowerShell one-liner on Windows), or try it once with npx t3@latest. Running t3 starts a server and opens the local web app; t3 service install keeps it resident in the background. Desktop builds are available from GitHub Releases, winget, Homebrew cask, a .deb, and the AUR.
i-have-adhd
🔗 github.com/ayghri/i-have-adhd
What it does: i-have-adhd is a skill for coding assistants that makes their output lead with the next action, number multi-step tasks, and drop sign-offs like "Hope this helps!" No ADHD diagnosis required. There are 10 rules in all: lead with the next action, number multi-step tasks, end with a concrete next step, suppress tangents, restate status each turn, give specific time estimates (minutes, not "a bit"), make progress visible, state errors honestly, cap lists at 5 items, and skip the opening preamble and closing recap.
Why it matters: It targets the all-too-common habit of burying the answer under paragraphs of throat-clearing. The README shows a before/after: the "before" explains every part of an auth flow and ends with "Hope this helps!"; the "after" just gives the npm install command to run, the file and line number to change, numbered steps, and a single "Next." Simple, opinionated, and honestly refreshing.
Tech: Mostly Python. Used as a skill/plugin — you install it by pasting a prompt into your CLI so the assistant follows the repo's AGENTS.md, or by hand per INSTALL.md. To customize, fork it, edit skills/i-have-adhd/SKILL.md, swap in your copy via the plugin commands, and re-invoke /i-have-adhd after a restart.
open-code-review
🔗 github.com/alibaba/open-code-review
What it does: Open Code Review is an AI code-review CLI (the command is ocr) that originated as Alibaba Group's internal AI review assistant. It reads your Git diff and, through a tool-calling agent, sends the changed files to a configurable LLM to produce structured, line-precise review comments. ocr scan can review whole files, and a delegation mode lets an AI coding agent run the review itself, with plugins provided for Claude Code, Codex, Cursor, and OpenCode.
Why it matters: The argument is that general-purpose agents plus Skills do code review unevenly — incomplete coverage, drifting comment locations, inconsistent quality — because a purely language-driven architecture lacks hard constraints. Open Code Review hands file selection, packaging, rule matching, comment placement, and reflection to deterministic engineering logic, leaving dynamic decisions and context retrieval to the agent. On its benchmark of 50 open-source repos, 200 real PRs, and 10 languages, it claims higher precision and F1 than Claude Code on the same underlying model, at roughly one-ninth the token cost — though with lower recall.
Tech: Mostly Go. It needs Git >= 2.41 to generate diffs, search code, and operate on the repo, and installs via npm. It works with OpenAI- and Anthropic-compatible models, matches rules with a template engine, and can pull in external tools through an MCP server.
pstack-claude
🔗 github.com/michael-denyer/pstack-claude
What it does: pstack-claude is a port of Lauren Tan's pstack — a skill stack originally for Cursor — to Claude Code, Codex, Pi, and other agent environments, with a skills-only install available anywhere. It tracks upstream while carrying named policy forks, each declared in tools/forks.json.
Why it matters: You tell poteto-mode your goal, and it calls the right workflow for the task while keeping the code clean, simple, and verified. For bugs, it reproduces the failure, investigates with how and why, delegates the fix, then reruns the failing case — pulling in an architect before implementation if the fix crosses function boundaries, and finishing with both failing and passing evidence. Other playbooks cover planning, features, refactors, performance, investigation, prototypes, PR maintenance, releases, and longer-horizon projects. For concurrency bugs and invariants that tests can't cover, it points you at a separate plugin, agent-formal-verify, which adds TLA+ model checking and Lean proofs.
Tech: Mostly JavaScript. Install through each host's plugin system (Claude Code, Codex, Pi). setup-pstack can change model defaults, set reasoning effort per role, or turn off auto-routing. The project stresses that pstack has no server and no telemetry — scripts run locally, and PR tooling uses your own GitHub CLI login.
context-mode
🔗 github.com/mksglu/context-mode
What it does: Context Mode is an MCP server for context-window optimization in AI coding agents. It uses sandbox tools to keep raw data out of the context, persists session events, and enforces tool routing across 17 platforms via MCP and hooks (Claude Code, Gemini CLI, VS Code and JetBrains Copilot, Cursor, OpenCode, KiloCode, and OpenClaw / Pi Agent gateway integrations, among others). It exposes 11 MCP tools — six sandbox tools and five meta-tools — plus slash commands and an optional status bar in Claude Code.
Why it matters: The problem it names will be familiar: every MCP tool call dumps raw data into the context window — a Playwright snapshot is 56 KB, twenty GitHub issues 59 KB, one access log 45 KB — and half an hour in, 40% of your context is gone. When the agent compacts the conversation to make room, it forgets which files it was editing, which tasks are in flight, and what you last asked. Context Mode attacks this from four angles: sandbox tools shrink 315 KB down to 5.4 KB (a 98% cut); it logs file edits, git operations, tasks, errors, and user decisions so compaction retrieves only what's relevant; it pushes a "Think in Code" style where the model writes scripts that output results instead of reading data into context; and it deliberately does not dictate the model's answer style — citing Moonshot AI's note that aggressively terse prompts have been shown to hurt coding and reasoning benchmarks.
Tech: Mostly TypeScript, running as an MCP server distributed via the npm package context-mode. Session events are stored in SQLite, indexed into FTS5, and retrieved with BM25; sandbox execution uses JavaScript scripts. Each platform integration leans on that platform's hooks and JSON config. Prerequisites include Node.js >= 22.5 (or Bun), Claude Code v1.0.33+ for the plugin, and a gateway version > 2026.1.29 for the OpenClaw integration.
Themes of the Week
Agent skills and plugins went supernova
More than half the list is some flavor of "make your coding agent better at one thing." It's no longer a trickle — it's a genre.
- skills packages a working engineer's daily discipline into composable, model-agnostic units.
- diagram-design and impeccable both attack the "every AI project looks the same" problem, one for diagrams and one for UI design.
- i-have-adhd is a 10-rule skill that just makes output less waffly.
- pstack-claude ports a whole Cursor skill stack to everyone else.
- open-code-review argues deterministic engineering should wrap the agent, not the other way around.
Reverse engineering and interoperability stole the show
The two biggest star magnets of the week weren't about writing new code — they were about understanding and relocating existing code.
- rea turns any coding agent into a reverse-engineering workbench, decompiling binaries and web apps to recreate features locally.
- AnyPS5 ports PS5 executables to Linux and Windows natively, no emulation involved.
Context and memory became first-class problems
As agents do more, the context window is the bottleneck — and this week two projects treated that as the main event.
- claude-mem gives agents persistent, searchable memory across sessions.
- context-mode keeps raw tool output out of the window entirely, claiming a 98% reduction, and preserves task state through compaction.
Takeaway
If last week felt like the agent-skills gold rush peaking, this week was the counterpoint: the repos that actually broke out — rea and AnyPS5 — weren't skills at all. They scratch a deeper itch, which is wanting to understand and reuse software that someone else shipped, source or no source. Meanwhile the skills ecosystem has matured enough that the interesting projects are the opinionated ones (make my output tighter, make my diagrams match my brand) rather than yet another kitchen-sink framework. And quietly underneath it all, the context window is emerging as the real constraint on how far agents can go — which makes claude-mem and context-mode worth watching even if they never top a chart. Bookmark the ones that fit your workflow; a few of these will still be around next quarter.
Compiled by Tommy Zhang | October 11, 2026