How I-Have-ADHD is Deployed Across Different LLM Runtimes: A Complete Guide

The I-Have-ADHD skill deploys across Claude Code, Codex, Pi, OMP, OpenCode, Qwen, Kimi, and Gemini through runtime-specific manifest files that register skills/i-have-adhd/SKILL.md as an injectable system prompt, activated via the /i-have-adhd slash command or always-on flag files.

I-Have-ADHD is an open-source skill package designed to modify LLM output styles for ADHD-friendly formatting. Rather than maintaining separate codebases for each environment, the repository uses a single source of truth pattern where skills/i-have-adhd/SKILL.md contains the canonical rule set, while runtime-specific manifests handle discovery, loading, and activation. This architecture allows the project to support diverse agent platforms—from Anthropic's Claude Code to OpenCode and native JavaScript agents—using a consistent deployment model based on manifest files and slash commands.

Single Source of Truth: The SKILL.md Architecture

Every runtime deployment points to the same core definition file. The skills/i-have-adhd/SKILL.md file contains the complete rule set that governs how the model structures responses for ADHD accessibility.

When any supported runtime initializes the skill, it performs the following operations:

1. Discovery – The runtime reads its respective manifest (e.g., .claude-plugin/plugin.json for Claude Code or extensions/i-have-adhd.ts for Pi) to locate the skills/ directory
2. Parsing – The loader strips YAML front-matter from SKILL.md and stores the plain text rules
3. Injection – Rules are prepended to the system prompt either on-demand (per session) or via always-on transformers that check for flag files

This approach ensures that updating the rules in one place propagates to all supported runtimes immediately.

Claude Code and Codex Deployment

Both Claude Code and Codex use JSON-based plugin manifests to register the skill.

Claude Code Configuration

The .claude-plugin/plugin.json file registers the skill directory and configures the activation hook. Claude Code specifically implements an always-on mode through the hooks/always-on.mjs script:

• On-demand activation: Type /i-have-adhd in chat to toggle the mode for the current session. Use /i-have-adhd on or /i-have-adhd off for explicit control.
• Always-on activation: Create the flag file ~/.claude/.i-have-adhd-always. When this file exists, the hook injects the rules into every turn automatically.

The slash command updates an internal session flag and saves the state entry i-have-adhd-state, which controls whether the rules appear in the system prompt.

Codex Integration

Codex reads .codex-plugin/plugin.json to discover the skill using the same skills/ directory structure. While Codex lacks the always-on hook present in Claude Code, it exposes identical slash command functionality:

/i-have-adhd          # toggles current session state

/i-have-adhd on      # forces enable

/i-have-adhd off     # forces disable

Pi and OMP (Open-Model-Platform) Deployment

The Pi runtime (a native JavaScript agent) and OMP (Open-Model-Platform) share the same extension architecture through extensions/i-have-adhd.ts.

Extension Loading Mechanism

Both runtimes load the TypeScript extension via package.json entries:

• Pi uses the "pi" entry point
• OMP uses the "omp" entry point

The extension implements three key functions:

