# What Is the “Cap Lists at 5 Items” Rule (Rule 9) in i-have-adhd?

> Learn about i-have-adhd's Rule 9, the list capping rule. Discover how limiting lists to 5 items prevents overwhelm and improves ADHD task management.

- Repository: [Ayoub Ghriss/i-have-adhd](https://github.com/ayghri/i-have-adhd)
- Tags: deep-dive
- Published: 2026-08-21

---

**Rule 9 in the i-have-adhd skill mandates that any actionable list exceeding five items must be hierarchically split into categories such as “do now” versus “later” or “must” versus “nice to have,” ensuring ADHD readers can process information without working-memory overload.**

The `i-have-adhd` repository by `ayghri` provides a specialized skill set designed to shape AI outputs for readers with attention differences. Rule 9—defined in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md)—acts as a structural constraint that prevents the cognitive paralysis often triggered by long, unprioritized task lists.

## Defining Rule 9: The Five-Item Cap

According to the canonical definition in [[`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md)](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) (lines 103–106), Rule 9 states:

> “If a list grows past five, split into ‘do now’ vs ‘later’, or ‘must’ vs ‘nice to have.’ Five items ranked beats ten unranked.”

This directive applies to any enumerated set of actions, requirements, or steps. When a draft response contains more than five discrete items, the author must either truncate the list or partition it into tiered sub-lists, ensuring the immediate priority set never exceeds the five-item threshold.

## Why Rule 9 Exists: Cognitive and Behavioral Rationale

The rule emerges from four specific design goals targeting ADHD-friendly communication.

### 1. Cognitive Load Reduction

Working memory in ADHD readers is significantly limited compared to neurotypical baselines. An unranked list of ten items demands the reader hold multiple competing priorities simultaneously, increasing the probability that critical actions are forgotten or skipped. By capping the immediate view at five items, **Rule 9 respects the reader’s cognitive bandwidth**.

### 2. Forced Prioritization

Long lists invite avoidance because they obscure where to start. Rule 9 functions as a **prioritization engine**: the author must decide which five items constitute the “do now” set, effectively creating a ranked hierarchy. This eliminates decision fatigue by presenting a clear, constrained starting point.

### 3. Motivation Maintenance

Completing a discrete, achievable chunk of five items generates **dopaminergic feedback** that sustains momentum. Seeing a truncated “later” bucket—rather than an endless scroll—transforms the task from overwhelming to manageable, preserving the reader’s motivation to continue.

### 4. Clear Action Boundaries

Splitting lists into “now” versus “later” creates **explicit boundaries** around current workload. This prevents the ADHD reader from context-switching between future hypotheticals and immediate necessities, a pattern that typically derails task completion.

## Practical Implementation: Correct vs. Incorrect Formatting

The following examples illustrate how Rule 9 transforms unstructured lists into ADHD-compliant output.

An unprioritized list violates the rule:

```markdown
**Incorrect (more than 5 items, no prioritisation)**
- Install dependencies
- Configure the database
- Set up environment variables
- Write unit tests
- Update README
- Add CI pipeline
- Deploy to staging

```

A compliant version splits actions into immediate and deferred categories:

```markdown
**Correct (capped list, split into immediate vs later)**

**Do now (≤ 5 items)**
1. Install dependencies (`npm install`).
2. Configure the database (`src/config/db.ts`).
3. Set up environment variables (`.env.example` → `.env`).
4. Write unit tests for the auth module.
5. Update the README with installation steps.

**Later**
- Add CI pipeline.
- Deploy to staging.

```

Similarly, when triaging bugs, prioritize the critical five:

```markdown
**Must (top 5)**
1. Fix token refresh bug.
2. Resolve login-redirect loop.
3. Correct typo in error messages.
4. Add missing validation on signup.
5. Update ESLint rules.

**Nice-to-have**
- Refactor auth service.
- Add TypeScript typings for JWT payload.

```

## Repository Structure and Source Files

Rule 9 is formally specified in the skill definition file, with additional context provided in the agent configuration.

- [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md): Contains the literal rule text at lines 103–106 and the complete set of ten ADHD-centric output constraints.
- [`AGENTS.md`](https://github.com/ayghri/i-have-adhd/blob/main/AGENTS.md): Maps the `i-have-adhd` skill to runtime adapters, documenting where the [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) rules are invoked during response generation.

These files collectively constitute the authoritative reference for implementing the “Cap lists at 5 items” constraint across the `ayghri/i-have-adhd` ecosystem.

## Summary

- **Rule 9** caps actionable lists at five items to prevent cognitive overload in ADHD readers.
- The rule is canonically defined in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) (lines 103–106) within the `ayghri/i-have-adhd` repository.
- Lists exceeding five items must be partitioned into prioritized tiers such as “do now” vs “later” or “must” vs “nice to have.”
- This structure reduces working-memory load, enforces prioritization, maintains dopamine-driven motivation, and clarifies immediate versus future work.
- Correct implementation requires ranking the top five actions explicitly and deferring remaining items to secondary buckets.

## Frequently Asked Questions

### Where is Rule 9 officially documented?

Rule 9 is officially documented in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) at lines 103–106 of the `ayghri/i-have-adhd` repository. This file serves as the single source of truth for all ten ADHD-centric output rules.

### Why is the threshold specifically five items?

The threshold aligns with research on working-memory capacity, which suggests most individuals can hold approximately four to seven discrete chunks of information simultaneously. Five strikes a practical balance that accommodates ADHD working-memory limitations while preserving sufficient context for meaningful action.

### How should I categorize items that exceed the five-item limit?

Excess items should be moved to a secondary tier using binary distinctions such as **“do now” versus “later”** or **“must” versus “nice to have.”** This binary split forces hierarchical thinking and prevents the primary list from becoming an overwhelming, unranked inventory.

### Does Rule 9 apply to non-actionable descriptive lists?

While Rule 9 primarily targets actionable task lists—where overwhelm directly blocks execution—it serves as a general guideline for any enumerated content in ADHD-optimized outputs. If a descriptive list exceeds five items, consider grouping items thematically or converting them into a structured table to maintain scannability.