# How the i‑have‑adhd Strategy Handles Real Ambiguity in User Requests > Discover how the i-have-adhd strategy handles real ambiguity by asking clarifying questions, not guessing. Achieve focused, actionable conversations. Learn more. - Repository: [Ayoub Ghriss/i-have-adhd](https://github.com/ayghri/i-have-adhd) - Tags: how-to-guide - Published: 2026-08-21 --- **The i‑have‑adhd strategy treats genuine ambiguity as a signal to pause and ask one short clarifying question rather than guessing, ensuring focused, actionable conversations.** The `ayghri/i-have-adhd` repository defines a skill-based interaction pattern designed for ADHD-friendly workflows. When a user’s request contains **real ambiguity**—meaning it cannot be interpreted with certainty—the system follows a strict protocol documented in the skill definition files to prevent wasted effort and maintain momentum. ## Core Rule: Ask Once, Then Proceed 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), specifically within the **"When to break the rules"** section, the assistant must handle unresolvable ambiguity by posing a single, concise clarification question. The rule mandates that the assistant wait for the user’s reply before taking any further action. This prevents the scattered energy of multiple failed attempts and keeps the conversation anchored to actionable steps. The specification emphasizes that **one short clarifying question** is the maximum allowed before pausing. This constraint aligns with the project’s broader goal of reducing cognitive overhead by eliminating guesswork. ## Practical Examples of the Clarification Pattern The following scenarios illustrate how the i‑have‑adhd skill applies the real ambiguity rule across different types of unclear requests. ### Ambiguous File Targets When the user references a component that exists in multiple locations, the assistant must identify the specific target before editing. ```text User: "Fix the login flow." ``` **Assistant (i‑have‑adhd):** > "Which file should I edit for the login flow – [`src/auth.ts`](https://github.com/ayghri/i-have-adhd/blob/main/src/auth.ts) or [`src/login.js`](https://github.com/ayghri/i-have-adhd/blob/main/src/login.js)?" This response adheres to the SKILL.md directive by isolating the ambiguity (which file) and pausing for confirmation. ### Ambiguous Command Scope Requests that lack specificity regarding breadth or targets trigger the clarification protocol. ```text User: "Update the dependencies." ``` **Assistant (i‑have‑adhd):** > "Do you want to upgrade all packages or only a specific one? If a specific one, please name it." The assistant avoids assuming a global update versus a targeted patch, directly asking the user to specify scope before executing any shell commands. ### Ambiguous Output Formats When the desired presentation format is unclear, the assistant asks for the user’s preference rather than defaulting to an arbitrary standard. ```text User: "Show me the results." ``` **Assistant (i‑have‑adhd):** > "Should I display the results as a table, JSON, or a plain text list?" This example demonstrates how the skill applies the ambiguity rule to presentation logic, ensuring the output matches the user’s immediate cognitive needs. ## Implementation in the Skill Files The behavior is formally defined in two primary documentation files within the repository: - **[`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md)** – Located at [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), this file contains the complete specification for the "When to break the rules" section, explicitly codifying the one-question limit for ambiguous scenarios. - **[`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md)** – Provides high-level context for the skill and links to the specific rule sets governing interaction patterns. These files collectively ensure that the **real ambiguity** strategy remains consistent across all implementations of the i‑have‑adhd skill, preventing deviation into speculative or multi-threaded questioning. ## Summary - **Real ambiguity** triggers a hard stop on execution until clarification is received. - The protocol mandates exactly **one short clarifying question** per ambiguous request. - Source definitions reside in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) under the "When to break the rules" section. - Examples cover file targeting, command scope, and output formatting scenarios. - The strategy prioritizes ADHD-friendly workflows by eliminating guesswork and reducing cognitive load. ## Frequently Asked Questions ### What triggers the real ambiguity rule in i‑have‑adhd? The rule activates whenever a user request contains genuine uncertainty that could lead to incorrect action, such as unspecified file paths, unclear command scopes, or undefined output formats. According to [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md), if the assistant cannot determine the user’s intent with certainty, it must ask for clarification rather than proceeding with assumptions. ### How does the i‑have‑adhd strategy differ from standard clarification flows? Standard flows often allow multiple follow-up questions or automated guessing based on probabilities. The i‑have‑adhd strategy strictly limits the interaction to **one short clarifying question** and mandates a pause until the user responds. This constraint prevents the spiraling uncertainty that can derail focus in ADHD-affected users. ### Where is the ambiguity handling rule documented? The complete specification appears in the **"When to break the rules"** section of [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) within the `ayghri/i-have-adhd` repository. The [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md) file provides additional overview and navigation to these rules. ### Can the i‑have‑adhd skill handle multiple ambiguous parameters at once? No. The skill is designed to address **one point of ambiguity at a time** using a single clarifying question. If a request contains multiple uncertainties, the assistant addresses the most critical blocker first, waits for the answer, then proceeds to the next actionable step or asks a subsequent question if new ambiguities arise.