1. Command Registration: Adds the i-have-adhd command to the runtime's command registry
2. Session Injection: Reads SKILL.md, strips front-matter, and injects rules once per session (mirroring Claude Code's SessionStart hook)
3. Context Synchronization: For OMP specifically, the extension listens to session_compact and session_tree events to keep the rules synchronized with conversation context

Activation Methods

Users can enable ADHD mode in Pi/OMP through:

# CLI flag for always-on at startup

pi --adhd

Or via chat commands:

/i-have-adhd
/i-have-adhd on
/i-have-adhd off

OpenCode Deployment

OpenCode uses a two-file configuration system consisting of opencode.json and .opencode/plugins/i-have-adhd.mjs.

The opencode.json file points to the plugin path, while the MJS module implements:

• Skill Registration: Adds the skills/ directory to OpenCode's skill search path
• Command Registration: Implements the /i-have-adhd slash command with on and off subcommands
• Always-On Transformer: Checks for ~/.config/opencode/.i-have-adhd-always on every turn; if present, prepends the rule set to the system prompt

Enable permanent mode in OpenCode:

# Enable always-on

touch ~/.config/opencode/.i-have-adhd-always

# Disable

rm ~/.config/opencode/.i-have-adhd-always

Qwen, Kimi, and Gemini Deployment

These three runtimes follow the standard manifest pattern with slight variations in metadata handling.

Qwen

The qwen-extension.json manifest adds the skills/ folder to Qwen's runtime skill path. The client exposes the standard /i-have-adhd slash command for session-level toggling.

Kimi

Kimi reads kimi.plugin.json to register the skill directory. Following the "on-demand" pattern, users activate the mode by typing /i-have-adhd in the chat interface.

Gemini

Gemini uses gemini-extension.json to point to the skills/ folder, supplemented by GEMINI.md which documents Gemini-specific installation procedures. Users can activate via the slash command or follow the tutorial in GEMINI.md for permanent one-time installation.

Common Activation Flow Across All Runtimes

Despite platform differences, all I-Have-ADHD deployments follow a consistent four-stage lifecycle:

1. Manifest Discovery – The runtime parses its specific JSON/TypeScript manifest to locate the skill directory
2. Rule Loading – The system reads skills/i-have-adhd/SKILL.md, removes YAML front-matter, and caches the plain text rules
3. State Management – The runtime maintains an internal boolean flag (typically stored as i-have-adhd-state) that determines whether to inject rules into the system prompt
4. User Interface – All platforms expose the /i-have-adhd command family, with some supporting --adhd CLI flags (Pi/OMP) or always-on flag files (Claude Code, OpenCode)

Summary

• Single source of truth: All runtimes read from skills/i-have-adhd/SKILL.md, ensuring consistent rule updates across platforms
• Manifest diversity: Each runtime uses its own discovery format—.claude-plugin/plugin.json, .codex-plugin/plugin.json, extensions/i-have-adhd.ts, opencode.json, qwen-extension.json, kimi.plugin.json, and gemini-extension.json
• Unified activation: The /i-have-adhd slash command works identically across Claude Code, Codex, Pi, OMP, OpenCode, Qwen, Kimi, and Gemini
• Always-on options: Claude Code and OpenCode support persistent activation via flag files (~/.claude/.i-have-adhd-always and ~/.config/opencode/.i-have-adhd-always)
• CLI integration: Pi and OMP support the --adhd flag for startup activation

Frequently Asked Questions

How do I permanently enable I-Have-ADHD in Claude Code?

Create the flag file ~/.claude/.i-have-adhd-always using touch ~/.claude/.i-have-adhd-always. The hooks/always-on.mjs script checks for this file on every turn and automatically injects the ADHD formatting rules into the system prompt. To disable permanent mode, remove the file with rm ~/.claude/.i-have-adhd-always.

What is the difference between the Pi and OMP deployments?

Both runtimes use the same extensions/i-have-adhd.ts file loaded via different package.json entry points ("pi" vs "omp"). The core logic is identical, but OMP adds context synchronization through session_compact and session_tree events to handle more complex conversation state management.

Can I use the same slash commands across all supported runtimes?

Yes. Every supported runtime implements the /i-have-adhd command with consistent syntax: typing /i-have-adhd toggles the current state, while /i-have-adhd on and /i-have-adhd off provide explicit control. This unified interface is defined by the canonical rules in SKILL.md and implemented in each runtime's command handler.

Where is the actual logic that modifies the LLM responses?

The behavioral logic lives entirely in skills/i-have-adhd/SKILL.md. Runtime-specific files like .claude-plugin/plugin.json or .opencode/plugins/i-have-adhd.mjs only handle discovery, loading, and injection—they do not contain the formatting rules themselves. When you update SKILL.md, those changes immediately apply to Claude Code, Codex, Pi, OMP, OpenCode, Qwen, Kimi, and Gemini.

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