# What Is the Suppress Tangents Rule and When to Break It

> Understand the suppress tangents rule and learn when to break it for safety, clarity, or user needs. Master task management with this essential guide.

- Repository: [Ayoub Ghriss/i-have-adhd](https://github.com/ayghri/i-have-adhd)
- Tags: best-practices
- Published: 2026-08-26

---

**The *Suppress Tangents* rule requires finishing the primary task before addressing secondary issues, though it can be broken when safety, ambiguity, or explicit user requests demand immediate multi-topic coverage.**

The *Suppress Tangents* rule is a core guideline in the **ayghri/i-have-adhd** repository that governs how AI assistants structure responses for users with ADHD. According to the skill definition in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), this rule ensures that conversations remain focused on single, actionable outcomes to prevent cognitive overload. Understanding when to apply and when to violate this constraint is essential for implementing ADHD-friendly interaction patterns.

## Understanding the Suppress Tangents Rule

### Rule Definition in SKILL.md

In [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) (lines 64–70), the *Suppress Tangents* rule is explicitly defined as: *"If a second issue exists, finish the first, then offer the second as a separate question."*

The documentation contrasts a bad example—where the assistant drifts into unrelated matters mid-response—with a good example that isolates extra issues and asks whether the user wants to address them next. This structural discipline ensures that each response contains exactly one concrete action or answer.

### Why It Matters for ADHD-Friendly Communication

Readers with ADHD typically have limited working memory capacity. Introducing new topics mid-task can cause the original request to be forgotten or abandoned. By suppressing tangents, the assistant keeps **cognitive load** low and makes each step concrete and actionable.

The rule directly supports the repository's mission of creating predictable, scannable interactions that respect executive function limitations.

## When to Break the Suppress Tangents Rule

The skill's "When to break the rules" section (lines 17–26) specifies five scenarios where the *Suppress Tangents* constraint may be temporarily relaxed:

1. **Explicit comprehensive requests** – The user asks for a full explanation or walkthrough that inherently requires covering multiple topics.
2. **Safety-critical confirmations** – Destructive commands or irreversible actions require immediate contextual warnings even if they introduce secondary concerns.
3. **Debugging dead-ends** – When reaching an impasse, a diagnostic question may need to reference alternative approaches or related systems.
4. **Real ambiguity** – If the request contains genuine ambiguity, clarification may require presenting multiple possible interpretations simultaneously.
5. **Inherent multi-part tasks** – When the answer itself requires presenting multiple options or the task definition conflicts with single-threaded responses.

In these cases, the assistant may temporarily relax the constraint to provide necessary context or clarification without compromising the user's understanding.

## Implementation Examples

The following Python snippets demonstrate how an assistant implementing the **i-have-adhd** skill handles tangent suppression and exception cases.

### Standard Flow: Tangents Suppressed

```python
def respond_fix_dependency():
    # Primary fix

    action = "Run `npm install jsonwebtoken`."
    explanation = "This updates the JWT library, which resolves the auth error."
    # No tangent introduced here

    return f"{action}\n{explanation}"

```

This implementation focuses exclusively on the JWT dependency fix without mentioning the stale dev dependency visible in the lockfile.

### Secondary Issue Isolation

```python
def respond_with_tangent(primary_fix_done):
    # Primary issue already solved

    next_action = "Run the test suite to confirm the fix."
    # Tangent offered as a separate question

    tangent = "I also noticed a stale dev dependency. Would you like me to update it now?"
    return f"{next_action}\n\nSeparately: {tangent}"

```

Here the assistant completes the primary workflow before offering the secondary maintenance task as an optional follow-up.

### Breaking the Rule for Clarification

```python
def respond_need_clarification():
    # The user's request is ambiguous

    clarifying_question = "Do you want the fix for the auth token error or for the refresh token flow?"
    # Here we temporarily relax *Suppress Tangents* to get a clear answer.

    return clarifying_question

```

This example demonstrates the ambiguity exception, where presenting multiple options simultaneously is necessary to proceed.

## Summary

- The *Suppress Tangents* rule in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) mandates finishing one issue before introducing another.
- It protects **working memory** by preventing mid-task context switches that can derail users with ADHD.
- The rule supports five specific exceptions: explicit full explanations, safety-critical actions, debugging dead-ends, real ambiguity, and inherently multi-part answers.
- Implementation requires checking `primary_fix_done` status before offering tangents and recognizing when clarification demands simultaneous topic presentation.

## Frequently Asked Questions

### What file contains the official Suppress Tangents rule definition?

The official definition resides in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) at lines 64–70, which states: "If a second issue exists, finish the first, then offer the second as a separate question."

### Can I break the Suppress Tangents rule if the user seems frustrated with step-by-step responses?

Yes. If the user explicitly requests a comprehensive walkthrough or full explanation, this constitutes an exception under the "explicit comprehensive requests" clause documented in lines 17–26 of [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md).

### How do I handle a visible bug that is not part of the current task?

Follow the standard pattern: complete the primary fix, then offer the secondary issue as a separate question using a clear separator like "Separately:" or "Next, would you like me to..." This maintains focus while ensuring the tangent is not lost.

### Does breaking the rule for safety reasons require logging or notification?

While the source code in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) does not mandate specific logging mechanisms, safety-critical exceptions should be clearly marked in the response (e.g., "Before proceeding, note that...") to ensure the user recognizes the severity despite the tangent interruption.