How Reverse-Skill Integrates with AI Agents Like Claude Code and Codex CLI

Reverse-Skill is a client-neutral skill router that AI agents integrate with through a four-step bootstrap process: provide the repository path, expose an MCP endpoint, inject three entry files (SKILL.md, routing.md, tool-index.md), and run a platform-specific bootstrap script that generates client-specific configurations.

This integration model allows Claude Code, Codex CLI, Cursor, and other code-AI tools to execute real reverse engineering tools—such as Frida, IDA Pro, and custom analyzers—without modifying the core routing logic. According to the zhaoxuya520/reverse-skill repository, the architecture intentionally separates client adapters from routing core to maximize portability across agent ecosystems.

The Four-Step Integration Model for AI Agent Support

Reverse-Skill follows a strict protocol defined in README_AI.md. Any agent wanting to consume the skill pack must complete these steps:

1. Provide the repository path — The agent receives the absolute location of the skill pack root directory.

2. Expose an MCP endpoint — A local HTTP server (default: http://localhost:23816/mcp) that exposes real tools through the Multi-Tool Control Protocol. The default configuration lives in skills/tool-index.json.

3. Inject three entry files — Every client must be configured to read:

   • skills/SKILL.md — top-level controller
   • skills/routing.md — dispatch matrix
   • skills/tool-index.md — local tool availability

   This enforces the "route first, execute second" principle.

4. Run the bootstrap routine — Platform-specific scripts (skills/scripts/bootstrap-reverse.sh for Linux/macOS, skills/scripts/bootstrap-reverse.ps1 for Windows) that refresh the tool index, detect the OS, write MCP configs (.claude/mcp.json, .codex/mcp.json), and load RULES.md.

How Claude Code Integrates with Reverse-Skill

Claude Code integration uses two touch-points per the repository's AI client guide:

• MCP configuration: ~/.claude/mcp.json stores the endpoint URL and authentication token
• Settings file: Optionally .claude/settings.local.json points to the skill root and entry files

The bootstrap script auto-generates these files. After bootstrap, Claude Code routes reverse engineering tasks through skills/routing.md before invoking any actual tooling.

// Generated ~/.claude/mcp.json
{
  "mcpServers": {
    "anything-analyzer": {
      "url": "http://localhost:23816/mcp",
      "headers": { "Authorization": "Bearer <token>" }
    },
    "idapro": { "url": "http://127.0.0.1:13337/mcp" },
    "jshook": {
      "command": "npx",
      "args": ["-y", "@jshookmcp/jshook@0.3.4"],
      "env": { "JSHOOK_BASE_PROFILE": "search" }
    }
  }
}

How Codex CLI Integrates with Reverse-Skill

Codex CLI follows the same pattern with client-specific naming:

• MCP configuration: codex.mcp.json (identical schema to Claude's)
• Project instruction file: References the three entry files and skill root path

The routing core remains unchanged—only the adapter layer differs.

# codex project-instruction (simplified)

client:
  name: codex
  skillRoot: "<absolute-path-to-reverse-skill>"
  entryPoints:
    - skills/SKILL.md
    - skills/routing.md
    - skills/tool-index.md
  mcpConfig: "codex.mcp.json"

Client Boundary: Keeping Reverse-Skill AI-Agent Agnostic

The AGENTS.md file explicitly mandates that routing core, tests, and tool index must not depend on any particular AI client. This boundary ensures:

• Single source of truth: skills/config/routing.json defines all routing rules
• Reusable skill packs: Same configuration works across Claude Code, Codex CLI, Cursor, Cline, Windsurf
• Simplified maintenance: Updates to routing logic propagate to all agents automatically

Client-specific adaptations live outside the core—typically as hook files, rule files, or IDE-specific configuration that merely points to the three entry files and MCP endpoint.

Bootstrap Scripts: Platform Detection and Configuration Generation

The skills/scripts/ directory contains the automation that makes integration repeatable:

• refresh-tool-index.sh / refresh-tool-index.ps1 — Generates tool-index.md and tool-index.json with current machine's available tools
• bootstrap-reverse.sh / bootstrap-reverse.ps1 / Kali-specific variant — Full platform detection and MCP config generation

Run these in sequence before any agent connection:

# Linux/macOS workflow

bash skills/scripts/refresh-tool-index.sh
bash skills/scripts/bootstrap-reverse.sh

# Windows workflow

powershell -NoProfile -ExecutionPolicy Bypass -File skills/scripts/refresh-tool-index.ps1
powershell -NoProfile -ExecutionPolicy Bypass -File skills/scripts/bootstrap-reverse.ps1

Key Files Controlling AI Agent Integration

File	Purpose
README_AI.md	Complete bootstrap guide, MCP examples, client-specific notes
AGENTS.md	Client boundary policy — routing must stay client-agnostic
RULES.md	Mandatory behavior chain loaded after bootstrap
skills/SKILL.md	Top-level controller loading routing and dispatching sub-skills
skills/routing.md	Routing matrix (target type ↔ intent ↔ toolchain)
skills/config/routing.json	Editable routing configuration — single source of routing truth
skills/scripts/refresh-tool-index.*	Tool availability scanner
skills/scripts/bootstrap-reverse.*	OS detection, MCP config generator, initial routing sequence

Summary

• Reverse-Skill integrates with AI agents through a client-neutral router requiring four steps: repository path, MCP endpoint, three entry files, and bootstrap execution.

• Claude Code and Codex CLI use identical core routing but different adapter files—.claude/mcp.json versus codex.mcp.json—both auto-generated by bootstrap scripts.

• The client boundary policy in AGENTS.md strictly separates routing logic from client adapters, enabling the same skill pack to work across all supported agents.

• Bootstrap automation handles platform detection, tool indexing, and configuration generation through skills/scripts/bootstrap-reverse.* scripts.

• Real tool invocation happens via MCP endpoints, allowing agents to execute Frida, IDA Pro, JSHook, and custom analyzers through a standardized protocol.

Frequently Asked Questions

What is MCP in Reverse-Skill?

MCP stands for Multi-Tool Control Protocol. It's a local HTTP-based protocol that exposes real reverse engineering tools to AI agents. Reverse-Skill runs an MCP server (default port 23816) that translates agent requests into actual tool invocations—such as launching Frida scripts or querying IDA Pro—returning structured results that the agent can consume.

Do I need to modify Reverse-Skill code to use it with Claude Code?

No. Claude Code integration uses auto-generated configuration files created by the bootstrap script. You only provide the repository path; bootstrap-reverse.sh or bootstrap-reverse.ps1 creates .claude/mcp.json and points Claude to the three entry files. The routing core in skills/config/routing.json remains untouched.

Can I use the same Reverse-Skill installation with multiple AI agents?

Yes. This is the explicit design goal of the client boundary policy. After running the bootstrap scripts, you'll have both .claude/mcp.json and .codex/mcp.json (plus any Cursor/Windsurf rule files). All reference the same skills/SKILL.md, skills/routing.md, and skills/tool-index.md—no duplication of routing logic required.

What happens if a tool isn't installed on my system?

The refresh-tool-index scripts scan your machine and generate tool-index.json containing only available tools. The routing layer uses this index to skip unavailable tools or suggest alternatives. Re-run the refresh script whenever you install new tools like IDA Pro or Frida to update the agent's available capabilities.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}