How i-have-adhd Handles Lists That Exceed Five Items: The 5-Item Rule Explained

The i-have-adhd skill enforces a strict five-item limit on any output list, automatically splitting longer lists into two ranked categories such as "do now" versus "later" or "must" versus "nice to have" to reduce cognitive overload.

When working with the ayghri/i-have-adhd repository, understanding how the skill manages lengthy enumerations is key to its ADHD-friendly design. The system prevents cognitive overwhelm by hard-capping lists at five items and restructuring any overflow into prioritized sub-lists. This approach ensures that how i-have-adhd handles lists that exceed five items remains consistent across all generated outputs.

The Five-Item Rule in SKILL.md

The canonical rule governing this behavior resides in skills/i-have-adhd/SKILL.md. Specifically, rule 9 at lines 103-106 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 operates through a four-step pipeline:

• Detect – The model identifies when a generated list would contain more than five elements
• Divide – Items are separated into two logical groups (e.g., immediate actions vs. future actions)
• Rank – Within each group, items remain rank-ordered (1-5) with critical items first
• Present – The output displays two concise lists, each containing ≤5 items

Implementation and Key Files

The repository structure propagates this rule through multiple entry points:

File	Purpose
skills/i-have-adhd/SKILL.md	Canonical skill definition containing rule 9
.cursor/skills/i-have-adhd/SKILL.md	Cursor-compatible mirror synchronized with the canonical source
hooks/hooks.json	Declares the skill as a hook for various runtimes, enforcing the rule during response generation
README.md	High-level documentation explaining the ADHD-focused design philosophy

According to the source code in skills/i-have-adhd/SKILL.md, the skill acts as a behavioral constraint layer that intercepts list generation before final output.

Practical Code Examples

The following examples demonstrate how the skill restructures overflowing lists into ADHA-friendly formats.

Node.js Project Setup

When prompted to list all steps for setting up a Node.js project including optional tooling, the skill automatically bifurcates the response:

**Do now (must-have)**
1. Run `npm init -y` to create a package.json.
2. Install essential dependencies: `npm install express`.
3. Create the entry file `index.js` with a basic server.
4. Add a start script to package.json (`"start": "node index.js"`).
5. Run `npm start` to verify the server works.

**Later (nice-to-have)**
1. Set up ESLint (`npm install eslint --save-dev`).
2. Add a .gitignore file.
3. Configure a testing framework (e.g., Jest).
4. Add a CI pipeline (GitHub Actions).
5. Document the project in a README.

Django Production Checklist

For deployment preparation queries, the skill separates critical tasks from optimizations:

**Critical (must-have)**
1. Ensure `DEBUG = False` in settings.
2. Configure allowed hosts (`ALLOWED_HOSTS`).
3. Set up a secure secret key.
4. Run database migrations (`python manage.py migrate`).
5. Collect static files (`python manage.py collectstatic`).

**Optional (nice-to-have)**
1. Enable HTTPS via a TLS certificate.
2. Set up logging and error monitoring.
3. Configure caching (Redis or Memcached).
4. Add rate-limiting middleware.
5. Perform load testing.

Why the Five-Item Limit Matters

The constraint aligns with the repository's core mission of reducing decision paralysis. By enforcing five items ranked beats ten unranked, the skill ensures that:

• Users face manageable cognitive loads
• Prioritization is explicit rather than implied
• Actionable items appear before optional ones

This implementation reflects evidence-based UX principles for ADHD accessibility, where short, categorized lists outperform comprehensive single enumerations.

Summary

• Rule 9 in skills/i-have-adhd/SKILL.md (lines 103-106) mandates a hard cap of five items per list
• Lists exceeding five items are automatically split into two ranked categories (e.g., "do now" vs. "later")
• The skill preserves ranking (1-5) within each sub-list to maintain prioritization
• Key files include the canonical SKILL.md, its Cursor mirror at .cursor/skills/i-have-adhd/SKILL.md, and hooks/hooks.json for runtime enforcement
• This approach reduces cognitive overload and supports ADHD-friendly information consumption

Frequently Asked Questions

What happens if a list has exactly six items?

The skill treats any list containing more than five items as an overflow case. With six items, it would split them into a "do now" group of five and a "later" group containing the sixth item, or redistribute them based on priority to create two smaller, balanced groups.

Can I customize the category names when splitting lists?

The source code in skills/i-have-adhd/SKILL.md specifies standard dichotomies like 'do now' vs 'later' or 'must' vs 'nice to have'. While the rule mandates splitting, the specific category labels adapt to context, always maintaining the semantic structure of immediate versus deferred importance.

Where is the five-item rule defined in the codebase?

The five-item rule is defined in skills/i-have-adhd/SKILL.md at lines 103-106. A synchronized copy exists at .cursor/skills/i-have-adhd/SKILL.md for Cursor IDE compatibility, and hooks/hooks.json registers the skill for runtime enforcement across supported platforms.

Does this rule apply to unordered bullet lists or just numbered lists?

The rule applies to all list formats generated by the model. Whether the original output would use numbered lists, bullet points, or comma-separated items, the skill enforces the five-item cap by restructuring the content into two categorized, ranked lists of five or fewer items each.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}