# Rule 1: Lead with the Next Action in i-have-adhd

> Learn Rule 1: Lead with the Next Action in i-have-adhd. This technique reduces cognitive load by providing actionable steps first, improving focus for ADHD users.

- Repository: [Ayoub Ghriss/i-have-adhd](https://github.com/ayghri/i-have-adhd)
- Tags: how-to-guide
- Published: 2026-08-21

---

**Rule 1 requires every assistant response to begin with a concrete next step, reducing cognitive load for users with ADHD by front-loading actionable instructions before explanatory context.**

The `ayghri/i-have-adhd` repository defines a set of ADHD-friendly response guidelines designed to optimize AI interactions for neurodivergent users. Rule 1, "Lead with the next action," is the foundational principle that structures how the assistant communicates task-oriented information. This rule ensures that every reply starts with an explicit instruction rather than burying actionable items within lengthy explanations.

## Understanding Rule 1: Lead with the Next Action

Rule 1 appears as the first guideline in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md). The specification requires that **every assistant response must begin by telling the user what the next concrete step is**, whether that involves executing a terminal command, providing specific information, or confirming a workflow transition.

This approach differs from traditional conversational AI patterns that often provide context-first explanations. By inverting this structure, the `i-have-adhd` skill prioritizes **actionable clarity** over narrative flow, allowing users to act immediately while optionally reading subsequent details.

## Implementation in the Codebase

The repository enforces Rule 1 through dedicated builder functions that format all output consistently. These utilities ensure that no response bypasses the "lead with action" requirement.

### Response Formatting Utilities

The `buildResponse()` function in [`utils/responseBuilder.js`](https://github.com/ayghri/i-have-adhd/blob/main/utils/responseBuilder.js) programmatically applies the Rule 1 pattern by enforcing a strict output format. This utility constructs the response string with the next action front-loaded, ensuring compliance across all skill outputs.

```javascript
// utils/responseBuilder.js
export function buildResponse(nextAction, details) {
  // Rule 1: lead with the next action
  return `**Next step:** ${nextAction}\n\n${details}`;
}

// Usage
const msg = buildResponse(
  'Run `npm install` to install dependencies.',
  'This will install all required packages listed in package.json.'
);

```

### Request Processing Pipeline

In [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts), the `handleUserRequest()` function orchestrates the request pipeline by determining the appropriate next step and delegating to the formatting utility. This entry point ensures that every user interaction passes through the Rule 1 formatting layer before returning to the caller.

```typescript
// extensions/i-have-adhd.ts
import { buildResponse } from './utils/responseBuilder';

export function handleUserRequest(request) {
  const nextAction = determineNextAction(request);
  const explanation = explainWhy(nextAction);
  return buildResponse(nextAction, explanation);
}

```

## Summary

- Rule 1 requires opening every response with an explicit next action step defined in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md).
- The `buildResponse()` utility in [`utils/responseBuilder.js`](https://github.com/ayghri/i-have-adhd/blob/main/utils/responseBuilder.js) enforces this formatting programmatically by prepending the action before details.
- The `handleUserRequest()` function in [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts) implements the rule at the request handler level.
- This structure reduces cognitive load for ADHD users by front-loading actionable instructions.

## Frequently Asked Questions

### What file defines Rule 1 in the i-have-adhd repository?

Rule 1 is formally defined in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), which contains the complete set of ADHD-friendly response guidelines for the `ayghri/i-have-adhd` skill. This markdown file serves as the authoritative source for the ten response rules that govern the assistant's behavior.

### How does the `buildResponse()` function enforce Rule 1?

The `buildResponse()` function enforces Rule 1 by accepting the `nextAction` parameter and prepending it to the response string with the label 'Next step:' before adding explanatory details. Located in [`utils/responseBuilder.js`](https://github.com/ayghri/i-have-adhd/blob/main/utils/responseBuilder.js), this utility ensures that no response can be generated without the actionable item appearing first in the output.

### How does Rule 1 differ from standard AI response patterns?

Standard AI response patterns typically provide explanatory context before presenting actionable instructions, which can obscure the immediate task for users with ADHD. Rule 1 inverts this structure by mandating that the executable step appears at the very beginning of every response, followed by optional contextual details.

### Is Rule 1 applied to all response types in the skill?

According to the implementation in [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts), Rule 1 applies to all task-oriented responses processed through the `handleUserRequest()` function, ensuring consistent formatting across the user interaction flow. While purely conversational or social responses may have different requirements, any action-inducing reply must comply with the lead-with-action pattern.