# How to Fork and Customize the i-have-adhd Skill for a Custom Team Environment

> Fork and customize the i-have-adhd skill by editing its ruleset and updating plugin manifests. Republish to provide personalized ADHD-friendly guidance to your team.

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

---

**Fork the `ayghri/i-have-adhd` repository, edit [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) to tailor the ADHD-friendly ruleset, update the relevant plugin manifests, and republish the plugin so every team member receives the customized guidance on every turn.**

The `ayghri/i-have-adhd` repository provides a single source of truth that standardizes ADHD-friendly AI interactions across multiple runtimes. Teams that need collaboration-specific conventions can fork and customize the i-have-adhd skill for a custom team environment by editing the canonical ruleset and redeploying the plugin. Because the architecture relies on thin runtime adapters that read the skill file at execution time, most customizations require no adapter modifications.

## How the Skill Architecture Works

### The Canonical Ruleset in SKILL.md

The entire behavior of the skill is driven by **[`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md)**. This file contains the canonical definition of the ten ADHD-friendly response rules, and every supported runtime references it as the single source of truth. When you modify this file in your fork, all adapters automatically pick up the new rules because they read the path at runtime rather than embedding a static copy.

### Runtime Adapters and Always-On Hooks

Each supported runtime uses a thin adapter that registers the skill and optionally enforces an **always-on** mode. The adapter injects the ruleset into every conversation turn when a specific flag file is present on the user's machine.

- **Claude Code / Codex** — The `hooks/always-on.mjs` script reads [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), strips its YAML front-matter, and writes the ruleset to `stdout` during session startup. It looks for the flag file at `~/.claude/.i-have-adhd-always`.
- **OpenCode** — The `.opencode/plugins/i-have-adhd.mjs` plugin registers the skill path and implements a transformer that appends the ruleset to the system prompt while the flag file exists at `~/.config/opencode/.i-have-adhd-always`.

## Fork the Repository

Start by creating a fork through the GitHub web interface. The fork retains the original directory layout, so all relative paths in the adapters remain valid without extra configuration.

After forking, clone the repository locally and branch for your team's changes:

```bash
git clone https://github.com/<your-username>/i-have-adhd.git
cd i-have-adhd
git checkout -b team-customization

```

## Customize the Skill Rules and Manifests

### Edit the Core Ruleset

Open **[`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md)** in your editor. You can add new rules, remove defaults, or reorder sections to match your team's workflow, and because the adapters always load this file dynamically, no further code changes are needed to propagate the new ruleset.

### Update Plugin Manifests

If you change the plugin name, entry points, or metadata, update the corresponding manifest files so each runtime recognizes the modified package. The required files include [`opencode.json`](https://github.com/ayghri/i-have-adhd/blob/main/opencode.json) for OpenCode, [`.claude-plugin/plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/.claude-plugin/plugin.json) for Claude Code, [`.codex-plugin/plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/.codex-plugin/plugin.json) for Codex, and [`package.json`](https://github.com/ayghri/i-have-adhd/blob/main/package.json) for Pi and OMP when adding new extension entry points.

## Deploy the Customized Skill

### Claude Code and Codex

Publish your fork to the Claude marketplace using the CLI commands documented in [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md). Replace `<your-username>` with your GitHub namespace:

```bash
claude plugin uninstall i-have-adhd
claude plugin marketplace remove i-have-adhd
claude plugin marketplace add <your-username>/i-have-adhd
claude plugin install i-have-adhd@i-have-adhd

```

### OpenCode

Point OpenCode to your fork by updating the plugin path in [`opencode.json`](https://github.com/ayghri/i-have-adhd/blob/main/opencode.json). Then reload the plugin:

```bash
opencode plugin install

```

The comment block inside `.opencode/plugins/i-have-adhd.mjs` shows the exact path configuration to reference.

## Enable Always-On Mode for Your Team

To make the customized ruleset active on every response without manual toggling, each team member must create an **always-on flag file** in their local config directory. Distribute the following instructions or wrap them in a setup script.

For Claude Code users:

```bash
touch ~/.claude/.i-have-adhd-always

```

For OpenCode users:

```bash
mkdir -p "$(dirname "$(opencode config get XDG_CONFIG_HOME)")/opencode"
touch "$(opencode config get XDG_CONFIG_HOME)/opencode/.i-have-adhd-always"

```

When these flag files exist, the corresponding adapters continuously inject your forked [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) ruleset into every session.

## Test the Integration

Before rolling the customized skill out to the full team, run the repository's test suite to confirm the adapters still locate the skill file after your edits:

```bash
python3 -m unittest discover -s tests -v

```

Then execute the always-on specific tests defined in [`tests/test_always_on_hooks.py`](https://github.com/ayghri/i-have-adhd/blob/main/tests/test_always_on_hooks.py) to verify flag-file injection behaves correctly with your new content:

```bash
python3 -m unittest tests.test_always_on_hooks -v

```

If these tests pass, your fork is ready for production use.

## Summary

- The canonical skill definition lives in **[`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md)** and is read dynamically by all runtime adapters.
- You can fork and customize the i-have-adhd skill for a custom team environment by editing this file and updating the relevant JSON manifests.
- Deploy to Claude Code or Codex via the CLI marketplace commands, and to OpenCode by updating [`opencode.json`](https://github.com/ayghri/i-have-adhd/blob/main/opencode.json).
- Enable always-on injection by creating the appropriate flag file in each team member's config directory.
- Run `python3 -m unittest discover -s tests -v` and `python3 -m unittest tests.test_always_on_hooks` to validate the integration.

## Frequently Asked Questions

### What file should I edit to customize the i-have-adhd skill rules?

Edit **[`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md)** in your fork. This file is the single source of truth, and every adapter reads it at runtime, so changes here automatically propagate to Claude Code, Codex, and OpenCode without touching adapter code.

### Do I need to modify adapter code when the ruleset changes?

No. The adapters in `hooks/always-on.mjs` and `.opencode/plugins/i-have-adhd.mjs` dynamically load [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md). You only need to modify adapter code if you are changing the plugin name, entry point, or always-on flag logic.

### How does always-on mode work across Claude Code and OpenCode?

Always-on mode relies on a sentinel flag file. For Claude Code, the presence of `~/.claude/.i-have-adhd-always` causes `hooks/always-on.mjs` to strip the YAML front-matter from [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) and stream the ruleset into the session. For OpenCode, `~/.config/opencode/.i-have-adhd-always` triggers `.opencode/plugins/i-have-adhd.mjs` to append the ruleset to the system prompt on every turn.

### How do I verify that my forked skill injects correctly?

Run the repository's full test suite with `python3 -m unittest discover -s tests -v`. Then run `python3 -m unittest tests.test_always_on_hooks` to confirm that the flag-file detection and ruleset injection logic still function with your customized content.