How AI Clients Are Integrated with reverse-skill: A Client-Neutral Architecture Guide

The reverse-skill repository integrates with Claude Code, Codex CLI, Cursor, and OpenCode through a thin adapter layer that loads bootstrap instructions from README_AI.md, reads the routing table in skills/config/routing.json, and invokes platform-specific master-route scripts without embedding client-specific logic in the core.

The reverse-skill package is deliberately built to be client-agnostic, allowing any code-AI agent to consume its reverse-engineering workflows through a standardized contract. Instead of hard-coding dependencies for specific clients, the repository exposes a bootstrap-based integration model where each agent loads configuration files, follows routing rules, and executes skill modules through external scripts. This architecture ensures that new AI clients can be added by simply writing a wrapper that reads the existing bootstrap instructions and invokes the standardized shell scripts.

The Client-Neutral Architecture

According to the AGENTS.md policy file in the repository, Claude Code, Codex, Cursor, and OpenCode may only access the repo through their own adapter layer. The core of reverse-skill—encompassing routing rules, test suites, tool indexes, and case workflows—lives in plain files that any client can read and invoke.

This design creates a client-agnostic integration contract: the repository explicitly forbids any client-specific code from residing in the core. Instead, integration happens through a thin adapter layer that each client provides on its own side, reading the bootstrap instructions in README_AI.md and invoking the universal shell scripts located in skills/scripts/.

The Six-Step Integration Flow

AI clients integrate with reverse-skill through a standardized workflow that remains identical regardless of the agent being used.

1. Bootstrap Configuration

The client loads the bootstrap instructions from README_AI.md, which directs the agent where to place configuration files and to copy the repository's RULES.md into its workspace. For Claude Code, this involves placing mcp.json under ~/.claude/; for other clients, it simply means loading the repository path and reading the rules.

2. Load Routing Core

The client reads the single source-of-truth routing table located at skills/config/routing.json. This JSON file drives the decision matrix that maps user tasks to appropriate skill modules, ensuring consistent routing behavior across all AI clients.

3. Fast Path Routing

A client-specific invocation calls the "master-route" script—skills/scripts/master-route.ps1 on Windows or skills/scripts/master-route.sh on Linux/macOS. This script parses the task hint, looks up the rule in the JSON routing table, and directs the agent to the correct skill folder (such as skills/pwn-chain/).

4. Case Initialization

Before any tool execution occurs, the client runs the case initialization script (skills/scripts/case-init.ps1 or skills/scripts/case-init.sh). This creates a scoped work directory at work/<case>/ containing scope.md, timeline.md, and other contract files, enforcing the auth-gate defined in RULES.md.

5. Tool Orchestration

The skill module calls real external tools (such as jadx, Frida, or Burp MCP). The client only needs to ensure these tools are installed locally; the routing core does not dictate which client performs the calls, maintaining the client-neutral boundary.

6. Reporting Generation

After workflow completion, the agent generates reports using the contracts defined in skills/ops/ (timeline, evidence, role map). Final artifacts are written to work/<case>/report/, completing the integration cycle.

Client-Specific Adapter Requirements

While the core remains client-neutral, each AI client requires specific setup steps to establish the adapter layer.

Claude Code Integration

Claude Code requires placing the Model Context Protocol configuration in the user's home directory. The client must copy ./tools/claude/mcp.json to ~/.claude/mcp.json, load README_AI.md, and execute the master-route script through its built-in tool invocation.

# Claude Code bootstrap example

cp ./tools/claude/mcp.json ~/.claude/mcp.json
bash skills/scripts/master-route.sh --hint "analyze apk"

Codex CLI Integration

Codex CLI integrates by providing a local path to the repository, reading RULES.md, and directly invoking the Bash master-route script. No special file layout is required beyond standard repository access.

# Codex CLI example

codex run ./reverse-skill/README_AI.md
bash skills/scripts/master-route.sh --hint "analyze apk"

Cursor Integration

Cursor uses its "Project Instructions" feature to fetch the repository and execute README_AI.md. Integration follows the same bootstrap steps as other clients, leveraging the universal shell scripts without cursor-specific core modifications.

# Cursor example

cursor open https://github.com/zhaoxuya520/reverse-skill
bash skills/scripts/master-route.sh --hint "pwn chain"

OpenCode Integration

OpenCode loads the repository through its "Project Import" feature and follows the bootstrap steps identical to Claude Code. The adapter simply ensures the repository is initialized and the master-route scripts are executable.

