Best Practices for Using the i-have-adhd Plugin Effectively

The i-have-adhd plugin reshapes LLM output to support ADHD cognition by enforcing ten lightweight rules that prioritize immediate action, numbered steps, and concrete time estimates, staying active across turns until explicitly disabled.

The i-have-adhd plugin from the ayghri/i-have-adhd repository is a skill that transforms how language models communicate by intercepting and restructuring responses before they reach the user. By installing this plugin in Claude Code or compatible runtimes, you enable a persistent set of formatting rules defined in skills/i-have-adhd/SKILL.md that minimize cognitive load and eliminate decision paralysis. Understanding the architecture and applying targeted best practices ensures you extract maximum value from every interaction.

Understanding the Plugin Architecture

The plugin consists of five interconnected components that work together to modify LLM output in real-time.

Core Components

• skills/i-have-adhd/SKILL.md – Contains the canonical ten-rule behavior set that defines how the LLM formats responses throughout the session. This file provides the authoritative instruction set for the skill.

• README.md – Provides user-facing documentation, quick-install instructions, and the "tune it" section for customization guidance.

• .claude-plugin/plugin.json – The plugin manifest that declares the plugin name, description, and entry points to the runtime environment, enabling automatic loading in Claude Code.

• extensions/i-have-adhd.ts – TypeScript glue code that registers the skill with the host runtime, bridging the generic plugin system to the concrete LLM implementation.

• hooks/always-on.mjs – Enforces persistence by ensuring the skill remains active across conversation turns until explicitly disabled with commands like "stop adhd mode".

Runtime Implementation

The plugin registers itself through the TypeScript extension:

// extensions/i-have-adhd.ts
import { registerSkill } from '@openai/skill-runtime';

registerSkill('i-have-adhd', {
  description: 'ADHD-friendly output shaping',
  persistent: true,
  // Rule enforcement references SKILL.md
});

When activated, the pre-send hook intercepts every outgoing message after tool calls complete. This hook reorders content so that code snippets and actionable commands appear before explanatory prose, regardless of how the model initially generates the response.

The persistence layer in hooks/always-on.mjs ensures the skill does not expire after a few turns. Unlike temporary modes that require reactivation, this plugin maintains its formatting rules indefinitely until you issue a deactivation command.

10 Best Practices for Maximum Effectiveness

To leverage the i-have-adhd plugin optimally, align your workflow with these evidence-based practices derived from the skill's architecture:

1. Install via the official one-liner

   Use the CLI command provided in README.md rather than manual copying. This ensures all hook files and extensions land in the correct runtime directories.

   curl -fsSL https://raw.githubusercontent.com/ayghri/i-have-adhd/main/INSTALL.md | sh

2. Activate once per session

   Invoke the skill with the slash command /i-have-adhd. The always-on hook in hooks/always-on.mjs maintains activation automatically—you do not need to re-run this command for subsequent turns.

3. Frame requests for immediate action

   Phrase prompts to request concrete outputs first. Ask "Give me the command to install Express" rather than "Tell me about Express installation." The pre-send hook enforces action-first formatting, but precise prompting improves target accuracy.

4. Demand numbered steps for multi-part tasks

   When requesting procedures, explicitly ask for steps: "Give me the steps to configure TypeScript." The plugin automatically formats these as bounded, numbered lists (1, 2, 3) rather than prose paragraphs, preventing "and then" overwhelm.

5. Request specific time estimates

   Include "How long will this take?" in planning queries. The skill responds with concrete minute estimates (e.g., "≈ 12 min") rather than vague durations, combating time-blindness and initiation anxiety.

6. Query for single next actions

   After receiving multi-step instructions, ask "What's the next thing I should do?" to trigger the "Next: ..." formatting rule. This provides a micro-commitment target (≤ 2 minutes) that bridges the gap between reading and doing.

7. Isolate distinct topics

   Avoid compound questions. The skill enforces topic boundaries to prevent tangents—keep follow-up questions separate and sequential to maintain the linear workflow optimized in SKILL.md.

8. Repeat critical state information

   The plugin assumes limited working memory. When referring to files, line numbers, or variables across turns, restate them explicitly in the current turn rather than relying on context windows.

9. Deactivate explicitly when finished

   State "stop adhd mode" or "normal mode" to disable the skill. The plugin confirms deactivation in one line and immediately reverts to default verbose formatting.

10. Fork for team-specific tuning

    Clone the repository and modify the rule text in skills/i-have-adhd/SKILL.md if your team requires adjusted time limits or specialized formatting. Reinstall from your fork to apply customizations.

Code Examples in Practice

Below are concrete implementations showing the plugin's effect on LLM interactions.

Installation and Activation

# Install the plugin via the official installer

curl -fsSL https://raw.githubusercontent.com/ayghri/i-have-adhd/main/INSTALL.md | sh

# Activate in your Claude Code session

/i-have-adhd

# Output: ADHD mode activated. Responses will be action-first.

Example Interaction

When you ask:

How do I add lodash to a Node project?

The plugin-shaped response via the pre-send hook reformats the LLM output to:

npm install lodash@latest

1. Run the command above in your terminal.
2. Import lodash: `import _ from "lodash";`
3. Use a function: `_.chunk(array, 2)`.

Next: Run `npm test` to confirm nothing broke.  (≈ 2 min)

Note how the install command appears first, followed by numbered steps, and ends with a single next action and time estimate—exactly as specified in the ten rules.

Summary

• The i-have-adhd plugin uses a pre-send hook defined in the runtime extension to reorder responses so actionable content precedes explanation.
• Persistence is enforced by hooks/always-on.mjs, meaning the skill stays active across turns until you say "stop adhd mode".
• Effective usage requires action-first prompting, numbered step requests, and explicit time estimate queries.
• The canonical rules reside in skills/i-have-adhd/SKILL.md, while registration logic lives in extensions/i-have-adhd.ts.
• Customization is straightforward: fork the ayghri/i-have-adhd repository, modify the skill definition, and reinstall.

Frequently Asked Questions

How do I know if the i-have-adhd plugin is currently active?

The plugin stays active indefinitely once invoked with /i-have-adhd due to the always-on hook. You will notice immediate formatting changes: responses start with commands or code rather than greetings, use numbered lists instead of bullet points for sequences, and include time estimates. If you see verbose prose without these elements, the skill may be inactive—simply re-run the activation command.

Can I customize the ten rules for my specific workflow?

Yes. The rules are not hardcoded in the TypeScript extension but defined in skills/i-have-adhd/SKILL.md. Fork the ayghri/i-have-adhd repository, edit the markdown file to adjust time limits or formatting preferences, then reinstall using your fork's URL. The plugin manifest in .claude-plugin/plugin.json will load your customized skill definition on next launch.

Why does the plugin move code snippets before explanations?

This behavior stems from the pre-send hook architecture that runs after tool calls complete. The hook intercepts the LLM's generated response and reorders elements to satisfy the "lead with action" rule. This reduces cognitive load by providing the executable solution immediately, allowing users to act before reading context if they choose.

Does the plugin work with runtimes other than Claude Code?

The plugin is designed for any runtime that supports the skill registration API used in extensions/i-have-adhd.ts. The manifest file .claude-plugin/plugin.json specifically targets Claude Code, but the core skill definition in SKILL.md and the persistence hook in hooks/always-on.mjs can theoretically adapt to other LLM runtimes that implement similar plugin architectures.

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