What Is the Suppress Tangents Rule and When to Break It

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, 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 (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

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

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

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 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 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.

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 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.

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