# How i‑have‑adhd Caps Lists at 5 Items: Rule 9 Explained

> Discover how i-have-adhd caps lists at 5 items using its Rule 9 prompt constraint. Learn how the LLM truncates and splits longer lists for better organization.

- 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 five‑item list limit through a prompt‑driven constraint called Rule 9, which instructs the LLM to truncate any longer list and split the remainder into a separate block.**

The `ayghri/i‑have‑adhd` repository is an open‑source AI skill designed to produce ADHD‑friendly outputs. One of its core behavioral guarantees is that enumerated lists never exceed five items. This article explains exactly how that cap is implemented, where the rule is defined, and why the authors chose this specific limit.

## Where the 5‑Item Cap Is Defined

The five‑item list limit is formally specified as **Rule 9** in the skill's configuration. Unlike traditional software constraints enforced by conditional logic, this is a **prompt‑level instruction** embedded in the system prompt sent to every LLM invocation.

Rule 9 states:

> "Cap lists at 5 items; split into now/later or must/nice‑to‑have if longer."

This rule appears in multiple configuration files across the repository:

- [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) — Human‑readable description of all 10 rules
- [`skills/i-have-adhd/agents/gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/agents/gemini.toml) — Agent configuration for Google's Gemini model
- [`skills/i-have-adhd/agents/claude.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/agents/claude.yaml) — Agent configuration for Anthropic's Claude model

According to the source code in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md), the developers selected five as a "sweet spot between providing enough actionable items and preventing information overload."

## How the LLM Enforces the Cap

The `i-have-adhd` skill does not use post‑processing code to truncate lists. Instead, it relies entirely on the LLM's instruction‑following behavior. Here's the execution flow:

1. **Prompt assembly** — The agent configuration files concatenate all 10 rules into a single system prompt string
2. **LLM invocation** — The assembled prompt is prepended to every user request
3. **Automatic compliance** — The model internally limits its output to five items when generating lists
4. **Optional splitting** — For lists exceeding five items, the model (or an optional post‑processor) inserts a divider and continues with a second block

This prompt‑driven approach means **no runtime code checks list length** — the constraint is behavioral, baked into how the model responds.

## Rule 9 in Practice: Code Examples

### Command Line Usage (Codex)

```bash
$ codex plugin marketplace add ayghri/i-have-adhd --ref main
$ codex plugin add i-have-adhd@i-have-adhd
$ i-have-adhd "Give me ten ways to improve focus"

```

**Expected output:**

```

1. Use the Pomodoro technique
2. Turn off non‑essential notifications
3. Break tasks into smaller steps
4. Keep a distraction‑free workspace
5. Schedule regular short breaks

```

Any remaining suggestions would appear in a follow‑up block labeled "later" or "nice‑to‑have."

### Claude Plugin Invocation

```bash
claude plugin marketplace add ayghri/i-have-adhd
claude plugin install i-have-adhd@i-have-adhd
/ i-have-adhd List the key features of this repository

```

**Result:**

```

1. Clear, numbered steps
2. No unnecessary pre‑ambles
3. Action‑first output style
4. Lists capped at five items
5. No recaps or closing pleasantries

```

### Raw System Prompt Fragment

```text
System prompt injected by i-have-adhd:
...
9. Cap lists at 5 items; split into now/later or must/nice-to-have if longer.
...

```

When a user asks: *"List the languages I should learn next year"*, the assistant responds with exactly five items — for example: Python, Rust, Go, TypeScript, Kotlin — then stops or continues in a labeled second group.

## Key Files That Define the List Cap

| File | Purpose |
|------|---------|
| [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) | Human‑readable rule descriptions including Rule 9 |
| [`agents/gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/gemini.toml) | Gemini‑specific prompt assembly |
| [`agents/claude.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/claude.yaml) | Claude‑specific prompt assembly |
| [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md) | Quick reference to all 10 rules |
| [`INSTALL.md`](https://github.com/ayghri/i-have-adhd/blob/main/INSTALL.md) | Rule set repeated for end users |

These files work together: [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) documents the intent, while the `.toml` and `.yaml` agent configurations operationalize it by embedding Rule 9 into executable system prompts.

## Why Five Items Specifically

The `i-have-adhd` maintainers explicitly designed for **cognitive load reduction**. Five items represent:

- Enough breadth to cover a topic meaningfully
- A small enough set to hold in working memory
- A natural breakpoint for "now versus later" prioritization

This aligns with the skill's broader design principles: clear numbered steps, no unnecessary preambles, action‑first output, and no closing pleasantries. The five‑item cap is not arbitrary — it is a deliberate UX constraint for users who benefit from concise, chunked information.

## Summary

- **Rule 9** in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) and agent config files defines the five‑item list cap
- The constraint is **prompt‑driven**, not code‑enforced — the LLM follows it automatically
- [`gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/gemini.toml) and [`claude.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/claude.yaml) inject Rule 9 into system prompts for their respective models
- Lists longer than five items are split into prioritized blocks (now/later, must/nice‑to‑have)
- The limit was chosen to balance information density with ADHD‑friendly cognitive load

## Frequently Asked Questions

### Does i‑have‑adhd use code to truncate lists?

No. The skill relies entirely on prompt engineering. Rule 9 is embedded in the system prompt, and the LLM's instruction‑following behavior ensures compliance without additional runtime checks.

### Where can I read the exact wording of Rule 9?

The canonical definition is in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md). The same rule appears in [`agents/gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/gemini.toml) and [`agents/claude.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/claude.yaml) where it is concatenated into executable system prompts.

### What happens to list items beyond the fifth?

The model either omits them or splits them into a second labeled block such as "later" or "nice‑to‑have." This behavior is also specified in Rule 9's directive to split longer lists.

### Can I change the list cap to a different number?

Yes, by forking the repository and modifying Rule 9 in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) and the corresponding agent configuration files. However, this would deviate from the skill's ADHD‑optimized design rationale.