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

> Discover how to combine i-have-adhd with other agent skills securely. Learn its non-intrusive design ensures no conflicts, enhancing your agent's capabilities.

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

---

**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`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/agents/openai.yaml) (under the `default_prompt` key) and the **rules** specified in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md)) paired with a **configuration file** ([`agents/openai.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/openai.yaml)).

According to [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/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`](https://github.com/ayghri/i-have-adhd/blob/main/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:

```yaml

# ~/.claude/plugins.yaml

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

  - name: code-assistant     # Generates code snippets

```

Install both plugins via CLI:

```bash
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:

```bash
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:

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