# What Is the Architecturally Most Important Rule in the i-have-adhd Skill?

> Discover the architecturally most important rule in the i-have-adhd skill. Learn how "Lead with the next action" drives effective task completion and boosts productivity.

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

---

**The architecturally most important rule in the i-have-adhd skill is Rule 1 – "Lead with the next action," which mandates that every response must begin with a concrete, immediately executable step for the reader.**

The `ayghri/i-have-adhd` repository defines a specialized skill designed to optimize AI outputs for users with ADHD, and this foundational rule ensures clarity and actionability above all else. According to the canonical skill definition, the entire architectural intent centers on front-loading actionable instructions to prevent cognitive overhead and enable immediate execution.

## Rule 1 – Lead With the Next Action

The cornerstone of the *i-have-adhd* skill architecture resides in **Rule 1**, explicitly defined 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-36. The specification states:

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

This directive is non-negotiable. Unlike traditional technical documentation that might begin with background information or high-level planning, this rule requires the first line of every response to be a verb-driven instruction that the reader can execute immediately. The architectural significance lies in its role as the load-bearing structure upon which all nine remaining rules depend.

## Implementation in the Source Files

The rule is codified in two primary locations within the repository:

- **[`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md)** – The canonical definition file containing all 10 rules, with Rule 1 establishing the "lead with the next action" mandate.

- **[`.cursor/skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/.cursor/skills/i-have-adhd/SKILL.md)** – A Cursor IDE-compatible mirror that enforces the same architectural constraints at runtime.

The [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md) provides invocation instructions, while [`AGENTS.md`](https://github.com/ayghri/i-have-adhd/blob/main/AGENTS.md) maps how the skill loads into the runtime environment, but both defer to [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) for the behavioral contract that Rule 1 establishes.

## Practical Examples of the Rule in Action

### Correct Application (Express Route Example)

When querying how to add a new Express route, a Rule 1-compliant response begins with the file creation step, not an explanation of Express architecture:

```markdown
Create a file `src/routes/newRoute.ts` and add the route handler.

```js
// src/routes/newRoute.ts
import { Router } from 'express';
const router = Router();
router.get('/new', (req, res) => res.send('New route!'));
export default router;

```

Next, register the route in `src/app.ts` with `app.use('/new', newRoute);`.

```

Notice the immediate imperative: "Create a file." This satisfies the architectural requirement that the first line must be executable.

### Correct Application (Database Migration Example)

For schema updates, Rule 1 requires leading with the specific SQL action before listing the procedural steps:

```markdown
Add a new column `age` to the `users` table.

1. Create migration file `migrations/2024_add_age_to_users.sql`.
2. Write `ALTER TABLE users ADD COLUMN age INTEGER;`.
3. Run the migration with `npm run migrate`.
4. Verify the column exists: `SELECT age FROM users LIMIT 1;`.
5. Update the ORM model to include `age`.

```

Here, the first line provides the immediate action (adding the column), while the numbered list provides the subsequent workflow. This hybrid approach maintains the architectural priority of actionability while accommodating multi-step processes.

## Why This Rule Anchors the Entire Architecture

Rule 1 functions as the **prerequisite foundation** for the skill's remaining rules, which include numbered steps, time estimates, state restatement, and chunking. Without the leading action:

- **Numbered steps** lack context for what the user should do first.
- **Time estimates** become abstract without a concrete task to measure.
- **State restatement** serves no purpose if no action has been initiated.

As implemented in `ayghri/i-have-adhd`, the skill cannot fulfill its primary purpose—enabling readers with ADHD to act immediately without parsing through contextual preamble. The architectural integrity collapses if the response begins with "First, let me explain..." instead of "Create the file..."

## Summary

- **Rule 1 – "Lead with the next action"** is the architecturally most important rule in the i-have-adhd skill, defined in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md).
- It requires every response to begin with an immediate, executable instruction rather than context or planning.
- All other skill rules (numbered steps, time boxing, state management) depend on this foundational behavior.
- The rule is mirrored in [`.cursor/skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/.cursor/skills/i-have-adhd/SKILL.md) for IDE compatibility.
- Violating Rule 1 breaks the skill's core promise of reducing cognitive load for ADHD users.

## Frequently Asked Questions

### What is the primary rule defined in skills/i-have-adhd/SKILL.md?

The primary rule is **Rule 1 – "Lead with the next action,"** located at lines 33-36 of [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md). It mandates that the first line of every response must be a concrete action the reader can execute immediately, prohibiting contextual preamble or high-level planning statements.

### Where is the i-have-adhd skill configuration stored?

The canonical configuration resides in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) at the repository root. A Cursor-specific implementation exists at [`.cursor/skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/.cursor/skills/i-have-adhd/SKILL.md). The [`AGENTS.md`](https://github.com/ayghri/i-have-adhd/blob/main/AGENTS.md) file maps how these configurations load into the runtime environment, while [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md) documents the skill's invocation syntax.

### How does Rule 1 differ from traditional technical documentation?

Traditional documentation typically begins with conceptual explanations, prerequisites, or architectural overviews. Rule 1 inverts this pattern by requiring the **executable instruction to precede all context**. If explanation is necessary, it must follow the action step, not introduce it.

### What happens if a response doesn't follow Rule 1?

According to the skill's architectural design in `ayghri/i-have-adhd`, omitting the leading action violates the fundamental contract of the skill. Such responses fail to meet the ADHD-specific usability requirements, increasing cognitive load by forcing the reader to parse through non-actionable text before identifying what to do next.