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

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 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 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:

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 lines 75-81.

Files That Define and Enforce the Rule

File	Purpose
skills/i-have-adhd/SKILL.md (lines 75-81)	Defines the "restate state every turn" rule, explains cognitive rationale, and provides examples
README.md (line 90)	Summarizes the rule among 10 total rules for quick developer reference
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 lines 75-81 and enforced session-wide via 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 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 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 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}