reverse-skill: GitHub’s Top AI Security Skill Router

> reverse-skill hit No. 1 on GitHub Trending with 20,000+ stars, routing AI coding agents like Claude Code and Cursor into reverse-engineering workflows.

ShareX LinkedIn

🎧 Listen — ~6 min

Ready · reverse-skill: GitHub’s Top AI S

0:00 / 6:00

Verified by Essa Mamdani

A cybersecurity project called reverse-skill spent the first week of August 2026 as the No. 1 trending repository on GitHub, crossing 20,000 stars after a growth pattern that looked explosive but wasn't quite what the headlines claimed. It's a useful case study in what "AI agent tooling" actually means in practice in 2026 — and in how quickly a niche security utility can go viral once it's framed as an AI story.

What reverse-skill actually is

Built by a developer using the handle zhaoxuya520, reverse-skill is not a standalone tool. It's a routing layer — what its own documentation calls a "Cybersecurity Skills Router" — that sits in front of an AI coding agent (Claude Code, Codex CLI, Cursor, Cline, Kiro, Windsurf, and others) and decides which of roughly 41 specialized workflows to hand a task to. When an agent encounters an APK to reverse engineer, a stripped binary, obfuscated frontend JavaScript, a CTF challenge, or an authorized penetration-testing target, reverse-skill's routing rules (encoded in a routing.json file with 41 rules and validated against a 163-case regression suite) point it toward the right methodology and toolchain instead of letting the model improvise commands from training data.

The scope is broad: APK and mobile reverse engineering, .NET/C# decompilation, frontend JS deobfuscation, malware analysis and YARA rule generation, firmware and IoT pentesting, patch-diffing for N-day exploits, pwn/exploit development, EDR bypass research, API and GraphQL security testing, supply-chain and SBOM auditing, and a 42-sub-skill CTF sandbox orchestrator. Each scenario maps to a dedicated skill directory with its own playbook, and the project ships adapters for the tool ecosystem around each discipline — jadx and apktool for Android, Frida and IDA Pro/Ghidra/radare2 for binaries, Burp Suite MCP integration for web and API testing.

The growth story, corrected

Coverage of reverse-skill's rise has leaned on a "10,000 stars in a day" framing that doesn't hold up under scrutiny. According to independent analysis of archived GitHub snapshots, the repository was actually created on May 13, 2026, and took roughly eleven weeks to cross 10,000 stars, hitting that mark around July 31. The growth curve shows a first surge in late June, a four-week plateau, and then a sharp second acceleration — about 5,800 new stars in the five days leading up to August 3 — that pushed it to the top of GitHub Trending on July 31 and past 20,000 stars by early August. Real growth, just not a one-day phenomenon; the project spent over two months as a comparatively obscure repo before the trending algorithm caught it.

It's also not the first project in this category, despite some coverage implying otherwise. A 6,631-star Android reverse-engineering skill package predates it by roughly three months, and separate iOS-focused and defensive malware-analysis skill packages have existed since early 2026. What reverse-skill did was consolidate the pattern at a larger scale than anything before it — more scenarios, a more rigorous routing/testing setup, and cross-platform CI on both Windows and Ubuntu — rather than invent the idea of packaging security methodology as an installable agent skill.

Why "skill routers" are becoming their own category

The underlying trend is bigger than one repository. Coding agents are increasingly capable of executing arbitrary shell commands and calling MCP servers, but they don't inherently know which of a dozen plausible tools is correct for a given reverse-engineering or pentesting subtask — whether to reach for jadx or apktool on an APK, or IDA versus radare2 on a stripped ELF binary. Skill routers like reverse-skill exist to close that gap: they encode expert triage logic as a structured, testable ruleset that sits between the user's request and the agent's tool calls, then enforce a repeatable evidence-and-reporting format (the project calls this an "Evidence → Finding → Path" pipeline) so output looks like a structured security report rather than an improvised chat transcript.

This same pattern is visible elsewhere in the current GitHub Trending list: a multi-agent document-processing pair from Firecrawl, an agent-infrastructure project from Cloudflare, and multiple competing security-skill-router forks, several explicitly split along offensive versus defensive lines. The consolidation into routers is happening on both sides — the same week reverse-skill trended, a related project packaged defensive malware-analysis workflows using the identical router pattern.

The authorization question

Because the toolchain spans genuinely offensive capabilities — exploit development, EDR bypass, pwn chains — the project puts real weight on scope-gating. Its routing pipeline requires a scope.md file establishing authorization and a defined network profile before any agent is allowed to "ACT" against a target; the README frames this explicitly as a prerequisite step, not an optional courtesy. Whether that self-enforced gate is sufficient guardrail for a widely forked, MIT-licensed tool that any Claude Code or Cursor session can install with a single git clone is the real open question raised by its virality — the routing logic can direct an agent toward the right methodology, but it can't verify that the human running the agent actually has authorization for the target they've pointed it at.

Under the hood: how the routing actually works

The entry point is a RULES.md file that every supported agent client is instructed to load before touching a target, followed by a master-route.ps1 script that reads the routing.json rule table and performs a one-shot triage based on the task description. Only after a case directory is initialized — with scope, authorization, and a network profile recorded — does the routing pipeline allow an agent to move from research into active engagement with a target. The project calls this the case-init step, and it's structurally similar to how professional pentesting engagements require a signed rules-of-engagement document before testing begins; reverse-skill is encoding that professional norm directly into the agent's tool-call sequence rather than leaving it as a README warning.

Client integration is deliberately kept generic. The core routing engine, the 163-case regression suite, and the case-management scripts don't depend on any single AI client's plugin format — Claude Code, Codex, Cursor, and OpenCode are all expected to load the repository through their own project-instruction mechanisms (a CLAUDE.md and an AGENTS.md both ship in the repo root for exactly this reason). That client-agnostic design is likely part of why the project spread as fast as it did once it started trending: it didn't require anyone to wait for a first-party integration from a specific vendor.

What to take from this if you build AI dev tooling

For teams building or evaluating AI coding agent extensions, reverse-skill is a clean example of a pattern worth copying for any specialized domain: don't rely on model knowledge alone for tasks where tool selection matters more than reasoning quality, ship a routing layer with an explicit, versioned rule table, and back it with a regression suite that fails CI when routing behavior drifts. That structure — 41 rules, 163 test cases, cross-platform CI — is arguably more transferable to other domains (legal research agents, data-engineering agents, DevOps runbooks) than anything specific to reverse engineering itself. Whether or not you ever touch a binary or an APK, the underlying lesson holds: as agents get more tool access, the bottleneck shifts from "can the model write correct commands" to "does the system know which commands are even appropriate to try," and that's a routing problem, not a model-capability problem.