How i-have-adhd Caps Lists and Ranks by Priority: The 5-Item Rule Explained

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 (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 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:

**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:

**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 file (lines 105-108) contains the explicit rules governing list length and priority enforcement.

Supporting files include:

• README.md – Provides integration context and activation instructions
• plugin.json – Registers the skill with the host agent system
• agents/openai.yaml – Contains example configurations for OpenAI agent integration
• 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 at lines 105-108.
• Implementation: The skill achieves this through configuration in SKILL.md and registration via 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, 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 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 (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 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 handling skill registration and scripts/run_evals.py providing test coverage to verify the behavior.

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