# Why i-have-adhd Restates the Current State on Every Turn

> Understand why i-have-adhd restates the current state on every turn. This feature compensates for limited working memory by reminding users of completed steps and what's next.

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

---

**The "restate state every turn" rule in i-have-adhd compensates for limited working memory by explicitly reminding users which step was just completed and what comes next.**

The **i-have-adhd** skill is an open-source tool designed to make AI assistants more accessible to users with ADHD. Unlike typical conversational AI output, this system enforces a strict formatting discipline that prioritizes cognitive accessibility over brevity. The restatement rule sits at the heart of this approach, transforming how multi-step workflows are communicated.

## Cognitive Science Behind the Restate State Rule

The rule appears in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) lines 75-81, where it is explicitly defined as mandatory behavior. According to the source code in `ayghri/i-have-adhd`, the pattern serves three interconnected purposes for readers with ADHD:

### Cognitive Grounding

ADHD often impairs the ability to retain information that isn't visually present. By restating the current state, each response anchors the user's mental model to concrete progress shown on screen. This eliminates the burden of remembering where they are in a sequence.

### Progress Visibility

Every turn becomes a **self-contained snapshot**. The format—"Step X of Y done: [description]. Next: [action]"—makes incremental wins immediately obvious. This structure provides natural dopamine feedback that sustains engagement through longer tasks.

### Session-Wide Reliability

Because the rule is enforced *persistently* for the entire session (see [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) line 19), the assistant never drops this reminder. Topic changes, interruptions, or context switches do not break the pattern.

## Implementation: How the Rule Works in Practice

The following Python implementation mirrors the enforcement logic described in the repository's documentation:

```python
def format_response(step_idx, total_steps, description, next_action):
    """
    Formats a response according to the i-have-adhd skill.
    Enforces restate state every turn (rule #5).
    """
    # 1️⃣ Restate state explicitly

    header = f"Step {step_idx} of {total_steps} done: {description}."
    
    # 2️⃣ Provide concrete next action (rule #1)

    body = f"Next: {next_action}"
    
    return f"{header}\n{body}"

```

A real output following this pattern:

```

Step 3 of 5 done: schema updated.
Next: run the back-fill script (`python backfill.py`).

```

This matches the exact wording mandated in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) lines 75-81.

## Files That Define and Enforce the Rule

| File | Purpose |
|------|---------|
| [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) (lines 75-81) | Defines the "restate state every turn" rule, explains cognitive rationale, and provides examples |
| [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md) (line 90) | Summarizes the rule among 10 total rules for quick developer reference |
| [`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json) | Registers the skill with Codex/Claude agents to enforce the rule at runtime |

These three files work together: documentation explains *why*, the README provides *reference*, and the plugin configuration ensures *enforcement*.

## Why This Matters for ADHD Accessibility

Typical AI assistants optimize for token efficiency and conversational flow. For users with ADHD, this creates friction: they must mentally track progress across disconnected responses. The restate state every turn rule inverts this priority—sacrificing concision for clarity.

The format also reduces **cognitive load** in two specific ways:

- **No memory dependency:** Users never need to recall prior messages to understand their current position
- **Reduced decision fatigue:** The "Next:" line removes ambiguity about what action to take

## Summary

- The **restate state every turn** rule is defined in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) lines 75-81 and enforced session-wide via [`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json)
- It compensates for ADHD-related working memory limitations by making every response self-contained
- The pattern follows: "Step X of Y done: [description]. Next: [action]"
- Implementation requires persistent enforcement, not one-time application
- The rule prioritizes cognitive accessibility over output brevity

## Frequently Asked Questions

### What file contains the official definition of the restate state rule?

The rule is 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 75-81. This file explains the cognitive rationale, provides formatting examples, and establishes the rule as mandatory for all responses.

### Does the restate state rule apply to single-turn interactions?

No. The rule specifically targets multi-step workflows where context could be lost between messages. For single-turn interactions, the standard formatting still applies but the step counter remains at "1 of 1."

### How does i-have-adhd enforce this rule across different AI platforms?

The [`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json) file registers the skill with Codex and Claude agent systems. This registration ensures the behavior is enforced at runtime regardless of which underlying model generates the response.

### Can developers customize the restate state format?

The source code suggests the format is strict. [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) line 19 indicates persistent enforcement "for the whole session," implying the pattern is not user-configurable without forking the repository and modifying the skill definition directly.