How to Combine i-have-adhd with Other Agent Skills Without Conflicts

The i-have-adhd skill is a non-intrusive, output-style plugin that only reshapes text formatting without altering the agent's underlying execution model, making it safe to combine with any other agent skill that follows standard plugin patterns.

The ayghri/i-have-adhd repository provides a persistent skill designed to restructure agent responses into ADHD-friendly formats. Because it operates purely as a text decorator rather than a functional modifier, you can safely enable it alongside code-generation, analysis, or any other specialized agent capabilities. This compatibility stems from its stateless architecture and isolated runtime layer that never mutates global state.

Stateless Output Decoration Architecture

The i-have-adhd skill functions as a purely decorative layer in the agent pipeline. It does not create or modify global variables, files, or environment state.

All behavior is driven by the prompt-template defined in skills/i-have-adhd/agents/openai.yaml (under the default_prompt key) and the rules specified in skills/i-have-adhd/SKILL.md. Since the skill never touches shared execution context, other skills that introduce their own configuration files—such as agents/gemini.toml for Gemini-based agents—operate in complete isolation without risk of key collisions or state corruption.

Independent Runtime Layers

The skill lives in the skills/i-have-adhd/ directory and is loaded by the agent harness as a skill definition (SKILL.md) paired with a configuration file (agents/openai.yaml).

According to skills/i-have-adhd/SKILL.md at line 4, the skill sets disable-model-invocation: true. This flag instructs the harness not to invoke a separate model for this skill; instead, it merely decorates the output of the main model. Consequently, other skills that also wrap or post-process the model’s response can coexist because they each operate on the same underlying generation pipeline without competing for model invocation resources.

Session-Scoped Persistence Rules

The skill’s persistence rules (defined in skills/i-have-adhd/SKILL.md at lines 17-21) keep the ADHD-style formatting active for the entire session until the user explicitly inputs stop adhd mode.

Other skills that are session-scoped (for example, a code-generation skill that activates only when a prompt contains a specific trigger) will be activated or deactivated independently based on their own logic. Because i-have-adhd only affects output text rendering, functional skills continue to execute their core logic regardless of whether the ADHD formatter is active or dormant.

Implicit Invocation Policy

The configuration in skills/i-have-adhd/agents/openai.yaml (lines 6-8) sets allow_implicit_invocation: true. This policy allows the harness to automatically apply the skill whenever the agent detects a context that benefits from the ADHD style.

If another skill also permits implicit invocation, the harness applies them in the order they are loaded. Since i-have-adhd only modifies text formatting and never alters the functional payload of the response, it will not interfere with transformations performed by other skills.

Avoiding Conflicts with Other Skills

While the architecture prevents runtime crashes, you should configure skill loading order to prevent logical conflicts.

Competing Output-Shaping Rules

If you load two skills that both attempt to rewrite the same response (such as another "concise-output" skill alongside i-have-adhd), the last-loaded skill will overwrite the previous formatting. To prevent this, prioritize the order of skill loading in your agent configuration file so that i-have-adhd loads after functional skills but before any secondary formatters.

Duplicate Activation Triggers

If two skills share the same invocation trigger (for example, both activated by /my-skill), the harness may choose one arbitrarily. Ensure distinct trigger strings—such as /i-have-adhd for this skill—to keep activations unambiguous and user-intent clear.

Practical Configuration Examples

Enabling i-have-adhd with a Code-Generation Skill

Configure both skills in your agent plugins file:

# ~/.claude/plugins.yaml

plugins:
  - name: i-have-adhd        # ADHD output style

  - name: code-assistant     # Generates code snippets

Install both plugins via CLI:

claude plugin install i-have-adhd@latest
claude plugin install code-assistant@latest

When you request a function, the response combines both capabilities:

1. Write the function signature.
2. Implement the body.
3. Run the test suite.

✅ Function `add(a, b)` now returns the sum. Try: `python -c "print(add(2,3))"`

Disabling i-have-adhd While Preserving Other Skills

To stop the formatting without affecting other active skills:

stop adhd mode

The harness emits a single-line confirmation per the persistence rule and reverts to default style, while the code-assistant skill remains active and functional.

Combining Explicit and Implicit Invocation

You can manually ensure ADHD formatting while triggering another skill:

/i-have-adhd      # Ensures ADHD style from now on

/code-assistant   # Generates code under ADHD formatting

The output retains the ADHD structure (first line = next action) while the second skill supplies the actual code payload.

Summary

• i-have-adhd is a stateless, output-only skill that decorates text without modifying agent execution logic.
• The disable-model-invocation: true flag in SKILL.md ensures it never competes for model resources with other skills.
• Persistence rules keep the skill active session-wide until stop adhd mode is received, independent of other skill lifecycles.
• allow_implicit_invocation: true in openai.yaml allows automatic activation without blocking explicit triggers for other skills.
• To avoid formatting conflicts, manage skill load order and ensure distinct trigger strings when multiple output-shaping skills are present.

Frequently Asked Questions

Can I use i-have-adhd with code-generation or analysis skills?

Yes. The skill only reformats the final text output and does not interfere with the logic of code-generation, analysis, or data-processing skills. According to the source code in skills/i-have-adhd/SKILL.md, it operates as a post-processor on the response stream, leaving the underlying function calling and reasoning layers untouched.

Does enabling i-have-adhd modify the underlying AI model or its parameters?

No. The skill explicitly sets disable-model-invocation: true in its configuration, meaning it does not invoke a separate model or modify the primary model's parameters. It only applies a prompt-template defined in agents/openai.yaml to reshape the text of existing responses.

What happens if two skills both try to format the same output?

The agent harness applies skills in their configured load order, and the last-loaded formatter wins. If you have i-have-adhd and another output-shaping skill active simultaneously, whichever loads last will determine the final text appearance. To control this, adjust the plugin order in your configuration file.

How do I temporarily disable i-have-adhd without affecting my other active skills?

Type stop adhd mode in the chat. The persistence logic defined in SKILL.md (lines 17-21) detects this trigger and disables only the ADHD formatting for that session, leaving all other skills and their states intact.

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