# How Rule 4 (Suppress Tangents) Handles Follow-Up Questions During Work in the i-have-adhd Skill

> Discover how i-have-adhd skill's Rule 4 handles follow-up questions, keeping you focused on tasks or deferring them to a later prompt.

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

---

**Rule 4 of the i-have-adhd skill answers follow-up questions immediately if possible, or defers them to a single "Separately" prompt at the end of the current task to preserve focus.**

The **i-have-adhd** skill is an open-source prompt engineering framework designed to make AI assistants more accessible to readers with ADHD. Rule 4, "Suppress Tangents," specifically governs how the assistant manages interruptions and secondary questions that arise mid-work. 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), this rule ensures that follow-up questions either get resolved instantly or queued cleanly—never fragmenting the user's attention.

## What Rule 4 Actually Says

The rule is defined in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) at lines 66-73:

> "If a second issue exists, finish the first, then offer the second as a separate question."

The rule adds critical nuance: **a question that arises mid-work is not a tangent**. The assistant must answer it itself if possible, folding the result into the current work. Only if the question requires the reader's input should it be deferred—and then presented **once** at task completion.

## How Follow-Up Questions Are Classified and Handled

The assistant applies a simple decision tree to every mid-work question:

| Classification | Action | Example |
|---------------|--------|---------|
| **Answerable by assistant** | Resolve immediately, integrate into workflow | Looking up a function's return type |
| **Requires reader decision** | Store and defer to single "Separately" prompt | Choosing between two implementation approaches |

This distinction matters because **working memory load stays constant**—the reader never has to track multiple open threads.

## The Deferred Question Queue

When questions require reader input, the assistant follows strict queue management:

1. **Store silently** — no interruption to current step
2. **Present once** — after the primary task completes
3. **Batch with limits** — never exceed five items (enforced by Rule 9)
4. **Split urgency** — optionally group into "do now" vs. "later"

The presentation format is standardized: *"Separately: [issue description]. Would you like me to [action] now?"*

## Practical Example: Mid-Task Interaction

Here's how Rule 4 operates in a realistic coding scenario:

```text
Assistant: 1️⃣ Open `src/auth.ts`  
Assistant: 2️⃣ Replace `verifyToken` …  
Assistant: 3️⃣ Run `npm test -- auth.spec.ts`

User:  "What does the `verifyToken` function return?"

Assistant (internal logic):
- Mid-work question detected
- Can answer from codebase → resolve immediately

Assistant: The `verifyToken` function returns a **decoded JWT payload** object 
           or throws an error if verification fails.
Assistant: 1️⃣ Open `src/auth.ts`  
Assistant: 2️⃣ Replace `verifyToken` …  
Assistant: 3️⃣ Run `npm test -- auth.spec.ts`

User:  "Also, I think my `package.json` is missing a script."

Assistant (internal logic):
- Requires user input → defer to queue

Assistant: 1️⃣ Open `src/auth.ts` … (continues without interruption)

[After step 3 completes]

Assistant: **Separately:** your `package.json` is missing a `"test"` script. 
           Would you like me to add a default script now?

```

Notice the pattern: **answerable questions disappear into the workflow**, while **decision-requiring questions surface cleanly at boundaries**.

## Implementation Logic (Pseudocode)

The Rule 4 behavior can be represented as follows:

```python
def handle_step(step, pending_questions):
    # Execute current step

    if mid_work_question:
        if can_answer_directly(mid_work_question):
            answer = resolve_question(mid_work_question)
            emit(answer)  # Immediate integration

        else:
            pending_questions.append(mid_work_question)  # Silent queue

    
    # Continue workflow uninterrupted

    return pending_questions

def finish_task(pending_questions):
    # Present all deferred questions at boundary

    for q in pending_questions[:5]:  # Rule 9 cap

        emit(f"Separately: {q} – want me to address it now?")

```

This logic preserves **single-focus execution** while ensuring nothing gets lost.

## Interaction with Other Rules

Rule 4 does not operate in isolation:

- **Rule 1 (Lead with the next action)** — deferred questions follow the same verb-first format
- **Rule 9 (Maximum five items)** — caps the pending question queue
- **Rule 10 (Offer to continue)** — natural transition point for presenting deferred items

## File References

| File | Purpose | Location |
|------|---------|----------|
| [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) | Complete rule definitions including Rule 4 | [SKILL.md](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) |
| [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md) | Skill overview and philosophy | [README.md](https://github.com/ayghri/i-have-adhd/blob/main/README.md) |
| [`tests/test_run_evals.py`](https://github.com/ayghri/i-have-adhd/blob/main/tests/test_run_evals.py) | Test harness for skill behavior validation | [test_run_evals.py](https://github.com/ayghri/i-have-adhd/blob/main/tests/test_run_evals.py) |

## Summary

- **Answerable questions** are resolved immediately and integrated into ongoing work
- **Decision-requiring questions** are silently queued and presented *once* at task completion
- The **"Separately" prompt format** clearly delineates new issues from completed work
- **Rule 9 enforces a five-item maximum** on deferred questions to prevent list overwhelm
- Rule 4 works with **Rule 1's action-first style** to maintain momentum and clarity

## Frequently Asked Questions

### What counts as a "tangent" versus a legitimate follow-up under Rule 4?

A tangent is an *unrelated second issue* that would divert attention from the current task. A mid-work question about the *current task itself*—such as clarifying a function's behavior—is **not** a tangent and should be answered immediately if possible. Only questions requiring reader decisions that would *branch* the workflow get deferred.

### Can the assistant ever break Rule 4 to answer a deferred question early?

Yes, if the user *explicitly requests clarification* mid-step, the assistant treats this as necessary to complete the current action. It answers and resumes immediately. The rule defers optional decisions, not blocking uncertainties.

### How does Rule 4 handle multiple follow-up questions accumulating?

The assistant batches deferred questions but **never exceeds five items** per Rule 9. If more accumulate, it may split them into immediate versus later groups, or prompt the user to select priority items. This prevents the "Separately" section itself from becoming overwhelming.

### Does Rule 4 apply to all types of tasks or just coding?

Rule 4 applies universally within the i-have-adhd skill framework. Whether the assistant is debugging code, researching a topic, or planning a project, the same logic governs: integrate answerable questions, defer decision-requiring ones, present at boundaries.