# How Rule 2: Number Multi-Step Tasks Improves Usability in i-have-adhd

> Discover how Rule 2, numbering multi-step tasks, reduces cognitive load and clarifies actions for ADHD users in i-have-adhd. Improve usability now.

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

---

**Rule 2 requires that any response containing more than one action be formatted as a numbered list, reducing cognitive load and making next steps unmistakable for users with ADHD.**

The i-have-adhd skill is an open-source framework designed to optimize AI interactions for users with ADHD. 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), Rule 2 mandates that any multi-step instruction must be expressed as a numbered list where each item represents a single bounded step, directly addressing working memory limitations and executive function challenges.

## How Numbered Steps Reduce Cognitive Load

In [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) (lines 44-50), Rule 2 explicitly requires numbered lists for any response containing more than one action. This formatting choice targets the working memory constraints referenced in Rule 1.

### Breaking Working Memory Limits

The human brain can only hold a few items in working memory at once. A dense paragraph of instructions overwhelms this capacity, but a numbered list breaks the work into bite-size chunks that are easy to retain. Each number creates a mental bookmark, allowing the user to focus entirely on the current step without holding the entire sequence in mind.

### Creating Action-First Workflows

Rule 2 ensures the first action is always obvious and subsequent steps follow a predictable pattern. Each line tells the reader exactly *what* to do next, eliminating ambiguous "and then" chains. This structure reduces the friction between understanding and execution, matching the "action-first" principle central to the skill's design.

## Progress Tracking and Error Isolation

Numbered lists provide more than just organization—they create mechanisms for motivation and recovery.

### Visible Wins and Dopamine

Users can tick off completed numbers, gaining visible progress that satisfies the dopamine scarcity described in Rule 1 fact 5. This visible tracking keeps users motivated through multi-step processes that might otherwise feel overwhelming or endless.

### Bounded Error Recovery

By isolating steps into distinct numbers, mistakes are caught early. A failing step can be retried without re-doing the whole process, limiting the impact of a single error. This matches the "matter-of-fact" error handling style of Rule 8, making setbacks feel manageable rather than catastrophic.

## Source Code Implementation

The requirement is formally defined in the skill's specification document and supported by the extension architecture.

### SKILL.md Specification

According to [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), Rule 2 states that any response with multiple actions must use a numbered list format. This rule works alongside Rule 6 (concrete time estimates), allowing each step to be given a specific time allocation, helping users plan realistically and avoid vague "a bit of work" estimates that feel uniform to an ADHD brain.

### Activation and Enforcement

Users activate the formatting rules by running:

```text
/run i-have-adhd

```

Once activated through the TypeScript entry point at [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts), the assistant automatically prepends the next action, numbers the steps, and ends with a single concrete next action without preamble or closing pleasantries. The `hooks/always-on.mjs` script ensures these rules persist throughout the session, while [`tests/test_always_on_hooks.py`](https://github.com/ayghri/i-have-adhd/blob/main/tests/test_always_on_hooks.py) validates that outputs conform to the numbered format.

## Before and After: Rule 2 in Practice

The transformation from paragraph to numbered list demonstrates immediate usability gains.

### Unstructured Instructions

Without Rule 2, instructions appear as dense text:

```text
Open the file, locate the `verifyToken` function, replace the old implementation with the new code, then run the test suite and finally restart the server.

```

### Rule 2 Compliant Format

After applying Rule 2, the same workflow becomes:

```markdown
1. Open `src/auth.ts`
2. Replace the `verifyToken` function (lines 42-58) with the updated snippet
3. Run `npm test -- auth.spec.ts`
4. Restart the development server with `npm run dev`

```

This format isolates each action, makes the sequence explicit, and allows the user to execute steps without re-reading the entire instruction set.

## Summary

- **Rule 2 mandates numbered lists** for any multi-step response in the i-have-adhd skill, as defined in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) lines 44-50.
- **Cognitive load reduction** occurs because numbered steps respect working memory limits, presenting one bounded action at a time.
- **Actionability increases** when each number represents a single, concrete task rather than a chain of "and then" clauses.
- **Progress tracking** enables users to mark completed steps, providing visible wins that combat dopamine deficiency.
- **Error isolation** allows users to retry specific steps without restarting entire workflows, reducing frustration.

## Frequently Asked Questions

### What is Rule 2 in the i-have-adhd skill?

Rule 2 is a formatting requirement defined in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) that mandates any AI response containing more than one action must be expressed as a numbered list. Each number represents a single bounded step, ensuring clarity and reducing cognitive overhead for users with ADHD.

### How does numbering tasks help with ADHD specifically?

Numbering tasks addresses working memory limitations by breaking complex instructions into discrete, manageable chunks. According to the skill's design principles, the ADHD brain struggles to retain multiple sequential items; numbered lists externalize this memory burden, making the next action unmistakable and allowing users to track progress visually.

### Where is Rule 2 implemented in the source code?

Rule 2 is formally specified in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) at lines 44-50. The rule is enforced through the skill's TypeScript extension at [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts) and validated by test suites in [`tests/test_always_on_hooks.py`](https://github.com/ayghri/i-have-adhd/blob/main/tests/test_always_on_hooks.py), ensuring all multi-step outputs follow the numbered format.

### Can Rule 2 be used alongside other productivity rules?

Yes, Rule 2 is designed to work synergistically with other rules in the framework. It pairs particularly well with Rule 6 (concrete time estimates) to provide duration expectations per step, Rule 7 (visible progress) to enhance completion tracking, and Rule 8 (matter-of-fact error handling) to isolate and recover from mistakes in specific steps.