# Lead with the Next Action Rule in i-have-adhd: A Complete Guide > Master the lead with the next action rule in i-have-adhd. Get actionable steps first for immediate progress in this complete guide. - Repository: [Ayoub Ghriss/i-have-adhd](https://github.com/ayghri/i-have-adhd) - Tags: deep-dive - Published: 2026-08-25 --- **The "lead with the next action" rule mandates that every response must start with a concrete, immediately-executable step for the reader before providing any explanation, context, or background information.** The `ayghri/i-have-adhd` repository defines a specialized skill for AI interactions designed to accommodate cognitive patterns associated with ADHD. 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), this rule appears as the very first guideline in the skill definition, establishing the fundamental structure for all subsequent exchanges. ## What Is the Lead with the Next Action Rule? In [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) (lines 33–41), the **lead with the next action** rule is defined as the primary constraint governing response formatting. The specification requires that every output begin with a specific, actionable instruction that the user can execute immediately, **before** any explanatory text, reasoning, or planning details appear. This structural requirement directly addresses the **working memory limitations** common in ADHD by ensuring the most critical information—the next physical or digital action—appears at the maximum point of attention. The rule intentionally inverts the traditional communication pattern of "explanation-then-action," instead presenting "action-then-context." ## Why This Rule Reduces Cognitive Load The rule serves three specific cognitive purposes according to the implementation: - **Working memory limitation accommodation** – Users cannot retain lengthy prose while processing instructions; placing the actionable item first ensures it is captured before attention drifts. - **Friction reduction** – Initiating tasks presents the highest cognitive barrier for ADHD brains; a clear first action eliminates the paralysis of starting. - **Interaction consistency** – Every turn follows this pattern, creating a predictable rhythm that reduces the mental overhead of parsing varied response structures. ## Code Examples from the Source The [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) file (lines 37–40) provides concrete examples distinguishing compliant and non-compliant responses: *Bad example* (violates the rule): ```text Let's think about this. Your auth flow has a few moving pieces: the middleware, the token verification, and the cookie handling... ``` *Good example* (complies with the rule): ```text Run `npm install jsonwebtoken`, then edit `src/auth.ts:42`. ``` The compliant example leads with the **immediately-executable command** (`npm install`) and specific file editing instruction, postponing conceptual explanation until after the user has begun acting. ## Implementation in the Skill Architecture The rule is documented in **section 1** of [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), positioned as the foundation of the ten-rule system summarized in [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md). When implemented in an AI assistant using this skill, the rule creates a deterministic pattern: the first line of every response must contain a verb-driven instruction (e.g., "Run," "Edit," "Create," "Delete") followed by specific parameters such as file paths, package names, or line numbers. This implementation ensures that users encounter **zero-threshold entry points** into tasks, transforming abstract objectives into concrete micro-steps that require no parsing or interpretation before execution. ## Summary - The **lead with the next action** rule requires opening every response with an immediately-executable step. - Documentation resides in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) (lines 33–41) as the first rule of the skill. - The pattern addresses ADHD-related **working memory constraints** by placing actionable information at the point of maximum attention. - Valid responses must start with specific commands (e.g., `npm install`, file edits) before offering explanation. - The [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md) summarizes this as one of ten core rules governing the interaction pattern. ## Frequently Asked Questions ### What does "lead with the next action" mean in i-have-adhd? It means every AI response must begin with a concrete, executable instruction—such as a command to run or a file to modify—before providing any explanatory text or context. This ensures the user sees exactly what to do next without having to read through background information first. ### Where is the lead with the next action rule documented? The rule is documented 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–41, where it appears as the first rule in the skill definition. The [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md) file also references this rule as part of the ten-rule system governing ADHD-optimized interactions. ### Why is the executable step placed before explanation? This placement accounts for **working memory limitations** associated with ADHD. Users may lose focus or forget details when reading lengthy explanations first; by placing the action at the beginning, the critical instruction is captured while attention is highest, with optional context available afterward if needed. ### Can context ever come before the action in this skill? No. According to the source code in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md), the rule mandates that context, explanation, and planning details must follow the initial executable step, never precede it. The examples in lines 37–40 explicitly contrast the incorrect pattern (leading with analysis) versus the correct pattern (leading with commands).