# How to Disable the i-have-adhd Skill Mid-Session for Normal AI Responses

> Quickly disable the i-have-adhd skill mid-session. Say stop adhd mode or normal mode to instantly restore standard AI responses without ending your chat.

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

---

**Disable the i-have-adhd skill mid-session by saying "stop adhd mode" or "normal mode," which immediately restores standard LLM output formatting without ending the conversation.**

The **i-have-adhd** skill modifies Claude/Klara responses to prioritize actionability for readers with ADHD, but users often need to switch back to normal responses during a single conversation. This guide covers exactly how the repository implements this toggle mechanism, where the persistence logic lives, and how to verify the skill is actually off.

## Understanding the Skill's Persistence Model

The `i-have-adhd` skill follows a **session-scoped activation pattern**. Once triggered with `/i-have-adhd`, it remains active across every exchange until explicitly disabled.

This behavior is defined in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), which contains ten immutable formatting rules plus a persistence clause explaining that rules stay active until the user issues a stop command. The skill does not auto-expire or time out—Intentional, since ADHD readers benefit from consistent structure rather than unpredictable toggling.

The host platform (Claude/Klara) injects these rules into the system prompt on every turn, meaning no runtime state machine tracks activation. The skill is **pure configuration**: the platform simply includes or excludes the SKILL.md content based on user utterances matching the stop phrases.

## Disabling the Skill: Exact Commands That Work

Two voice commands reliably deactivate the skill mid-session:

| Command | Effect |
|---------|--------|
| `stop adhd mode` | Immediately strips ADHD formatting rules from subsequent responses |
| `normal mode` | Synonym that achieves identical deactivation |

Both phrases are case-insensitive and work inline—no slash command prefix required. For example:

```text
/user: stop adhd mode
assistant: ADHD mode disabled – returning to normal response style.

```

After this acknowledgment, the assistant resumes standard paragraph-based responses without numbered steps, time estimates, or "Next action" framing.

### What Happens Technically

When the platform detects either phrase in a user message, it:

1. Removes the [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) rule block from the active system prompt
2. Clears any session-level flag marking ADHD mode as active
3. Returns a confirmation response (hardcoded acknowledgment)
4. Processes subsequent messages through the base model configuration

This happens in the **same conversation thread**—no restart, no history loss, and no re-authentication required.

## Verifying the Skill Is Fully Disabled

Because the skill operates via prompt injection rather than API parameters, confirmation requires behavioral observation:

**Check 1: Response structure changes**

- **With skill active**: Responses lead with immediate actions, use numbered lists, include time estimates ("2 min"), and end with explicit next steps
- **With skill disabled**: Responses open with context or explanation, use paragraph flow, and conclude without "Next:" directives

**Check 2: Re-activation attempt**

If uncertain whether the skill is off, try re-activating:

```text
/user: /i-have-adhd

```

If the assistant responds with "ADHD mode is already active," the skill was still on. If it responds with activation confirmation, the skill was successfully disabled and you're now re-enabling it.

## Comparing Disable Methods: Command vs. Thread Reset

Two approaches exist for returning to normal responses, with different trade-offs:

| Method | When to Use | Trade-off |
|--------|-------------|-----------|
| **Voice command** (`stop adhd mode`) | Mid-conversation, preserving context | Immediate, seamless; requires remembering the phrase |
| **New thread / session reset** | When skill appears stuck or confirmation fails | Guaranteed clean state; loses conversation history |

The voice command is preferred for the `i-have-adhd` skill specifically because its **stateless design** (no server-side persistence) makes thread reset overkill except during platform bugs.

## Skill Architecture: Why Disabling Works This Way

The repository's minimal architecture explains the simple disable mechanism:

- [`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json) registers the skill name but contains **no runtime hooks**
- [`agents/openai.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/openai.yaml) and [`agents/gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/gemini.toml) enable `allow_implicit_invocation: true`, letting the platform handle activation parsing
- [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) defines behavior entirely in natural language rules, including the stop condition

There is no `deactivate()` function or state database. The platform's skill runner matches utterances against the SKILL.md instructions and includes/excludes the rule block accordingly. This pure-configuration approach makes the disable mechanism robust—fewer moving parts, no version drift between enable and disable logic.

## Re-enabling After Disabling

Users can toggle repeatedly within one session. Re-activation uses the original slash command:

```text
/user: /i-have-adhd
assistant: ADHD mode active. I'll provide action-first, numbered responses with time estimates.

```

Each toggle wipes and replaces the active rule set. There is no cooldown, rate limit, or confirmation dialog specific to the `i-have-adhd` skill.

## Summary

- **Disable with**: "stop adhd mode" or "normal mode" — natural language, no slash prefix
- **Location of rule logic**: [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) defines the ten formatting rules and stop conditions
- **Mechanism**: Platform removes rule block from system prompt; no API call or state change required
- **Verification**: Look for paragraph-based responses without numbered steps or "Next:" framing
- **Re-enable**: `/i-have-adhd` slash command restores ADHD-formatted output

The skill's configuration-only architecture makes mid-session toggling instantaneous and reliable, matching the ADHD-centric design goal of reducing friction in tool interactions.

## Frequently Asked Questions

### Can I disable i-have-adhd mode without losing my conversation history?

Yes. Saying "stop adhd mode" preserves the entire thread. The skill operates through prompt injection rather than separate API sessions, so deactivation only changes how new responses are formatted. Your prior messages remain visible and contextual.

### What if "stop adhd mode" doesn't work?

First, verify exact phrasing—the commands "stop adhd mode" and "normal mode" are the only recognized variants per [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md). If still active, the platform's skill runner may have failed to parse the utterance; start a new thread as fallback. This resets to baseline configuration without the skill's rule block.

### Does disabling mid-session affect how the assistant remembers earlier parts of the conversation?

No. The assistant's context window retains all prior exchanges. Only the **output formatting rules** are removed from the system prompt. The underlying model's memory of your discussion, files referenced, and task state remain intact.

### Can I use i-have-adhd with some assistants and normal mode with others simultaneously?

Not within a single conversation thread. However, the skill's agent configurations in [`agents/openai.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/openai.yaml) and [`agents/gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/gemini.toml) are independent—you could have ADHD mode active on a Claude-coded project (OpenAI-backed) while using default formatting on a separate Gemini-backed session, if your platform permits multiple concurrent agent contexts.