# MASTER-ROUTING.md Fast Path vs routing.md Matrix in reverse-skill: Key Differences Explained

> Understand the key differences between MASTER-ROUTING.md fast path and routing.md matrix. Learn when to use single-keyword priority routing versus multi-dimensional lookup for complex requests in reverse-skill.

- Repository: [ZhaoXu/reverse-skill](https://github.com/zhaoxuya520/reverse-skill)
- Tags: deep-dive
- Published: 2026-08-13

---

**The MASTER-ROUTING.md fast path provides single-keyword priority routing for common scenarios, while the routing.md matrix offers multi-dimensional lookup for ambiguous or complex requests.**

The `reverse-skill` repository uses two complementary routing documents to direct user requests to appropriate SKILL modules. Understanding when each document takes precedence is essential for working effectively with this reverse-engineering and pentesting framework.

## Purpose and Scope of Each Routing Document

The repository maintains two distinct routing strategies to balance speed against thoroughness:

| Aspect | **MASTER-ROUTING.md** (Fast Path) | **routing.md** (Full Matrix) |
|--------|-----------------------------------|------------------------------|
| **Primary goal** | Rapid resolution of unambiguous, high-confidence requests | Exhaustive matching for complex or vague scenarios |
| **Decision basis** | Single-keyword matching (e.g., "APK", "IDA", "Radare2") | Three-axis evaluation: Target Type × User Intent × Toolchain |
| **Typical response time** | Immediate hand-off to SKILL.md | Requires normalization and multi-dimensional analysis |
| **Coverage** | Most common reverse-engineering tasks | Edge cases, novel combinations, ambiguous natural language |

Both documents implement the security-first routing policies defined in [`RULES.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/RULES.md), but they serve different points in the request lifecycle.

## How the Fast Path Works in MASTER-ROUTING.md

The **MASTER-ROUTING.md fast path** (lines 56-66) defines a concise priority list of **R1-R40 rules** and an 8-step execution contract. When `scripts/master-route.ps1` receives a request, it scans for **strong keywords** that map directly to primary skills.

```powershell

# Fast-path routing: direct keyword match triggers immediate skill selection

powershell -File skills\scripts\master-route.ps1 -Hint "分析 APK 文件"

# Result: Immediately opens apk-reverse/SKILL.md (matches PRIMARY R1)

```

The fast path succeeds when:

- The request contains unambiguous technical terms (file formats, tools, or operations)
- A single skill clearly dominates the intent
- No disambiguation between similar skills is required

According to the source, unmatched requests explicitly fall back to the matrix with the instruction: *"If no strong keyword detected → consult routing.md three-axis matrix"* (line 108-112 of [`MASTER-ROUTING.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/MASTER-ROUTING.md)).

## How the routing.md Matrix Provides Fallback Coverage

The **routing.md matrix** comes into play when the fast path cannot resolve a request confidently. This document contains exhaustive tabular definitions organized by:

- **Target Type** — concrete entry points per artifact (APK, binary, firmware, etc.)
- **User Intent** — natural-language phrases mapped to skill modules
- **Toolchain** — appropriate MCP/tools for execution
- **Ambiguity Recovery Protocol** — normalization steps when intent is unclear

```powershell

# Matrix fallback: ambiguous request requires multi-dimensional analysis

powershell -File skills\scripts\master-route.ps1 -Hint "我要破解这个 Android 应用的授权机制"

# Result: MASTER-ROUTING cannot determine PRIMARY

# → routing.md matrix evaluates: APK + "破解授权" + Frida toolchain

# → Proposes apk-reverse/SKILL.md with dynamic hooking steps

```

The matrix (lines 1-13) specifically handles cases where **no strong keyword** is present, applying normalization rules before the three-axis lookup.

## Execution Order and Read Sequence

The repository enforces a strict read order visible in the [`MASTER-ROUTING.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/MASTER-ROUTING.md) diagram (lines 108-112):

```

RULES.md → MASTER-ROUTING.md → PRIMARY SKILL.md
                    ↓ (if needed)
              routing.md matrix

```

This hierarchy ensures that:

1. **Security policies** from [`RULES.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/RULES.md) are always evaluated first
2. **Routine cases** resolve through fast-path priority rules
3. **Complex cases** receive thorough multi-dimensional analysis without blocking simpler requests

## When to Rely on Each Routing Method

**Use the MASTER-ROUTING.md fast path when:**

- Your request contains standard technical vocabulary
- You need immediate skill activation for common tasks (APK analysis, IDA decompilation, Radare2 scripting)
- Confirmed single-skill dominance exists

**Use the routing.md matrix when:**

- Your request uses natural language without clear technical keywords
- Multiple skills could plausibly apply
- You need toolchain-specific guidance (e.g., Frida vs. Xposed vs. native hooking)
- The request represents a novel combination of target, intent, and tools

## Source Files and Implementation Details

| File | Role in Routing Architecture |
|------|------------------------------|
| [`skills/MASTER-ROUTING.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/MASTER-ROUTING.md) | Priority list R1-R40, 8-step execution contract, fallback trigger |
| [`skills/routing.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/routing.md) | Three-axis matrix, intent normalization, ambiguity recovery protocol |
| `skills/scripts/master-route.ps1` | PowerShell implementation of fast-path logic with matrix fallback |

Both routing documents reference the same SKILL modules but differ in **decision granularity**: single-dimensional keyword matching versus multi-dimensional constraint satisfaction.

## Summary

- **MASTER-ROUTING.md provides fast-path routing** through 40 priority rules and strong-keyword matching for unambiguous requests
- **routing.md supplies exhaustive matrix lookup** across Target Type, User Intent, and Toolchain dimensions for complex cases
- **Execution order is sequential**: fast path first, matrix fallback when needed, both governed by [`RULES.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/RULES.md) policies
- **The same PowerShell script (`master-route.ps1`)** implements both paths, transparently selecting based on keyword confidence

## Frequently Asked Questions

### What happens if both routing documents disagree on the best skill?

The fast path takes precedence when it produces a confident match. If [`MASTER-ROUTING.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/MASTER-ROUTING.md) identifies a PRIMARY skill, that selection stands. The matrix only activates when the fast path explicitly signals ambiguity or no-match conditions.

### Can I force matrix routing even for simple requests?

The `master-route.ps1` script does not expose a force-matrix flag in its current implementation. Matrix consultation occurs automatically when strong keywords are absent. To influence routing, structure your hint to include or exclude technical terms that trigger specific R1-R40 rules.

### How do I add new routing rules to the system?

New skills require updates to both documents: add a priority rule to [`MASTER-ROUTING.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/MASTER-ROUTING.md) if the skill warrants fast-path treatment, and register the full three-axis definition in [`routing.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/routing.md) including target types, intent phrases, and toolchain mappings. All changes must comply with the [`RULES.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/RULES.md) policy framework.

### Where does skill selection logic live in the codebase?

The selection logic is distributed: **priority evaluation** resides in [`MASTER-ROUTING.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/MASTER-ROUTING.md) as declarative rules, **matrix lookup** is documented in [`routing.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/routing.md) as structured tables, and **execution orchestration** is implemented in `skills/scripts/master-route.ps1` which interprets both documents at runtime.