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

Claude Code Codex uses a lightweight JSON-based plugin format in .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 — 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 with manifest, categories, permissions
.codex-plugin/	Claude Code Codex	plugin.json with single run entry point
skills/i-have-adhd/agents/openai.yaml	OpenAI	YAML with model and system_prompt
skills/i-have-adhd/agents/gemini.toml	Gemini	TOML with model and system_prompt

Discovery and Aggregation

The root 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 follows the Codex schema:

{
  "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:

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 includes:

{
  "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

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 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

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:

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

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:

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	.claude-plugin/plugin.json	agents/openai.yaml	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)	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 — pytest-based test runner
• evals/cases.jsonl — Test cases in JSON Lines format
• evals/rubric.md — Scoring criteria for response quality

Running Evaluations

# 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 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: 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

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 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 for the plugin definition. Cursor aggregates this through the root 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 and .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 and 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 feeds identical inputs through each adapter and evaluates outputs against evals/rubric.md. This detects if any platform wrapper incorrectly transforms requests or responses, ensuring the skill core behavior remains portable.

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