# The 10 Canonical Response Rules for the i-have-adhd Skill: A Complete Technical Guide > Master the 10 canonical response rules for the i-have-adhd skill. This technical guide details immediate actions, numbered steps, and suppressed tangents for efficient output. - Repository: [Ayoub Ghriss/i-have-adhd](https://github.com/ayghri/i-have-adhd) - Tags: deep-dive - Published: 2026-08-21 --- **The i-have-adhd skill enforces 10 strict output rules—codified in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md)—that require every response to lead with an immediate action, use numbered steps for multi-step tasks, suppress tangents, and eliminate conversational fluff.** The **i-have-adhd** skill in the `ayghri/i-have-adhd` repository defines a rigid **IO canonical response** contract designed to make AI outputs instantly actionable for readers with ADHD. These ten rules govern everything from sentence structure to list length, ensuring that every interaction remains focused, concrete, and free of cognitive overhead. ## The 10 Canonical Response Rules Explained Each rule is enforced for the entire session unless the user explicitly disables them (e.g., by saying “stop adhd mode”). The canonical source resides at [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md). ### 1. Lead with the Next Action The first line of every response must be a concrete step the reader can perform immediately. According to the source code at lines 33-41, the output cannot open with context, greetings, or explanations; it must jump straight to the executable instruction. ### 2. Number Multi-Step Tasks When a solution requires several steps, present them as a numbered list where each step represents a single bounded action. As implemented in lines 42-55, this format prevents the reader from parsing dense paragraphs to identify discrete actions. ### 3. End with One Concrete Next Action After any explanation, the response must finish by naming **one** thing the reader can do in under two minutes. Lines 57-63 specify that this final line acts as a “release valve,” ensuring the user never faces a vague conclusion. ### 4. Suppress Tangents Finish the current issue before introducing a new one. Lines 64-70 mandate that related but separate issues must be offered as distinct questions rather than merged into the current response, preventing context switching. ### 5. Restate State Every Turn Re-announce the current step and overall progress on each turn. Lines 73-79 require this so the reader does not need to hold prior context in working memory; the response is self-contained. ### 6. Give Specific Time Estimates Provide concrete time windows (e.g., “≈15 minutes”) rather than vague descriptors like “soon” or “quickly.” Lines 82-88 emphasize temporal specificity to aid time-blindness management. ### 7. Make Completed Work Visible Explicitly state what now works and how to verify it. Lines 89-95 require the response to summarize the new state and provide a verification command or check, closing the feedback loop. ### 8. Matter-of-Fact Tone for Errors Describe failures without emotive language; give cause and fix directly. Lines 96-101 prohibit apologetic or alarming phrasing, instead requiring a neutral statement of the error, its cause, and the remediation step. ### 9. Cap Lists at Five Items If a list grows beyond five items, split it (e.g., “do now” vs. “later”). Lines 103-106 enforce this to prevent overwhelm; the reader receives only the immediately relevant subset. ### 10. No Preamble or Closing Pleasantries Start straight with the answer and finish when the answer ends. Lines 107-114 ban generic greetings, sign-offs, or “hope that helps” closures, reducing word count and social overhead. ## Implementation Examples The following snippets demonstrate correctly-shaped responses according to the 10 canonical rules. ### Example 1: Simple One-Step Fix ```markdown Run `npm install jsonwebtoken` and then edit `src/auth.ts:42` as shown. ``` **Rule compliance**: The first line is a concrete action (Rule 1). There is no preamble or sign-off (Rule 10). ### Example 2: Multi-Step Task ```markdown 1. Open `src/auth.ts`. 2. Replace the `verifyToken` function (lines 42-58) with the snippet below. 3. Run `npm test -- auth.spec.ts`. Next: run `npm test` and copy the first failing line. ``` **Rule compliance**: Steps are numbered (Rule 2). The final line gives a single actionable next step under two minutes (Rule 3). A time estimate could be added, e.g., “≈5 minutes” (Rule 6). ### Example 3: Handling an Error ```markdown Test fails at `auth.spec.ts:42`: expected 200, got 401. Cause: missing `Authorization` header. Fix: add `Authorization: Bearer ${token}` to the request. Run the test again. ``` **Rule compliance**: Uses a matter-of-fact tone (Rule 8) and ends with a concrete next action (Rule 3). ### Example 4: List Longer Than Five Items ```markdown Do now: 1. Update dependencies. 2. Fix lint errors. 3. Write missing unit tests. Later: 4. Refactor the authentication module. 5. Improve documentation. ``` **Rule compliance**: Splits a long list into “do now” vs. “later” (Rule 9), keeping each segment under the five-item cap. ## Source Files and Repository Structure The 10 canonical response rules are defined, exposed, and synchronized across three primary files in the `ayghri/i-have-adhd` repository: - **[`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md)**: The canonical source of truth containing the ten response rules and their enforcement logic (lines 33-114). - **[`AGENTS.md`](https://github.com/ayghri/i-have-adhd/blob/main/AGENTS.md)**: Provides the repository-wide mapping of agents and points to the skill’s location for runtime discovery. - **[`.cursor/skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/.cursor/skills/i-have-adhd/SKILL.md)**: A mirror of the canonical skill for Cursor-based runtimes; kept in strict sync with the source file to ensure consistent behavior across editors. ## Summary The i-have-adhd skill transforms standard AI outputs into executive-function-friendly formats by enforcing strict structural constraints: - Every response must **lead and end with a single, concrete action** (Rules 1 and 3). - **Numbered lists** organize multi-step work, capped at five items per list (Rules 2 and 9). - **State restatement** and **specific time estimates** reduce working memory load (Rules 5 and 6). - **Matter-of-fact error handling** and **zero conversational fluff** keep cognitive overhead minimal (Rules 8 and 10). - All rules reside in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) and propagate to [`.cursor/skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/.cursor/skills/i-have-adhd/SKILL.md). ## Frequently Asked Questions ### Where are the 10 canonical response rules for the i-have-adhd skill defined? The rules 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 33-114. This file serves as the single source of truth; a mirrored copy exists at [`.cursor/skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/.cursor/skills/i-have-adhd/SKILL.md) for Cursor IDE integration. ### How do I temporarily disable the i-have-adhd skill rules during a session? Users can disable the skill for the current session by explicitly requesting cancellation, such as saying “stop adhd mode.” Once disabled, the IO canonical response contract no longer applies until the session resets. ### Why is the list length capped at five items? Rule 9 caps lists at five items to prevent decision paralysis and overwhelm. According to lines 103-106 of [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md), any list exceeding five items must be split into themed sub-lists (e.g., “do now” vs. “later”), ensuring the reader processes only immediately actionable information. ### Do the canonical rules allow any exceptions? Yes. While the default flow enforces all ten rules, the skill defines explicit exceptions for scenarios requiring safety-critical confirmations or when the user explicitly requests an explanatory, non-actionable response. These exceptions override the standard “no preamble” and “lead with action” constraints temporarily.