Why Rule 5 (Restate State Every Turn) Is Essential for ADHD‑Friendly AI Interactions

Rule 5 requires AI assistants to restate the current progress on every turn (e.g., "Step 3 of 5 done...") to accommodate limited working memory, provide concrete incremental feedback, and prevent task‑switching confusion in users with ADHD.

The ayghri/i-have-adhd repository defines a rigorously engineered interaction framework designed specifically for users with attention differences. Within this ten‑rule specification, Rule 5 (Restate State Every Turn) serves as a critical accessibility feature that transforms abstract conversational flows into manageable, stateful transactions. By mandating that the assistant restate the current position in any multi‑step process at the start of every response, the rule eliminates the cognitive overhead of mental bookkeeping.

How Rule 5 Addresses Core ADHD Cognitive Traits

According to the skill definition in skills/i-have-adhd/SKILL.md (lines 73‑79), Rule 5 targets three specific neurological characteristics common in ADHD. The implementation ensures that no user must infer previous context from scrollback history.

Limited Working Memory

Information that disappears from the screen is rapidly lost for readers with ADHD. By forcing the assistant to display the current step number and recent accomplishments explicitly, Rule 5 keeps essential context persistently visible. The user never needs to hold the sequence state in memory because each message refreshes it automatically.

Need for Concrete, Incremental Feedback

Abstract progress feels invisible. Rule 5 mandates "step X of Y" phrasing to generate visible checkpoints, converting invisible workflows into tangible milestones. This explicit计量 triggers dopaminergic reward responses and sustains motivation through long procedural tasks.

Difficulty Maintaining Linear Mental Models

Task‑switching and multitasking fracture the mental narrative of a process. Restating state every turn creates a single‑source‑of‑truth that the user can re‑read instantly upon returning to the conversation. This eliminates the "lost in the middle" problem that typically stalls ADHD users when they context‑switch between applications or interruptions.

Implementation Examples in the I‑Have‑ADHD Skill

The SKILL.md documentation provides concrete linguistic patterns for Rule 5 compliance. Violations occur when the assistant assumes the user remembers previous steps; compliance requires self‑contained status declarations.

Non‑compliant pattern (mental state required):

Done. Ready for the next part?

Rule 5‑compliant pattern (state explicitly restated):

Step 3 of 5 done: schema updated. Next: backfill the new column. Run the script?

When building custom assistants, you can enforce this pattern programmatically using a helper function that formats status lines consistently:

def progress_message(step, total, description, next_action):
    """Generate a Rule 5‑compliant status line."""
    return f"Step {step} of {total} done: {description}. Next: {next_action}?"
    

# Example usage

msg = progress_message(
    step=2,
    total=4,
    description="added authentication middleware",
    next_action="run `npm test`"
)
print(msg)   # → Step 2 of 4 done: added authentication middleware. Next: run `npm test`?

This implementation guarantees that every conversational turn is self‑contained, enabling the "scan‑and‑act" behavior pattern documented in the repository’s design principles.

Source Code Architecture and Enforcement

The i-have-adhd skill enforces Rule 5 across multiple architectural layers to ensure runtime compliance:

• skills/i-have-adhd/SKILL.md – Contains the canonical rule definition (lines 73‑79) specifying that the assistant must restate progress on each turn.
• hooks/always-on.mjs – The runtime hook that injects the skill into conversational agents, guaranteeing Rule 5 is active for every turn regardless of the underlying model.
• tests/test_opencode_plugin.py – Unit tests that verify the skill’s behavior programmatically, asserting that responses contain state restatement markers during automated validation.
• AGENTS.md – Documents the architectural placement of the skill within the repository, enabling developers to trace how the rule propagates through the agent execution pipeline.
• README.md – Provides high‑level before/after illustrations demonstrating Rule 5’s impact on user experience.

Together, these files define, document, and enforce Rule 5, making the assistant’s output reliably accessible to working‑memory‑limited users.

Summary

• Rule 5 (Restate State Every Turn) requires the assistant to display the current step and progress count at the beginning of every response.
• The rule compensates for ADHD‑related limited working memory by keeping critical context visible rather than requiring mental retention.
• It transforms abstract workflows into concrete milestones (step X of Y), satisfying the neurological need for incremental feedback.
• The skills/i-have-adhd/SKILL.md specification (lines 73‑79) and the hooks/always-on.mjs runtime hook work together to enforce this at the architectural level.
• Implementing Rule 5 programmatically involves formatting functions that prepend state information to every message, ensuring self‑contained conversational turns.

Frequently Asked Questions

What exactly does Rule 5 require?

Rule 5 mandates that the assistant must restate the current progress on each turn, typically using "step X of Y" phrasing that explicitly describes what has just been accomplished and what comes next. According to skills/i-have-adhd/SKILL.md lines 73‑79, this prevents the user from having to infer previous context from earlier messages.

How does restating state help with working memory limitations?

Users with ADHD often experience rapid decay of information that is not visually present. By restating the state every turn, the assistant keeps the essential context in view without forcing the reader to remember it from previous messages. This externalizes the mental model and reduces cognitive load.

Where is Rule 5 implemented in the codebase?

The rule is defined in skills/i-have-adhd/SKILL.md (lines 73‑79), enforced at runtime by hooks/always-on.mjs, and validated by unit tests in tests/test_opencode_plugin.py. The AGENTS.md file explains how the skill integrates into the broader agent architecture to ensure consistent application across all conversational turns.

Can I implement Rule 5 in my own AI assistant?

Yes. You can implement Rule 5 by adding a formatting layer—such as the progress_message() function shown above—that prepends step counts and status descriptions to every assistant response. The key is ensuring that every turn is self‑contained, meaning a user could drop into the conversation at any point and understand exactly where they are in the process without reading previous messages.

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