# How i-have-adhd Caps Lists and Ranks by Priority: The 5-Item Rule Explained > Discover how i-have-adhd caps lists to 5 items, prioritizing tasks and managing overflow into 'do now' or 'later' buckets. Prevent cognitive overload and boost productivity. - Repository: [Ayoub Ghriss/i-have-adhd](https://github.com/ayghri/i-have-adhd) - Tags: deep-dive - Published: 2026-07-31 --- **The i-have-adhd skill enforces a strict five-item limit on all generated lists and orders them by priority, splitting any overflow into categorized buckets like "do now" versus "later" to prevent cognitive overload.** The `ayghri/i-have-adhd` repository provides a specialized skill designed to keep AI-generated content actionable and digestible for users with ADHD. By strictly limiting list length and enforcing priority rankings, this tool ensures that readers can quickly identify their next step without facing decision paralysis. Understanding how i-have-adhd caps lists and ranks by priority reveals the design philosophy behind its bite-sized output strategy. ## The Five-Item Maximum Cap At the core of the skill's design is an unbreakable rule: **no list may exceed five items**. When content generation would naturally produce more than five entries, the skill automatically partitions the list into separate categorized buckets rather than presenting a long, scrolling enumeration. 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) (lines 105-108), this constraint exists to prevent overwhelming the reader. The documentation explicitly states that when a generated list contains more than five entries, the skill must split it into two distinct buckets—commonly using temporal distinctions like "do now" versus "later" or priority distinctions like "must" versus "nice to have." ## Priority Ranking Within the Cap Simply limiting length is not sufficient; the skill also mandates **strict priority ordering**. Within any capped list of five items, the most urgent and important actions must appear first, creating a ranked hierarchy that guides immediate attention. The [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) file emphasizes this principle with the directive: "Five items ranked beats ten unranked." This ranking ensures that even within the permitted five-item window, the reader can instantly identify which single action to take next, maintaining momentum without wasting cognitive resources on comparison or sorting. ## The Split-Bucket Strategy for Overflow When content naturally exceeds the five-item boundary, the skill employs a bifurcation strategy that preserves the cap while accommodating additional information. ### Temporal Splits: Do Now vs. Later The first overflow pattern separates items by immediacy. The skill creates two distinct five-item-capped lists labeled by time sensitivity: ```markdown **Do now** 1. Open the repository in your IDE. 2. Run `npm install` to install dependencies. 3. Add the `i-have-adhd` skill to your `.cursor` folder. 4. Enable the skill with `/i-have-adhd`. 5. Test the skill by typing `$i-have-adhd` in a new session. **Later** 1. Configure additional agent settings. 2. Review documentation updates. ``` ### Priority Splits: Must vs. Nice to Have Alternatively, the skill may categorize by necessity rather than timing: ```markdown **Must** 1. Add `SKILL.md` to the skill directory. 2. Update the skill manifest (`plugin.json`). **Nice to have** 1. Write unit tests for the skill. 2. Document usage examples in `README.md`. ``` Both approaches maintain the five-item limit within each bucket while ensuring that the highest-priority items receive prime visual placement. ## Implementation in the Codebase The capping and ranking logic is defined in the skill's primary definition file. The [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) file (lines 105-108) contains the explicit rules governing list length and priority enforcement. Supporting files include: - [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md) – Provides integration context and activation instructions - [`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json) – Registers the skill with the host agent system - [`agents/openai.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/openai.yaml) – Contains example configurations for OpenAI agent integration - [`scripts/run_evals.py`](https://github.com/ayghri/i-have-adhd/blob/main/scripts/run_evals.py) – Houses the test harness for verifying list-capping behavior ## Summary - **Maximum capacity**: All lists are strictly capped at five items to prevent cognitive overload. - **Mandatory ranking**: Items must be ordered by priority, with the most urgent actions appearing first. - **Overflow handling**: Excess items are split into secondary buckets (temporal or priority-based) rather than extending the primary list. - **Source definition**: The five-item rule and ranking requirements are explicitly defined in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) at lines 105-108. - **Implementation**: The skill achieves this through configuration in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) and registration via [`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json). ## Frequently Asked Questions ### Why does i-have-adhd limit lists to five items specifically? The five-item limit represents the cognitive sweet spot for working memory and decision-making in users with ADHD. According to the source documentation in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), exceeding this threshold creates overwhelm and decision paralysis, while shorter lists maintain the "bite-sized" actionability that keeps readers moving forward without getting lost in options. ### How does the skill decide which items rank highest? The skill orders items by urgency and importance, placing the most critical actions at the top of the list. The [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) file explicitly directs that "Five items ranked beats ten unranked," meaning the system prioritizes creating a clear hierarchy over comprehensive coverage. When using split buckets, items in the primary bucket ("do now" or "must") automatically outrank those in secondary buckets. ### Can developers configure the five-item limit? Based on the current implementation in `ayghri/i-have-adhd`, the five-item cap appears to be a fixed constraint rather than a configurable parameter. The rule is hardcoded into the skill's behavioral definition in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) (lines 105-108), suggesting it is a core design philosophy rather than an adjustable setting. Developers wishing to modify this behavior would likely need to fork the repository and edit the skill definition directly. ### Where is the ranking logic enforced in the codebase? The ranking and capping instructions are defined in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) at lines 105-108. This file serves as the behavioral contract for the skill. The actual enforcement mechanism depends on the host agent's interpretation of these instructions, with [`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json) handling skill registration and [`scripts/run_evals.py`](https://github.com/ayghri/i-have-adhd/blob/main/scripts/run_evals.py) providing test coverage to verify the behavior.