# Claude Code Codex vs. Other AI Assistants: A Complete Plugin Integration Comparison

> Compare Claude Code Codex, Claude Assistant, and other AI assistants plugin integration. Discover their unique formats and shared skill core from the i-have-adhd repository.

- Repository: [Ayoub Ghriss/i-have-adhd](https://github.com/ayghri/i-have-adhd)
- Tags: comparison
- Published: 2026-08-05

---

**Claude Code Codex uses a lightweight JSON-based plugin format in [`.codex-plugin/plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/.codex-plugin/plugin.json), while Claude Assistant requires a Marketplace-compatible manifest in `.claude-plugin/`, and OpenAI/Gemini rely on YAML/TOML agent configurations—yet all wrap the same reusable skill core from the *i‑have‑adhd* repository.**

The *i‑have‑adhd* project demonstrates a **portable AI skill architecture** that isolates core functionality from platform-specific adapters. This design allows a single codebase to serve multiple AI assistant ecosystems without modification to the skill logic itself. Below is a comprehensive comparison of how plugin integration differs between Claude Code Codex, Claude Assistant, OpenAI, and Gemini based on the actual implementation in `ayghri/i-have-adhd`.

---

## Core Architecture: Skill Core vs. Platform Adapters

The repository is organized into three distinct layers that enable cross-platform portability.

### Skill Core Layer

The **skill logic** resides in `skills/i-have-adhd/` and contains:

- [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) — Human-readable command specification and internal flow documentation
- Reusable parsing, reminder generation, and task-tracking implementations

This layer has **zero dependencies** on any AI assistant SDK. It defines a generic API: `input → process → output`.

### Platform Adapter Layer

Each target assistant receives its own lightweight wrapper:

| Adapter Location | Target Platform | Configuration Format |
|-----------------|-----------------|----------------------|
| `.claude-plugin/` | Claude Assistant (Marketplace) | [`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json) with `manifest`, `categories`, `permissions` |
| `.codex-plugin/` | Claude Code Codex | [`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json) with single `run` entry point |
| [`skills/i-have-adhd/agents/openai.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/agents/openai.yaml) | OpenAI | YAML with `model` and `system_prompt` |
| [`skills/i-have-adhd/agents/gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/agents/gemini.toml) | Gemini | TOML with `model` and `system_prompt` |

### Discovery and Aggregation

The root [`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json) acts as a **universal manifest** that Cursor uses for auto-detection. It references the hidden adapter directories, allowing the same repository to be imported regardless of which AI assistant the user employs.

---

## Claude Code Codex Plugin Integration

Claude Code Codex favors **minimal, function-oriented** plugin definitions.

### Manifest Structure

The [`.codex-plugin/plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/.codex-plugin/plugin.json) follows the Codex schema:

```json
{
  "name": "i-have-adhd",
  "version": "1.0.0",
  "entry_point": "run",
  "permissions": ["read"]
}

```

Key characteristics:

- **Single entry point**: Must expose a `run` function
- **Minimal permissions**: Only `read` access to skill files required
- **No build step**: JSON file plus skill directory is sufficient

### Runtime Invocation

Codex invokes the skill with a flat JSON payload:

```python
import requests

payload = {
    "action": "run",
    "parameters": {
        "prompt": "Help me schedule a 15-minute study session."
    }
}

resp = requests.post(
    "https://api.codex.ai/v1/plugins/i-have-adhd/run",
    headers={"Authorization": f"Bearer {CODEX_TOKEN}"},
    json=payload,
)

print(resp.json()["output"])

```

The Codex platform handles routing, execution sandboxing, and response serialization automatically.

---

## Claude Assistant (Marketplace) Plugin Integration

Claude Assistant uses a **richer, metadata-heavy** manifest designed for marketplace discovery.

### Manifest Structure

The [`.claude-plugin/plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/.claude-plugin/plugin.json) includes:

```json
{
  "manifest": {
    "id": "i-have-adhd",
    "name": "I Have ADHD",
    "version": "1.0.0",
    "categories": ["productivity", "health"],
    "permissions": ["readFile"]
  },
  "entry_points": {
    "execute": {
      "action": "execute",
      "parameters": {
        "prompt": "string"
      }
    }
  }
}

```

Key differences from Codex:

- **Explicit permission declarations**: `readFile` must be listed in `manifest.permissions`
- **Category taxonomy**: Required for marketplace browsing
- **Named action endpoints**: Uses `execute` rather than generic `run`

### Runtime Invocation

```python
import requests

data = {
    "action": "execute",
    "plugin_id": "i-have-adhd",
    "parameters": {
        "prompt": "Remind me to take a break in 30 minutes."
    }
}

r = requests.post(
    "https://api.anthropic.com/v1/plugins/execute",
    headers={"x-api-key": CLAUDE_KEY},
    json=data,
)

print(r.json()["result"])

```

The Claude Marketplace additionally reads [`marketplace.json`](https://github.com/ayghri/i-have-adhd/blob/main/marketplace.json) for listing metadata, separate from the runtime plugin definition.

---

## OpenAI and Gemini: Agent-Based Integration

Non-Claude platforms use **agent configuration files** rather than plugin manifests.

### OpenAI Integration

File: [`skills/i-have-adhd/agents/openai.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/agents/openai.yaml)

```yaml
name: i-have-adhd
model: gpt-4o
system_prompt: |
  You are the "I have ADHD" skill. Follow the skill's command set
  defined in SKILL.md. Parse user requests and respond with
  structured reminders and task breakdowns.

```

Runtime invocation:

```python
from openai import ChatCompletion

resp = ChatCompletion.create(
    model="gpt-4o",
    messages=[
        {
            "role": "system",
            "content": "You are the i-have-adhd skill."
        },
        {
            "role": "user",
            "content": "Create a checklist for a focused work session."
        },
    ],
)

print(resp.choices[0].message.content)

```

### Gemini Integration

File: [`skills/i-have-adhd/agents/gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/agents/gemini.toml)

```toml
name = "i-have-adhd"
model = "gemini-1.5-flash"
system_prompt = """
You are the "I have ADHD" skill. Interpret the user's request
and respond using the skill's format with clear, actionable steps.
"""

```

Runtime invocation:

```python
from google.generativeai import GenerativeModel

model = GenerativeModel(
    "gemini-1.5-flash",
    system_instruction="You are the i-have-adhd skill."
)

resp = model.generate_content(
    "Suggest a Pomodoro schedule for me."
)

print(resp.text)

```

### Key Characteristics

| Aspect | OpenAI/Gemini |
|--------|---------------|
| **Permission model** | API-key based; no manifest declarations |
| **Packaging** | Standard skill directory + agent config file |
| **Discovery** | Host platform selects adapter based on client type |
| **Invocation** | Native chat completion API, not plugin-specific endpoints |

---

## Side-by-Side Comparison

| Feature | Claude Code Codex | Claude Assistant | OpenAI | Gemini |
|--------|------------------|------------------|--------|--------|
| **Manifest format** | [`.codex-plugin/plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/.codex-plugin/plugin.json) | [`.claude-plugin/plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/.claude-plugin/plugin.json) | [`agents/openai.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/openai.yaml) | [`agents/gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/gemini.toml) |
| **Entry point** | `run` function | `execute` action | Chat completion | `generate_content` |
| **Permissions declared** | Minimal (`read`) | Explicit (`readFile`, etc.) | None (API-key scoped) | None (API-key scoped) |
| **Marketplace metadata** | No | Yes ([`marketplace.json`](https://github.com/ayghri/i-have-adhd/blob/main/marketplace.json)) | No | No |
| **Build requirement** | None | None | None | None |
| **Runtime protocol** | POST JSON to Codex endpoint | POST JSON to Anthropic endpoint | OpenAI API native | Gemini API native |

---

## Cross-Platform Evaluation

The repository includes a unified test suite to verify consistent behavior across all adapters.

### Evaluation Harness

Files:
- [`tests/test_run_evals.py`](https://github.com/ayghri/i-have-adhd/blob/main/tests/test_run_evals.py) — pytest-based test runner
- `evals/cases.jsonl` — Test cases in JSON Lines format
- [`evals/rubric.md`](https://github.com/ayghri/i-have-adhd/blob/main/evals/rubric.md) — Scoring criteria for response quality

### Running Evaluations

```bash

# Run against all configured platforms

python scripts/run_evals.py --platform all

# Run against specific adapter

python scripts/run_evals.py --platform codex
python scripts/run_evals.py --platform claude
python scripts/run_evals.py --platform openai

```

The evaluation framework injects the same test inputs through each adapter and compares outputs against the rubric, ensuring that **platform wrappers do not alter skill behavior**.

---

## Adding a New AI Assistant: Implementation Pattern

To extend `i-have-adhd` to a new assistant (e.g., a hypothetical "Nova AI"):

1. **Create adapter directory**: `.nova-plugin/` or [`agents/nova.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/nova.yaml) depending on the host's convention
2. **Write minimal manifest**: Map the host's request/response format to the generic skill API
3. **Register in root [`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json)**: Add reference for Cursor auto-discovery
4. **Add agent config if needed**: YAML/TOML for API-native assistants
5. **Extend evaluation harness**: Add `--platform nova` support in [`scripts/run_evals.py`](https://github.com/ayghri/i-have-adhd/blob/main/scripts/run_evals.py)

No changes to `skills/i-have-adhd/` are required.

---

## Summary

- **Claude Code Codex** uses the simplest plugin format—a single JSON file with a `run` entry point and minimal permissions
- **Claude Assistant** requires richer marketplace metadata with explicit permission declarations and category tags
- **OpenAI and Gemini** bypass plugin manifests entirely, using agent configuration files that inject system prompts into standard chat completion flows
- The **skill core remains identical** across all platforms; only thin adapters vary
- **Cross-platform evaluation** in [`tests/test_run_evals.py`](https://github.com/ayghri/i-have-adhd/blob/main/tests/test_run_evals.py) guarantees consistent behavior
- New assistants can be added by creating a single manifest file without modifying skill logic

---

## Frequently Asked Questions

### What file does Claude Code Codex read to discover plugins?

Claude Code Codex reads [`.codex-plugin/plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/.codex-plugin/plugin.json) for the plugin definition. Cursor aggregates this through the root [`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json) to enable auto-discovery when the repository is imported.

### Can the same skill run on Claude Code Codex and Claude Assistant simultaneously?

Yes. The repository contains both [`.codex-plugin/plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/.codex-plugin/plugin.json) and [`.claude-plugin/plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/.claude-plugin/plugin.json). Each platform reads only its respective directory, and both wrap the identical skill core in `skills/i-have-adhd/`.

### Why do OpenAI and Gemini use YAML/TOML instead of JSON manifests?

OpenAI and Gemini integrate through their native chat completion APIs rather than a plugin marketplace system. The [`openai.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/openai.yaml) and [`gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/gemini.toml) files configure how the host platform's client interacts with the skill—primarily through system prompt injection—rather than declaring a standalone plugin interface.

### How does the evaluation harness ensure consistent behavior across platforms?

[`tests/test_run_evals.py`](https://github.com/ayghri/i-have-adhd/blob/main/tests/test_run_evals.py) feeds identical inputs through each adapter and evaluates outputs against [`evals/rubric.md`](https://github.com/ayghri/i-have-adhd/blob/main/evals/rubric.md). This detects if any platform wrapper incorrectly transforms requests or responses, ensuring the skill core behavior remains portable.