# How reverse-skill Handles Different AI Clients: Claude Code, Codex CLI, and More

> Discover how reverse-skill seamlessly integrates various AI clients like Claude Code and Codex. Its client-neutral architecture with optional adapters ensures unified routing and orchestration without code changes.

- Repository: [ZhaoXu/reverse-skill](https://github.com/zhaoxuya520/reverse-skill)
- Tags: how-to-guide
- Published: 2026-08-11

---

**reverse-skill uses a client‑neutral core architecture with thin optional adapters that map each AI client's configuration format to a generic MCP (Modular Command Proxy) interface, ensuring the same routing logic and tool orchestration works across Claude Code, Codex CLI, Cursor, and other clients without code changes.**

reverse-skill is an open-source security automation framework designed to work with any AI code editor or client. According to the `zhaoxuya520/reverse-skill` source code, the project achieves this flexibility through strict separation between client-agnostic routing logic and minimal client-specific configuration adapters.

## Client-Neutral Core Architecture

The foundation of reverse-skill's multi-client support is explicitly defined in [`RULES.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/RULES.md), which mandates that **all core functionality must work for any AI editor/client** and that **client-specific adapters must not affect the routing contract** ([`RULES.md#L3`](https://github.com/zhaoxuya520/reverse-skill/blob/main/RULES.md#L3), [`RULES.md#L42`](https://github.com/zhaoxuya520/reverse-skill/blob/main/RULES.md#L42)).

The core consists of three client-independent components:

- **Skill Router** — Parses user requests, classifies tasks, and selects appropriate skills from the `skills/` directory
- **Tool Orchestration** — Invokes locally installed tools via the MCP server after routing completes
- **Generic Data Operations** — Core scripts only manipulate tool-index data, never touching client-specific configuration files ([`RULES.md#L5`](https://github.com/zhaoxuya520/reverse-skill/blob/main/RULES.md#L5))

## The Adapter Layer for Claude Code, Codex CLI, and Others

Each AI client receives a minimal adapter that translates its native configuration format into the generic MCP interface. These adapters are **optional** — users can add or remove clients simply by creating or deleting the appropriate configuration file.

| Client | Configuration Location | Adapter Function |
|--------|----------------------|------------------|
| **Claude Code** | `~/.claude/mcp.json` ([`skills/CONTRIBUTING.md#L578`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/CONTRIBUTING.md#L578)) | Writes MCP registration so Claude can discover and call tools |
| **Codex CLI** | `~/.codex/mcp.toml` (or similar) ([`README_zh.md#L55`](https://github.com/zhaoxuya520/reverse-skill/blob/main/README_zh.md#L55)) | Loads `skills/` content via project instruction files |
| **Cursor, Cline, Windsurf, Kiro, OpenCode** | Various paths (`~/.cursor/settings.json`, `~/.cline/config.yaml`, etc.) | Minimal bootstrap scripts pointing to [`RULES.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/RULES.md) and MCP endpoint |

The bootstrap process unifies client setup regardless of which AI tool you use.

### Bootstrap Script Example

Run once for any client:

```bash

# Sets up MCP server, refreshes tool-index, writes client-specific config

bash skills/scripts/bootstrap-reverse.sh

```

After bootstrap, the client can immediately invoke skills. Claude Code example:

```json
// ~/.claude/mcp.json — automatically written by bootstrap
{
  "tools": {
    "nmap": { "cmd": "nmap", "args": [] },
    "burp": { "cmd": "burp", "args": [] }
  }
}

```

Codex CLI equivalent (user-created TOML):

```toml

# ~/.codex/mcp.toml

[tools.nmap]
cmd = "nmap"
args = []

[tools.burp]
cmd = "burp"
args = []

```

Both configurations feed the identical MCP server endpoint — no skill logic changes required.

## Enforcement of Client Neutrality

The [`RULES.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/RULES.md) documentation explicitly prohibits core scripts from writing **client-global configuration** ([`RULES.md#L44`](https://github.com/zhaoxuya520/reverse-skill/blob/main/RULES.md#L44)). All client-specific behavior is isolated to:

- Platform documentation in `docs/platforms/*.md`
- Optional adapter definitions in [`AGENTS.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/AGENTS.md) ([`AGENTS.md#L45`](https://github.com/zhaoxuya520/reverse-skill/blob/main/AGENTS.md#L45))

This architectural boundary ensures future AI clients can be supported without modifying routing code, test suites, or manifests in `skills/`.

## Unified Agent Instructions

[`README_AI.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/README_AI.md) provides the canonical bootstrap procedure that every AI client should execute first. It:

1. Configures the MCP server
2. Refreshes the tool-index cache
3. Conditionally injects client-specific configuration when the target file is detected ([`README_AI.md#L5`](https://github.com/zhaoxuya520/reverse-skill/blob/main/README_AI.md#L5), [`README_AI.md#L36`](https://github.com/zhaoxuya520/reverse-skill/blob/main/README_AI.md#L36))

## Summary

reverse-skill handles Claude Code, Codex CLI, and other AI clients through:

- **Strict client neutrality** — Routing and tool orchestration live entirely in `skills/` with no client dependencies
- **Thin optional adapters** — Single-purpose configuration translators for each client's native format
- **MCP as the universal interface** — All clients communicate with skills through the same proxy protocol
- **Bootstrap automation** — One script configures the server and emits client-specific files only when needed
- **Architectural enforcement** — Documentation and code policies prevent core logic from acquiring client-specific dependencies

## Frequently Asked Questions

### Does reverse-skill require code changes to support a new AI client?

No. According to [`AGENTS.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/AGENTS.md) and [`RULES.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/RULES.md), new clients only need a minimal adapter that maps their configuration format to MCP. The core routing code in `skills/` remains untouched.

### What happens if I use multiple AI clients simultaneously?

Each client maintains its own configuration file (e.g., both `~/.claude/mcp.json` and `~/.codex/mcp.toml` can exist). All point to the same MCP server and `skills/` directory, so tool invocations remain consistent across clients.

### Where is the single source of truth for reverse-skill's behavior?

[`RULES.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/RULES.md) at the repository root. It explicitly states that skills must work for any AI editor and that client-specific adaptations must not modify the routing contract ([`RULES.md#L3`](https://github.com/zhaoxuya520/reverse-skill/blob/main/RULES.md#L3)).

### Is the MCP server bundled with reverse-skill or external?

The bootstrap script ([`skills/scripts/bootstrap-reverse.sh`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/scripts/bootstrap-reverse.sh)) sets up the MCP server as part of initial configuration. The server then persists as a local endpoint that all AI client adapters reference.