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

> Deploy I-Have-ADHD across Claude Code, Codex, Pi, and more with runtime-specific manifest files. Activate this skill using slash commands or flag files for enhanced LLM interaction.

- Repository: [Ayoub Ghriss/i-have-adhd](https://github.com/ayghri/i-have-adhd)
- Tags: how-to-guide
- Published: 2026-09-09

---

**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`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/.claude-plugin/plugin.json) for Claude Code or [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts) for Pi) to locate the `skills/` directory
2. **Parsing** – The loader strips YAML front-matter from [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/.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`](https://github.com/ayghri/i-have-adhd/blob/main/.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:

```text
/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`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts).

### Extension Loading Mechanism

Both runtimes load the TypeScript extension via [`package.json`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/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:

```bash

# CLI flag for always-on at startup

pi --adhd

```

Or via chat commands:

```text
/i-have-adhd
/i-have-adhd on
/i-have-adhd off

```

## OpenCode Deployment

OpenCode uses a two-file configuration system consisting of [`opencode.json`](https://github.com/ayghri/i-have-adhd/blob/main/opencode.json) and `.opencode/plugins/i-have-adhd.mjs`.

The [`opencode.json`](https://github.com/ayghri/i-have-adhd/blob/main/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:

```bash

# 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`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/gemini-extension.json) to point to the `skills/` folder, supplemented by [`GEMINI.md`](https://github.com/ayghri/i-have-adhd/blob/main/GEMINI.md) which documents Gemini-specific installation procedures. Users can activate via the slash command or follow the tutorial in [`GEMINI.md`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/.claude-plugin/plugin.json), [`.codex-plugin/plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/.codex-plugin/plugin.json), [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts), [`opencode.json`](https://github.com/ayghri/i-have-adhd/blob/main/opencode.json), [`qwen-extension.json`](https://github.com/ayghri/i-have-adhd/blob/main/qwen-extension.json), [`kimi.plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/kimi.plugin.json), and [`gemini-extension.json`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts) file loaded via different [`package.json`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md). Runtime-specific files like [`.claude-plugin/plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/.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`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md), those changes immediately apply to Claude Code, Codex, Pi, OMP, OpenCode, Qwen, Kimi, and Gemini.