# How to Suppress Tangents with i-have-adhd: A Complete Guide to Rule 4 > Master i-have-adhd and suppress tangents using Rule 4. This guide shows you how to keep LLM responses focused and efficient. Get complete control now. - Repository: [Ayoub Ghriss/i-have-adhd](https://github.com/ayghri/i-have-adhd) - Tags: how-to-guide - Published: 2026-07-31 --- **To suppress tangents with i-have-adhd, invoke the skill using `/i-have-adhd` and rely on Rule 4 to ensure the LLM finishes the primary response before introducing secondary issues as separate questions.** The **i-have-adhd** skill is an open-source framework that imposes strict behavioral rules on LLM outputs to maintain focus and clarity. When you need to **suppress tangents**, you leverage **Rule 4** from the skill's metadata, which operates through prompt engineering rather than code-based detection. This rule ensures that if multiple issues exist in a query, the model addresses them sequentially rather than interleaving them. ## Understanding Rule 4: The Core Mechanism The tangent suppression capability centers on **Rule 4** defined in the skill's configuration files. ### Rule Definition and Location 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) at lines 66-73, **Rule 4** states: > "If a second issue exists, finish the first, then offer the second as a separate question." This rule defines a **tangent** as any secondary issue that could divert attention from the primary task. Instead of mixing multiple topics, the LLM completes the first response entirely, then offers the additional topic separately (for example, appending "Separately: There is also a stale dependency in package.json. Want me to update that next?"). ### How the Rule Is Enforced The implementation relies on **system prompt injection** rather than runtime code: - When the skill loads, the hosting platform (Claude, Codex, etc.) reads [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) and injects the rule set into the system prompt. - The agent definition in [`skills/i-have-adhd/agents/openai.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/agents/openai.yaml) declares the skill's display name and default prompt behavior. - The LLM receives these instructions as part of its context window and applies them during response generation. This prompt-based approach means no external code executes to "detect" tangents—the model itself follows the rule when composing answers. ## How to Activate Tangent Suppression ### Invoking the Skill You can activate the **i-have-adhd** skill using either of these command prefixes: ```bash # Option 1: Slash command /i-have-adhd # Option 2: Dollar command $i-have-adhd ``` When invoked, the skill applies all seven rules (including Rule 4) to the subsequent interaction. ### Installation and Setup To use the skill in your environment, configure it through your agent's plugin system: ```yaml # Example: Declaring the skill in a Claude plugin manifest plugins: - name: i-have-adhd path: .claude-plugin invoke: "/i-have-adhd" ``` Or install via CLI: ```bash # Using Claude Code (CLI) claude plugin marketplace add ayghri/i-have-adhd claude plugin install i-have-adhd@i-have-adhd ``` ## Practical Example: Rule 4 in Action When **Rule 4** is active, responses follow a strict sequential structure. Consider a scenario where you ask about fixing an authentication bug, but the codebase also has outdated dependencies: **Without Rule 4**, the LLM might interleave these issues, discussing dependency updates while explaining the auth fix. **With Rule 4** (suppress tangents), the output looks like this: > **Answer** > 1. Run `npm install jsonwebtoken@latest`. > 2. Edit [`src/auth.ts`](https://github.com/ayghri/i-have-adhd/blob/main/src/auth.ts) at line 42. > 3. Run `npm test -- auth.spec.ts`. > > **Separately:** There is also a stale dependency in [`package.json`](https://github.com/ayghri/i-have-adhd/blob/main/package.json). Want me to update that next? The secondary issue (stale dependency) is **deferred** until the primary task (auth fix) is complete, then offered as a new question. ## Key Configuration Files Understanding where these rules reside helps when troubleshooting or extending the skill: - **[`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md)**: Contains the complete rule set including Rule 4 (lines 66-73) that defines tangent suppression behavior. - **[`skills/i-have-adhd/agents/openai.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/agents/openai.yaml)**: The agent definition that enables the skill for OpenAI-based hosts and references the rule set. - **[`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json)**: Root metadata used by the plugin system to load and initialize the skill. - **[`INSTALL.md`](https://github.com/ayghri/i-have-adhd/blob/main/INSTALL.md)**: Platform-specific installation instructions for Claude, Codex, and other supported agents. ## Summary - **Rule 4** in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) explicitly defines how to suppress tangents by finishing the primary issue before offering secondary ones. - The skill is invoked via `/i-have-adhd` or `$i-have-adhd` commands. - Implementation occurs through **system prompt injection**, not code-based detection, ensuring the LLM follows the rule during text generation. - Tangent suppression produces structured output where secondary issues appear under a "Separately:" header after the main answer completes. - Configuration files are located in `skills/i-have-adhd/` with the main rules defined at lines 66-73 of [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md). ## Frequently Asked Questions ### What exactly constitutes a "tangent" in i-have-adhd? A **tangent** is any secondary issue or topic that could divert attention from the primary query. According to Rule 4 in the source code, if the LLM detects additional issues while answering, it must suppress the urge to address them immediately and instead complete the primary response first. Only after finishing the main answer may it offer the secondary topic as a separate question. ### How do I know if the skill is active and suppressing tangents? When **i-have-adhd** is active, you will see structured responses that strictly separate multiple issues. If you invoke `/i-have-adhd` and the LLM begins deferring secondary topics with phrases like "Separately:" or "As a separate question:", Rule 4 is functioning correctly. The skill's rules are injected via the agent 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). ### Can I modify Rule 4 to allow certain types of tangents? Yes, because the rules are defined in plain text within [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), you can fork the repository and edit lines 66-73 to adjust the tangent suppression language. However, modifying the rule text requires redeploying the skill to your agent, as the behavior is governed by the system prompt content rather than configurable runtime parameters. ### Does this work with LLM providers other than OpenAI? The repository includes agent definitions for multiple platforms. While [`skills/i-have-adhd/agents/openai.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/agents/openai.yaml) targets OpenAI-based hosts, the skill architecture supports any agent that can read markdown rule files and inject them into system prompts. Check [`INSTALL.md`](https://github.com/ayghri/i-have-adhd/blob/main/INSTALL.md) for provider-specific integration instructions and verify that your hosting platform supports skill-based prompt injection.