What Does "Restate State Every Turn" Mean in the i‑have‑adhd Skill?

"Restate state every turn" means the assistant must begin or end every response with a concise recap of what has been completed, what remains pending, and the current context to reduce cognitive load for users with ADHD.

The ayghri/i‑have‑adhd repository provides a conversational framework designed specifically to support readers with ADHD through structured, predictable interactions. The "restate state every turn" rule is a core directive that ensures continuity across multi-turn conversations by explicitly surfacing session progress at every step.

What "Restate State Every Turn" Means in Practice

In practical implementation, restate state every turn requires the assistant to generate a brief status summary as part of every response. This summary must outline three critical elements:

• Completed work: Explicit acknowledgment of finished tasks or "wins"
• Pending actions: Clear identification of the immediate next step
• Current context: Any relevant variables, user preferences, or intermediate results that must carry forward

According to the canonical skill definition in skills/i‑have‑adhd/SKILL.md, the directive appears within a broader set of ADHD‑friendly output rules:

"Shape output for a reader with ADHD: lead with the next action, number multi‑step work, restate state across turns, suppress tangents, give specific time estimates, make wins visible…"

The same requirement is reiterated in GEMINI.md for the Gemini runtime:

"Shape every response for a reader with ADHD. Follow the rules … restate state across turns …"

Why This Rule Matters for ADHD‑Friendly Interfaces

The rule addresses specific cognitive accessibility needs by providing memory refresh and progress visibility:

• Reduces cognitive load: Users do not need to maintain a mental model of the entire conversation history. The assistant tracks and surfaces state variables automatically.
• Prevents disorientation: By restating what was just accomplished and what comes next, the user remains anchored in the workflow without retracing previous messages.
• Maintains continuity: The assistant prevents "state loss" by explicitly carrying forward important context (e.g., partial calculations, selected preferences, or incomplete forms) across turns.

Without this rule, users with ADHD may lose track of multi‑step processes, requiring them to scroll back through chat history to reconstruct context—a significant barrier to task completion.

Implementation in the Source Code

The repository enforces this pattern through documentation and skill definitions rather than hardcoded enforcement, leaving implementation to runtime adapters.

Key implementation locations include:

• skills/i‑have‑adhd/SKILL.md: The canonical definition requiring state restatement across turns alongside other formatting rules.
• GEMINI.md: Gemini‑specific runtime instructions that replicate the SKILL.md directive for Google's AI platform.
• .opencode/command/i‑have‑adhd.md: OpenCode command documentation listing the rule among ADHD‑friendly output requirements.
• .cursor/skills/i‑have‑adhd/SKILL.md: Mirror of the canonical skill definition for the Cursor IDE runtime.

Any adapter implementing this skill—whether for OpenCode, Gemini, Claude, or custom agents—must embed a state‑summary block within the response generation pipeline.

Practical Code Implementation

Below is a minimal JavaScript implementation demonstrating how to honor the "restate state every turn" rule. The pattern maintains a mutable session state object and prepends a formatted summary to each assistant response.

// Session state tracker
let sessionState = {
  stepsCompleted: [],   // e.g., ["downloaded data"]
  stepsPending:   [],   // e.g., ["process data", "generate report"]
  lastAction:    null,  // description of the most recent action
};

// Helper to render the state summary block
function renderStateSummary(state) {
  const done = state.stepsCompleted.length
    ? `✅ Completed: ${state.stepsCompleted.join(', ')}. `
    : '';
  const pending = state.stepsPending.length
    ? `🔜 Next: ${state.stepsPending[0]}. `
    : '';
  const last = state.lastAction 
    ? `↪️ Last action: ${state.lastAction}. ` 
    : '';
  return `${done}${pending}${last}`.trim();
}

// Main response builder called every turn
function buildResponse(userInput) {
  // Logic determining next action
  const nextAction = 'process data';
  
  // Update state
  sessionState.lastAction = `started "${nextAction}"`;
  sessionState.stepsPending.shift();
  sessionState.stepsCompleted.push(nextAction);
  
  // Assemble response per "restate state every turn" rule
  const stateSummary = renderStateSummary(sessionState);
  const coreMessage = `Processing the data now (≈2 min).`;
  
  // State summary must appear in every response
  return `${stateSummary}\n\n${coreMessage}`;
}

Key implementation details:

• State persistence: The sessionState object persists across function calls, tracking stepsCompleted, stepsPending, and lastAction.
• Mandatory formatting: The renderStateSummary function ensures consistent formatting using visual markers (✅, 🔜, ↪️) to enhance scannability.
• Turn integration: Every invocation of buildResponse prepends stateSummary to the core message, satisfying the requirement that state be restated across turns.

For Python implementations or other runtimes, the pattern remains identical: maintain a context dictionary and prepend a formatted summary to assistant.reply or equivalent output methods.

Summary

• "Restate state every turn" requires every assistant response to include a concise recap of completed work, pending tasks, and current context.
• The rule is canonically defined in skills/i‑have‑adhd/SKILL.md and mirrored in runtime‑specific files like GEMINI.md and .cursor/skills/i‑have‑adhd/SKILL.md.
• Implementation requires maintaining a persistent state object across conversation turns and formatting a summary block that appears in every response.
• This pattern reduces cognitive load for users with ADHD by eliminating the need to manually track conversation history and multi‑step progress.

Frequently Asked Questions

What does "restate state every turn" mean exactly?

It means every response generated by the assistant must explicitly summarize the current situation, including what has been accomplished so far, what remains to be done, and any relevant context from previous turns. This prevents users from losing track of multi‑step workflows.

Where is this rule defined in the repository?

The rule is defined in skills/i‑have‑adhd/SKILL.md as part of the canonical skill description, and replicated in GEMINI.md for Gemini‑specific implementations. You can also find references in .opencode/command/i‑have‑adhd.md and .cursor/skills/i‑have‑adhd/SKILL.md.

How do I implement this in my own AI assistant?

Maintain a session‑level state object tracking completed steps, pending steps, and recent actions. Create a formatter function that generates a concise summary string from this state. Ensure your response builder calls this formatter and prepends the result to every outgoing message, regardless of the specific content of that turn.

Does this apply to all AI runtimes or just specific ones?

While the rule originated in the i‑have‑adhd skill framework, the repository provides configurations for multiple runtimes including OpenCode, Gemini, and Cursor. Any runtime adapter implementing this skill must follow the "restate state every turn" directive to maintain ADHD‑friendly output consistency.

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