api-reference

Reverse-Skill Trigger Keywords: The Complete Routing Reference

August 1, 2026 zhaoxuya520/reverse-skill ↗

Reverse-Skill trigger keywords are case-insensitive literal phrases defined in skills/routing.md that map natural-language user requests to specific skill modules by matching Target Type, User Intent, and Toolchain dimensions.

The zhaoxuya520/reverse-skill repository uses a keyword-driven routing system to determine which specialized skill module should handle a given request. When a user’s query contains any of the predefined trigger keywords, the router selects the corresponding skill file and executes its workflow.

How Trigger Keywords Work in Reverse-Skill Routing

The routing engine evaluates three dimensions to select the appropriate skill module: Target Type, User Intent, and Toolchain. The trigger keywords serve as the literal bridge between natural language and these dimensions.

When processing a request, the system scans the User Says column in skills/routing.md for case-insensitive substring matches. Once a match is found, the router redirects execution to the file path specified in the Route To column. This design allows the system to handle diverse reverse-engineering tasks—from decompiling binaries with IDA Pro to analyzing Android APKs—without requiring exact command syntax.

Complete Trigger Keyword Reference

The master routing matrix in skills/routing.md contains dozens of trigger phrases organized by domain. Below are the primary keyword groups and their corresponding skill modules.

Binary Analysis and Decompilation

These keywords activate workflows for static and dynamic analysis of compiled binaries:

Virtual Machine and Obfuscation Reverse Engineering

Specialized triggers for handling protected or virtualized code:

Dynamic Instrumentation and Runtime Analysis

Keywords for runtime manipulation and debugging:

Mobile and Web Reverse Engineering

Triggers for platform-specific analysis:

Language-Specific Compiled Code

These phrases route to specialized handlers for modern compiled languages:

Penetration Testing and Security Analysis

Keywords bridging reverse engineering with offensive security:

Malware and Protocol Analysis

Specialized triggers for threat intelligence and communications:

Automation and Documentation

Utility triggers for supporting workflows:

CTF and Game Reverse Engineering

Competition and entertainment-specific routing:

Routing Implementation Details

The routing logic resides in two primary files. The skills/routing.md file contains the complete mapping matrix with the User Says and Route To columns. When ambiguity exists, the system consults skills/MASTER-ROUTING.md as the high-level entry point to resolve conflicts.

The router performs case-insensitive substring matching using regex.Escape (in Python implementations) or [regex]::Escape (in PowerShell) to ensure literal phrase matching rather than pattern interpretation. Additionally, the system verifies tool availability by checking tool-index.md (generated by scripts/refresh-tool-index.*) before activating a skill module that requires specific binaries.

Programmatic Routing Lookup

You can emulate the reverse-skill routing logic to determine which module handles a specific query. Below are reference implementations in PowerShell and Python.


# PowerShell implementation of trigger keyword matching

$routingFile = Join-Path $repoRoot 'skills\routing.md'
$content = Get-Content $routingFile -Raw

# Extract the "User Says" → "Route To" mapping from the markdown table

$regex = '(?m)^\s*\|\s*"([^"]+)"\s*\|\s*`([^`]+)`'
$routeMap = @{}
foreach ($match in [regex]::Matches($content, $regex)) {
    $phrase = $match.Groups[1].Value.Trim()
    $skill  = $match.Groups[2].Value.Trim()
    $routeMap[$phrase] = $skill
}

function Find-Route($query) {
    foreach ($phrase in $routeMap.Keys) {
        if ($query -match [regex]::Escape($phrase)) {
            return $routeMap[$phrase]
        }
    }
    return $null
}

# Example usage

$query = "Can you help me decompile this binary with IDA?"
$route = Find-Route $query
Write-Host "Matched skill module:" $route

# Output: Matched skill module: ida-reverse/SKILL.md


# Python implementation of the routing lookup

import re
import pathlib

def load_routing_matrix(path: str = 'skills/routing.md') -> dict[str, str]:
    """Load the trigger keyword to skill module mapping."""
    routing_path = pathlib.Path(path)
    text = routing_path.read_text(encoding='utf-8')
    
    # Match table rows: | "trigger phrase" | `target/skill.md` |

    pattern = re.compile(r'^\s*\|\s*"([^"]+)"\s*\|\s*`([^`]+)`', re.MULTILINE)
    return {m[1].strip(): m[2].strip() for m in pattern.findall(text)}

def find_route(query: str, route_map: dict[str, str]) -> str | None:
    """Find the first matching skill module for a given query."""
    for phrase, skill in route_map.items():
        if re.search(re.escape(phrase), query, re.IGNORECASE):
            return skill
    return None

# Example usage

route_map = load_routing_matrix()
result = find_route("I need to bypass anti-debug checks in this binary", route_map)
print(result)

# Output: reverse-engineering/anti-analysis.md

Summary

  • Trigger keywords are defined in skills/routing.md and serve as the routing mechanism for the zhaoxuya520/reverse-skill repository.
  • The system matches Target Type, User Intent, and Toolchain dimensions using case-insensitive substring matching.
  • Keywords range from specific tools ("IDA analyze", "radare2") to techniques ("control flow flattening removal") and platforms ("APK unpack", "iOS app").
  • The router consults skills/MASTER-ROUTING.md for ambiguous queries and verifies tool availability via tool-index.md before execution.
  • Each keyword maps to a specific SKILL.md file containing the detailed workflow implementation.

Frequently Asked Questions

What file contains the complete list of reverse-skill trigger keywords?

The complete routing matrix is located at skills/routing.md in the repository root. This markdown file contains a table mapping all trigger phrases to their respective skill module paths, along with the Target Type and Toolchain specifications used by the routing engine.

How does the router handle keyword matching?

The router uses case-insensitive substring matching against the User Says column. It escapes special regex characters to treat the trigger keywords as literal phrases rather than patterns. The first match found in the routing table determines which skill module receives the request.

Can I add custom trigger keywords to the system?

Yes. You can extend the routing matrix by adding new rows to skills/routing.md following the existing format: | "your trigger phrase" | Target Type | Toolchain | [skill-module/SKILL.md](https://github.com/zhaoxuya520/reverse-skill/blob/main/skill-module/SKILL.md) |. After modification, run the appropriate refresh script to update tool-index.md if your new skill requires specific binaries.

What happens when multiple trigger keywords match a single query?

The router selects the first match found during the table scan. For complex queries that might match multiple patterns, the system relies on the ordering in skills/routing.md and falls back to skills/MASTER-ROUTING.md when ambiguity detection is required. Design your trigger keywords with specific, unique phrases to avoid unintended routing collisions.

Have a question about this repo?

These articles cover the highlights, but your codebase questions are specific. Give your agent direct access to the source. Share this with your agent to get started:

Share the following with your agent to get started:
curl -s "https://instagit.com/install.md"
Works with
Claude Codex Cursor VS Code OpenClaw Any MCP Client

Maintain an open-source project? Get it listed too →