# What Does "Lead with the Next Action" Mean in the i-have-adHD Rules?

> Learn what lead with the next action means in i-have-adhd rules. Get actionable commands first to overcome cognitive friction and boost productivity.

- Repository: [Ayoub Ghriss/i-have-adhd](https://github.com/ayghri/i-have-adhd)
- Tags: deep-dive
- Published: 2026-08-23

---

**"Lead with the next action" is the first rule of the i-have-adHD skill requiring that every response begins with an immediate, executable command rather than explanatory context, ensuring readers with ADHD can act without cognitive friction.**

The **i-have-adHD** repository by ayghri defines ten ADHD-friendly output rules designed to optimize technical communication for neurodivergent readers. Among these constraints, "lead with the next action" serves as the foundational formatting requirement that governs how the LLM structures its responses.

## Rule Definition and Purpose

"Lead with the next action" prioritizes **executability over exposition**. For readers with ADHD, background information or planning statements that precede the actual task create friction that overwhelms working memory and prevents execution.

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) (lines 33-36), the rule mandates:

> "The first line is something the reader can do. Not context. Not a plan. The action."

This means the opening line must be a direct command, file path, or code snippet that the reader can execute immediately. The [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md) (lines 70-71) lists this as the first of ten rules, establishing it as the primary constraint for all generated outputs.

## Technical Implementation and Enforcement

The rule is not merely advisory; it is programmatically enforced through a runtime post-processor defined in the repository's architecture.

### Runtime Adapter and Rule Loading

The skill runtime (supporting Claude, Codex, Pi, OMP, and OpenCode) loads the rule definitions from [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) at initialization time. The [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts) runtime adapter reads these constraints and stores them in the plugin's metadata, while `hooks/always-on.mjs` registers the skill to ensure every LLM response passes through the enforcement pipeline.

### Post-Processor Validation

Every generated response undergoes validation before delivery. The post-processor scans the output text; if the first non-blank line fails to match an actionable pattern (direct command, path, or code snippet), the system either rejects the response or rewrites it until compliance is achieved.

## Code Examples: Valid and Invalid Patterns

The repository provides concrete examples demonstrating compliance and violation of the rule.

### Compliant Output Structure

```markdown
Run `npm install jsonwebtoken`, then edit `src/auth.ts:42`.

1. Open `src/auth.ts`
2. Replace the `verifyToken` function (lines 42-58) with the new implementation
3. Run `npm test -- auth.spec.ts`

```

This example satisfies the rule because the first line contains an immediate executable command.

### Non-Compliant Output Structure

```markdown
Let's look at your authentication flow first.

1. Open `src/auth.ts`
2. ...

```

This output fails validation because the opening sentence is contextual prose rather than an actionable step.

### Enforcement Logic Implementation

The following pseudo-code from [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts) illustrates how the system validates the first line:

```javascript
function enforceLeadWithNextAction(output) {
  const lines = output.trim().split('\n');
  const firstLine = lines.find(l => l.trim().length > 0);
  const isAction = /^(Run|Execute|Open|Add|Create|Edit|Replace|Copy|Move|Delete)\b/.test(firstLine);
  if (!isAction) {
    throw new Error('Response does not lead with the next action');
  }
  return output;
}

```

## Why This Matters for ADHD Accessibility

Cognitive load theory underlies this constraint. When background information precedes the task, readers with ADHD must hold that context in working memory while navigating to the actual instruction—a process that often results in paralysis or distraction. By **leading with the next action**, the output eliminates the "invisible" preamble and provides an immediate on-ramp to execution.

## Summary

- **"Lead with the next action"** is the first of ten rules defined in [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md) and detailed in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md).
- The rule requires the **first non-blank line** to be an executable command, not context or planning.
- Enforcement occurs through a **post-processor** in [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts) that validates every LLM output.
- Valid actions include commands like **Run, Open, Edit, Create, Replace**, or specific file paths with line numbers.
- This constraint reduces **cognitive friction** for readers with ADHD by eliminating preamble and prioritizing immediate executability.

## Frequently Asked Questions

### How does the i-have-adHD skill detect if a response violates the "lead with the next action" rule?

The skill uses a post-processor defined in [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts) that parses the first non-empty line of generated text and checks it against an action-pattern regex. If the line does not start with verbs like Run, Open, Edit, or a concrete file path, the system flags the response for rewriting or rejection before delivery.

### Can the "lead with the next action" rule be disabled or modified in the configuration?

No. The rule is hardcoded as the foundational constraint in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) and enforced by the runtime adapter. While the repository allows for skill customization, the ten ADHD-friendly rules—including this one—are designed as immutable guardrails to ensure consistent accessibility standards across all supported platforms.

### What happens if an LLM generates background context before the actionable step?

The enforcement pipeline intercepts such outputs and either rewrites them to move the actionable content to the first line or rejects the response entirely. This ensures that regardless of the LLM's initial generation, the final delivered text always complies with the constraint defined in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) lines 33-36.

### Where are the rule definitions stored and how are they loaded at runtime?

The rule definitions reside in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), with the specific "lead with the next action" text located at lines 33-41. The [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts) runtime adapter reads these rules during plugin initialization and caches them in metadata, while `hooks/always-on.mjs` ensures the validation hook activates for every response cycle.