# How i-have-adhd Reduces Friction for Coding Task Execution: A Technical Deep Dive > Discover how i-have-adhd transforms LLM output for coding. This skill-first plugin front-loads executable actions, bridging the gap between knowing and implementing solutions for developers. - Repository: [Ayoub Ghriss/i-have-adhd](https://github.com/ayghri/i-have-adhd) - Tags: deep-dive - Published: 2026-09-11 --- **i-have-adhd is a skill-first plugin that reshapes LLM output to front-load executable actions, eliminating the cognitive gap between knowing a solution and implementing it.** The `i-have-adhd` repository by ayghri implements a behavioral constraint system designed specifically to reduce friction for coding task execution. Rather than presenting solutions as narrative text followed by code, it enforces a structure that matches ADHD-friendly cognitive processing patterns. The system transforms typical LLM responses into concise, immediately actionable plans through a three-part architecture that persists across sessions. ## The Three-Part Architecture The plugin operates through tightly coupled components that enforce 10 specific behavioral rules defined in the canonical source file. ### Canonical Rule Set (SKILL.md) The foundation resides in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), a human-readable Markdown file containing 10 ADHD-friendly constraints. Rule 1 ("Lead with the next action") mandates that the first line of every response must contain the exact command, file path, or concrete step the user can execute immediately, removing the need to parse through explanatory prose. ### Runtime Plugins (.opencode/plugins/i-have-adhd.mjs) Each supported AI harness uses a thin wrapper to load the rules. The OpenCode implementation in `.opencode/plugins/i-have-adhd.mjs` registers the `/i-have-adhd` slash command and implements the always-on flag detection logic. When active, this plugin reads the rule set and injects it into the system prompt before every turn, constraining the model's output format. ### Always-On Hook (hooks/always-on.mjs) For Claude Code and Codex users, `hooks/always-on.mjs` provides session-start automation. This script checks for the presence of a flag file and automatically triggers the skill injection at the beginning of every conversation, ensuring continuous enforcement without manual invocation. ## Mechanisms for Friction Reduction The system reduces friction for coding task execution through two primary technical mechanisms that modify how the LLM generates responses. ### Action-First Output Formatting By prepending the rule set to the system prompt, the plugin constrains the model to output the executable solution as line one. This eliminates "starter-itis"—the paralysis caused by having to hunt for the actionable piece inside a long narrative response. The user receives immediately executable commands like `npm install zod` or `edit src/utils.ts:12` before any explanation. ### Persistent Session-Wide Enforcement The always-on system uses marker files to maintain state between sessions. When `~/.config/opencode/.i-have-adhd-always` (for OpenCode) or `~/.claude/.i-have-adhd-always` (for Claude Code/Codex) exists, the plugin automatically appends the full rule set to the system prompt on every turn via `hooks/always-on.mjs` or the equivalent logic in `.opencode/plugins/i-have-adhd.mjs`. This guarantees continuous adherence to ADHD-friendly constraints without requiring the user to repeat instructions. ## Implementation and Usage Setting up the workflow requires installing the skill and optionally enabling persistent mode for continuous friction reduction. ### On-Demand Invocation Install the skill once through your harness's plugin manager, then invoke it explicitly when needed: ```bash # Install the skill claude plugin install i-have-adhd@i-have-adhd # Trigger for a specific task /i-have-adhd ``` This loads the rules into the current context, producing responses that lead with executable actions. ### Enabling Always-On Mode To reduce friction across every coding session, create the flag file specific to your runtime: ```bash # For OpenCode users touch ~/.config/opencode/.i-have-adhd-always # For Claude Code or Codex users touch ~/.claude/.i-have-adhd-always ``` With this flag present, the system automatically loads [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) into the system prompt at session start. ### Disabling Always-On Mode To return to standard LLM output behavior, remove the flag file: ```bash rm ~/.config/opencode/.i-have-adhd-always # or rm ~/.claude/.i-have-adhd-always ``` ## Summary - **i-have-adhd** modifies LLM behavior through a canonical rule set ([`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md)) containing 10 specific constraints designed to reduce friction for coding task execution. - The **action-first rule** (Rule 1) eliminates cognitive overhead by placing executable commands at the start of every response. - **Runtime plugins** (`.opencode/plugins/i-have-adhd.mjs`) provide harness-specific integration for OpenCode, Claude Code, and Codex. - The **always-on hook** (`hooks/always-on.mjs`) enforces persistent behavioral constraints via flag files in `~/.config/opencode/` or `~/.claude/`. - Together, these components transform narrative-heavy LLM responses into concise, immediately executable plans that minimize the mental load required to start coding tasks. ## Frequently Asked Questions ### How does i-have-adhd technically enforce the action-first output format? The plugin injects the contents of [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) into the system prompt, specifically highlighting Rule 1 ("Lead with the next action"). This constrains the model to output the exact executable command, file path, or concrete step as the first line of every response, eliminating the need to parse through contextual explanation to find the actionable piece. ### What is the difference between on-demand and always-on modes? On-demand mode requires typing `/i-have-adhd` to trigger the skill for a single interaction. Always-on mode uses flag files (`~/.config/opencode/.i-have-adhd-always` or `~/.claude/.i-have-adhd-always`) to automatically load the rules at session start via `hooks/always-on.mjs`, applying ADHD-friendly constraints to every turn without manual invocation. ### Which files control the persistent behavior across sessions? Persistent behavior is controlled by `hooks/always-on.mjs` for Claude Code and Codex, and by the always-on flag detection logic in `.opencode/plugins/i-have-adhd.mjs` for OpenCode. Both systems check for the existence of the dotfile flag in the user's config directory to determine whether to prepend the rule set to the system prompt on every turn. ### Can I use i-have-adhd with AI assistants other than Claude Code or OpenCode? Yes. The architecture supports multiple harnesses through runtime-specific plugins. While the repository currently implements `.opencode/plugins/i-have-adhd.mjs` for OpenCode and `hooks/always-on.mjs` for Claude Code/Codex, the skill-first design allows integration with any LLM harness that supports system prompt modification and slash commands.