# How i‑have‑adhd Handles Multi‑Step Tasks in AI Responses

> Discover how i-have-adhd manages multi-step tasks in AI responses by using numbered lists and tracking progress. Enhance your workflow and reduce cognitive load.

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

---

**The i‑have‑adhd skill structures every multi‑step task as a numbered list of atomic actions and restates the user's current progress after each turn, eliminating the need for working memory.**

The `ayghri/i-have-adhd` repository provides a behavioral framework that reshapes how AI assistants present complex instructions to users with ADHD. Unlike standard AI outputs that may bury steps inside dense paragraphs, this system enforces a strict protocol for breaking down multi‑step tasks into immediately actionable units. According to the source code, the implementation relies on two complementary mechanisms defined in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) that ensure users always know exactly what to do next without remembering previous context.

## The Two‑Part Workflow for Multi‑Step Tasks

When an AI assistant equipped with the i‑have‑adhd skill encounters a multi‑step request, it follows a mandatory two‑part workflow designed to minimize cognitive load and decision paralysis.

### Numbered Task Lists (Rule 2)

The skill mandates that every multi‑step response begin with a **numbered task list** where each item represents a single, bounded action. Rule 2 in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) enforces that steps must be atomic—containing no more than one "and then"—and completable in under two minutes. This transforms abstract goals into concrete, sequential commands.

A typical output follows this pattern:

```markdown
1. Open `src/auth.ts`
2. Replace `verifyToken` (lines 42‑58) with the snippet below
3. Run `npm test -- auth.spec.ts`

```

By prefixing each action with a numeric label, the skill creates a visual anchor that prevents the user from losing their place within the sequence.

### State Restatement (Rule 5)

After each turn or completion event, the assistant must emit a **state restatement** that explicitly announces the current position in the workflow. Rule 5 requires the AI to repeat the progress status (e.g., "Step 2 of 3 done") so the reader does not have to retain the plan in working memory.

Example response format:

```markdown
Step 2 of 3 done: `verifyToken` replaced. Next: run the tests. Run `npm test -- auth.spec.ts`.

```

This continuous restatement acts as a persistent breadcrumb trail, allowing the user to resume immediately even if they become distracted between interactions.

## Integration with External Task Tools

When the host harness provides a `task` or `plan` tool, the skill delegates checklist handling to that external system while maintaining its core constraints. As implemented at line 80 of [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md), the skill ensures that only one item remains "in‑progress" at a time while the tool automatically manages the "Step X of Y" state injection.

Harness integration example:

```typescript
// The harness calls the i-have-adhd skill with a task list
await harness.task([
  "Open src/auth.ts",
  "Replace verifyToken (lines 42‑58)",
  "Run npm test -- auth.spec.ts"
]);

// The skill ensures the checklist is presented one item at a time
// and automatically injects "Step X of Y" after each turn.

```

If no external tool is available, the assistant falls back to manual generation of both the numbered list and the state restatement line on every turn.

## Core Implementation Files

The multi‑step task handling logic is distributed across several key files in the repository:

- **[`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md)** — Contains the core rule set, including Rule 2 (numbered tasks) and Rule 5 (state restatement), plus the task tool delegation logic at line 80.
- **[`gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/gemini.toml)** — Example harness configuration referencing the multi‑step workflow rules for the Gemini agent implementation.
- **[`.opencode/command/i-have-adhd.md`](https://github.com/ayghri/i-have-adhd/blob/main/.opencode/command/i-have-adhd.md)** — High‑level description of persistent skill behavior and command invocation patterns.
- **[`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md)** and **[`INSTALL.md`](https://github.com/ayghri/i-have-adhd/blob/main/INSTALL.md)** — User‑facing documentation that reiterates the multi‑step handling guidelines for developers implementing the skill.

## Summary

- **Atomic numbering**: Every multi‑step task becomes a numbered list where each item contains exactly one actionable command.
- **Continuous progress tracking**: The AI restates "Step X of Y" after every completion, eliminating the need for users to remember their position.
- **Tool delegation**: When available, the skill offloads checklist management to external `task` tools while enforcing single‑item focus.
- **Two‑minute rule**: Each step must be completable within 120 seconds to prevent overwhelm and maintain momentum.
- **Source authority**: All rules are formally defined in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) and referenced by harness configurations like [`gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/gemini.toml).

## Frequently Asked Questions

### What is the i‑have‑adhd skill?

The i‑have‑adhd skill is a behavioral specification for AI assistants that modifies output formatting to accommodate cognitive patterns common in ADHD. It enforces strict rules about how multi‑step instructions are structured, ensuring that responses prioritize clarity, immediacy, and minimal working memory load over conversational verbosity.

### How does the skill prevent cognitive overload during complex tasks?

The skill prevents overload by enforcing **atomicity** and **state visibility**. By breaking work into numbered steps that take under two minutes each (Rule 2) and explicitly restating the current progress after every action (Rule 5), the system ensures users never face ambiguity about what to do next or how much remains. This removes the executive function burden of planning and tracking from the user.

### Can the i‑have‑adhd skill function without external task tools?

Yes. When no `task` or `plan` tool is available in the host harness, the skill operates in standalone mode. The assistant manually generates the numbered task list and appends the "Step X of Y" restatement to every response. The delegation logic at line 80 of [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) only activates when an external tool is explicitly detected.

### Where are the specific rules for multi‑step task formatting defined?

The authoritative rules are defined in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) within the repository's `skills/i-have-adhd/` directory. Rule 2 governs the numbered list format, while Rule 5 mandates state restatement. Implementation examples appear in [`gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/gemini.toml), and user documentation in [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md) and [`INSTALL.md`](https://github.com/ayghri/i-have-adhd/blob/main/INSTALL.md) provides additional context for adoption.