# OpenCode example

open-code init ./reverse-skill
bash skills/scripts/master-route.sh --hint "malware analysis"

Running the Integration: Cross-Platform Examples

The following examples demonstrate the complete integration flow from bootstrap to report generation, showing how AI clients invoke the client-neutral core across different platforms.

Linux and macOS (Bash)

# 1️⃣  Bootstrap (Claude Code specific - run once)

cp ./tools/claude/mcp.json ~/.claude/mcp.json

# 2️⃣  Route a user request through the core

bash skills/scripts/master-route.sh --hint "detect hidden C2 in ELF"

# 3️⃣  Initialise a case (creates work/<case>/)

bash skills/scripts/case-init.sh --hint "detect hidden C2 in ELF"

# 4️⃣  Execute the skill-specific workflow (example: IDA reverse)

bash skills/ida-reverse/run.sh --target sample.elf

# 5️⃣  Generate and view the final report

cat work/<case>/report/report.md

Windows (PowerShell)

# Same flow on Windows using PowerShell adapters

powershell -File skills/scripts/master-route.ps1 -Hint "analyze apk"
powershell -File skills/scripts/case-init.ps1 -Hint "analyze apk"

# Execute skill-specific scripts as needed

powershell -File skills/pwn-chain/run.ps1 -Target sample.apk

# Access generated reports

Get-Content work/<case>/report/report.md

Key Integration Files

The following files form the complete integration contract that all AI clients use to interact with reverse-skill:

• README_AI.md — Primary bootstrap guide for AI agents that defines the initial setup steps.
• RULES.md — Behavior-chain source of truth that defines auth-gate policies and routing constraints.
• skills/config/routing.json — Single source of truth for all task-to-skill mappings.
• skills/scripts/master-route.ps1 and skills/scripts/master-route.sh — Platform-specific entry points that perform fast routing to skill modules.
• skills/scripts/case-init.ps1 and skills/scripts/case-init.sh — Creates scoped case workspaces and enforces the auth-gate before tool execution.
• skills/ops/ — Directory containing contracts for timeline generation, evidence handling, role mapping, and final reporting.
• AGENTS.md — Policy document specifying that client adapters must remain external to the core repository.

Summary

• reverse-skill maintains a strictly client-neutral core that forbids embedded AI client logic according to AGENTS.md.
• Integration occurs through a six-step flow: bootstrap, routing table loading, fast-path routing, case initialization, tool orchestration, and reporting.
• Claude Code requires mcp.json placement in ~/.claude/, while Codex CLI, Cursor, and OpenCode need only repository access and script execution rights.
• All clients read from skills/config/routing.json and invoke the same master-route and case-init scripts located in skills/scripts/.
• Platform differences are handled through paired PowerShell (.ps1) and Bash (.sh) scripts rather than client-specific code branches.
• New AI clients can integrate by writing a thin adapter that reads README_AI.md and calls the existing shell scripts, ensuring future compatibility without core modifications.

Frequently Asked Questions

Can I use reverse-skill with AI clients not listed in the documentation?

Yes. Any AI client that can read markdown files and execute shell scripts can integrate with reverse-skill. According to the architecture defined in AGENTS.md, you only need to create a thin adapter that loads README_AI.md for bootstrap instructions, reads skills/config/routing.json for routing logic, and invokes the platform-appropriate master-route script. The core repository remains unchanged regardless of which client consumes it.

Where does the client-specific configuration live?

Client-specific configuration lives outside the core repository. For example, Claude Code places mcp.json in ~/.claude/, while other clients may store configurations in their own preference directories. The reverse-skill repository itself only contains the bootstrap instructions in README_AI.md and the universal routing core; it never contains hard-coded paths or settings specific to any particular AI client.

How does reverse-skill handle different operating systems?

The repository provides paired scripts for each integration point: Bash scripts (.sh) for Linux and macOS, and PowerShell scripts (.ps1) for Windows. The master-route and case-init scripts exist in both formats within skills/scripts/, ensuring that AI clients can invoke the appropriate version based on the host operating system without requiring client-specific modifications to the routing logic.

What happens if the routing JSON changes?

All AI clients automatically pick up routing changes because they all read from the same skills/config/routing.json file. Since the routing table is the single source of truth and contains no client-specific logic, updating the JSON immediately affects all integrated clients. This centralized approach eliminates the need to update multiple client adapters when adding new skills or modifying task mappings.

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