Understanding the List Capping Behavior in the i-have-adhd Skill

The i-have-adhd skill enforces a strict presentation rule that limits all visible lists to a maximum of five items to reduce cognitive overload, while retaining additional entries internally for future reference or next-step actions.

The i-have-adhd project is an open-source skill designed to optimize AI responses for users with attention-deficit/hyperactivity disorder. This article examines the specific list capping behavior defined in skills/i-have-adhd/SKILL.md and explains exactly when and how this five-item constraint applies to final outputs.

What Is the List Capping Behavior?

The canonical rule "Cap lists to 5 items" appears in skills/i-have-adhd/SKILL.md at lines 103-106. This behavior mandates that any enumeration displayed in the final assistant response must not exceed five entries per group, regardless of the total number of relevant items identified during internal processing.

This restriction functions purely as a presentation layer constraint. While the assistant may analyze, search, or reason over a larger dataset internally, any list rendered into the visible output undergoes automatic truncation at the fifth item.

When Does List Capping Apply?

The restriction applies specifically to the final response—the actual text the user reads in the chat interface. It does not limit the underlying analysis, search index results, or the assistant’s internal state representation.

Final Output vs. Internal State

When preparing the visible working set, the assistant groups enumerated items and truncates them to at most five entries. The remaining items are kept internally so the assistant retains full context, but they remain hidden from the user unless explicitly requested. This distinction ensures that cognitive load reduction targets only the presentation layer without compromising analytical depth.

Handling Overflow Items

Items beyond the fifth index are suppressed from the current view but preserved in the assistant’s internal memory. The system handles this overflow through two primary patterns: deferred disclosure and next-step conversion.

Deferred Full Disclosure

If a user explicitly requests the complete set, the assistant can expand the view to reveal previously hidden entries:

You asked for the complete list – here it is:

1. Refactor the authentication middleware.
2. Add unit tests for the new routes.
3. Update documentation for the API endpoints.
4. Optimize database queries in the reporting module.
5. Review and merge pending pull requests.
6. Implement rate‑limiting for the login endpoint.
7. Add logging middleware to trace request flow.

Converting Excess to Next Actions

Alternatively, the assistant can present the sixth item as the immediate next concrete action, maintaining forward momentum while respecting the cap:

We’ve listed the top 5 items. The next actionable step is to **implement rate‑limiting** (item 6). Run `npm install rate-limit-middleware` and add it to `src/middleware/rateLimit.ts`.

Implementation Examples

The following patterns demonstrate how the capping logic separates internal data structures from visible outputs.

A properly capped list in the final response appears as standard markdown:

Here are the top 5 priorities for the sprint:

1. Refactor the authentication middleware.
2. Add unit tests for the new routes.
3. Update documentation for the API endpoints.
4. Optimize database queries in the reporting module.
5. Review and merge pending pull requests.

Internally, the assistant maintains the full dataset while rendering only the slice:

# Internal representation (not shown to the user)

full_list = [
    "Refactor auth middleware",
    "Add unit tests",
    "Update docs",
    "Optimize DB queries",
    "Review PRs",
    "Implement rate limiting",
    "Add logging middleware",
    # ...more items

]

visible_list = full_list[:5]   # shown to the user

Configuration and Source Files

The list capping behavior is defined and documented across three primary files in the repository:

• skills/i-have-adhd/SKILL.md – Contains the canonical definition of the "Cap lists to 5 items" rule at lines 103-106, along with all other ADHD-friendly response constraints.
• README.md – Provides the high-level behavioral description of the skill, including references to list truncation.
• INSTALL.md – Houses implementation notes and practical examples demonstrating how list capping functions in production scenarios.

Summary

• The list capping behavior is a presentation rule that limits visible enumerations to five items maximum.
• It is defined in skills/i-have-adhd/SKILL.md as the "Cap lists to 5 items" rule.
• The constraint applies only to final user-facing output, not to internal processing or reasoning states.
• Excess items remain accessible internally and can be surfaced via user request or converted into next actionable steps.
• This architectural pattern specifically targets working memory limitations associated with ADHD to minimize cognitive load.

Frequently Asked Questions

Does the list capping behavior delete extra items permanently?

No. According to the implementation in skills/i-have-adhd/SKILL.md, items beyond the five-item limit are retained within the assistant's internal state. Only the display rendering is truncated; the full dataset remains available for subsequent queries or deep-dive exploration.

How can I view items beyond the five-item limit?

Users can explicitly request the complete list by issuing follow-up prompts such as "show all items" or "what are the rest." When such a request is detected, the assistant expands the view to reveal the previously suppressed entries from index six onward.

Is the five-item limit configurable in the i-have-adhd skill?

Based on the current source code in skills/i-have-adhd/SKILL.md, the "Cap lists to 5 items" rule represents a fixed canonical constraint. There is no exposed configuration parameter or environment variable that adjusts this threshold in the current implementation.

Why five items specifically?

The limit targets the working memory constraints commonly associated with ADHD. By capping visible lists at five entries, the skill prevents decision paralysis and information overload while strategically preserving the ability to surface overflow items as concrete, actionable next steps.

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