# How the i-have-adhd Skill Suppresses Tangents in LLM Responses

> Discover how the i-have-adhd skill suppresses tangents in LLM responses by enforcing a strict one issue at a time rule and removing conversational asides. Learn more now.

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

---

**The i-have-adhd skill enforces a strict "one issue at a time" rule through Rule 4, which forces the model to complete the primary answer before mentioning secondary issues and removes "by the way" remarks via a pre-send filter.**

The **i-have-adhd** skill is a Cursor-compatible specification that reshapes how large language models communicate with readers who have ADHD. Maintained in the `ayghri/i-have-adhd` repository, this skill uses behavioral rules rather than code to constrain output generation. The **suppress tangents** mechanism—formalized as **Rule 4**—ensures that responses remain singularly focused and free of distracting digressions.

## How Rule 4: Suppress Tangents Works

The suppression logic operates in three layers, all defined in the markdown-based skill file.

### Issue Sequencing Enforcement

When a response would naturally address multiple distinct topics, the skill mandates strict serialization:

1. **Finish the first issue completely** before acknowledging any secondary matter.
2. **Present additional issues as separate questions**, appended only after the primary answer terminates.
3. **Remove "by-the-way" patterns** such as "Also, …" or "By the way, …" during the pre-send validation phase.

This sequencing prevents the cognitive overload that occurs when readers must track parallel threads.

### Pre-Send Filter Implementation

The skill engine performs a post-generation cleanup pass described at the end of [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md). This filter:

- Scans for tangent indicators (transitional phrases signaling topic shifts).
- Deletes or rewrites detected tangents into discrete follow-up offers.
- Regenerates the response if residual digressions remain after filtering.

The filter runs automatically for every response while the skill is active—no user intervention required.

### Structural Validation

Final outputs must satisfy format constraints that inherently block tangents:

| Position | Requirement | Anti-Tangent Effect |
|----------|-------------|---------------------|
| First line | Actionable step | Forces immediate relevance |
| Last line | Next concrete action | Closes the single thread cleanly |

Any content violating this structure triggers regeneration.

## Source Code Locations

The suppress tangents rule is formally specified in two identical skill definitions:

- [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) (lines 66-73)【/cache/repos/github.com/ayghri/i-have-adhd/main/skills/i-have-adhd/SKILL.md†L66-L73】
- [`.cursor/skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/.cursor/skills/i-have-adhd/SKILL.md) (duplicate for Cursor engine integration)【/cache/repos/github.com/ayghri/i-have-adhd/main/.cursor/skills/i-have-adhd/SKILL.md†L66-L73】

These files contain no executable code—the rule exists as declarative markdown that Cursor's skill engine interprets.

## Before and After Examples

**Unfiltered output (violates Rule 4):**

```text
Here's the fix for the login bug.
By the way, your README is missing a section on environment variables.
Do you want me to add that now?

```

**After suppression filter:**

```text
Here's the fix for the login bug.
Separately: your README is missing a section on environment variables. Want me to handle that next?

```

The rewrite preserves the secondary issue but transforms it from an embedded distraction into an explicit, deferrable decision point.

## Activating the Skill

Include the skill reference in your agent configuration:

```yaml

# skills/i-have-adhd/agents/openai.yaml

system: |
  {{< skill i-have-adhd >}}
user: |
  How do I refactor this function?

```

Alternative configurations exist for Gemini in [`skills/i-have-adhd/agents/gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/agents/gemini.toml). Once loaded, the skill engine applies Rule 4 to every response without additional prompting.

## Summary

- **Rule 4: Suppress Tangents** is a behavioral constraint, not a code module—it lives in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) as declarative rules.
- The skill engine enforces **sequential single-issue resolution** through pre-send filtering and structural validation.
- **Tangent patterns** (e.g., "By the way") are rewritten into **discrete follow-up questions** to maintain reader focus.
- Two file paths implement the same rule: [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) and [`.cursor/skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/.cursor/skills/i-have-adhd/SKILL.md).

## Frequently Asked Questions

### What triggers the suppress tangents filter?

The filter activates on any recognizable digression pattern: transitional phrases ("Also," "Additionally," "Speaking of which"), parenthetical asides, or appended secondary issues. The pre-send check pattern-matches against these indicators and either deletes them or restructures them into explicit follow-up offers.

### Can I customize which phrases count as tangents?

No—the current implementation in `ayghri/i-have-adhd` uses a fixed rule set defined in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md). The skill specification does not expose configuration parameters for tangent detection. Forking the repository and modifying the "Suppress tangents" section would be required to alter the behavior.

### Does the skill prevent all multi-topic responses?

Not entirely—it enforces **serialization** rather than **elimination**. Secondary topics are permitted only when reformatted as separate, explicitly deferred questions. The response may acknowledge additional issues exist, but cannot interleave their resolution with the primary answer.

### How does this differ from standard system prompt instructions?

Standard prompts rely on the model's compliance; this skill uses **guaranteed post-processing**. The Cursor skill engine validates structure after generation and regenerates non-compliant outputs, making enforcement deterministic rather than probabilistic.