# How the i-have-adhd Skill Restates State Across Turns Without Causing User Fatigue

> Learn how the i-have-adhd skill avoids user fatigue by restating state across turns. Discover its efficient prompt injection technique for clear progress tracking and reduced cognitive load.

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

---

**The skill uses an always-on hook to inject a "Restate state every turn" rule into the system prompt on every turn, ensuring the model explicitly tracks progress while forbidding verbose pleasantries to minimize cognitive load.**

The `ayghri/i-have-adhd` repository provides a conversational AI skill designed specifically for ADHD users who struggle to retain context between messages. By forcing the model to explicitly restate the current step on every response, the skill eliminates the need for users to remember "we are on step 3 of 5" between turns. This article explains how the skill implements persistent state restatement across turns without generating the repetitive chatter that typically causes user fatigue.

## The "Restate State Every Turn" Rule in SKILL.md

Inside [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) at lines 73-80, **Rule 5** explicitly mandates that the model must restate state every turn. This directive acknowledges that ADHD readers cannot retain step progress between messages, requiring the model to repeat the current position in the workflow each time it generates output.

The rule requires outputs to include a concise progress indicator such as **"Step 3 of 5 done: … Next: …"** This explicit anchoring prevents users from losing track of where they are in multi-step tasks without having to scroll back through conversation history.

## System Prompt Injection via the Always-On Hook

To ensure the model actually follows this rule on every response, the harness implements an always-on hook that injects the entire ruleset into the system prompt at the start of each turn. In `.opencode/plugins/i-have-adhd.mjs` at lines 55-70, the hook reads the [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) file, strips its YAML front-matter, and appends the remaining rules to the system prompt.

The hook only activates when the opt-in flag file exists at `~/.config/opencode/.i-have-adhd-always`. When present, the logic executes on every turn:

```javascript
const body = fs.readFileSync(skillPath, "utf8")
               .replace(/^---[^\S\r\n]*\r?\n[\s\S]*?\r?\n---[^\S\r\n]*/, "")
               .trim();
output.system.push(
  `ADHD MODE ACTIVE (always‑on)…\n\n${body}`
);

```

Because the ruleset persists in the system prompt context, the language model receives the "Restate state every turn" instruction each time it generates output. This removes the burden from the model's parametric memory and guarantees consistent state tracking regardless of conversation length. An equivalent always-on hook for non-OpenCode environments is implemented in `hooks/always-on.mjs`.

## Preventing Fatigue by Eliminating Verbose Preambles

User fatigue is avoided through **Rule 10** in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md), which explicitly forbids preambles, closing pleasantries, or repetitive chatter. The skill outputs only the essential state recap and the next concrete action, keeping responses terse and focused.

The always-on hook adds only a concise reminder header plus the rule body to the system prompt, never exposing the full ruleset to the user. The model sees the instructions internally but generates only the brief progress indicator required by Rule 5, ensuring the conversation remains fatigue-free while maintaining contextual continuity.

## Enabling the Skill and Verifying Behavior

To activate the always-on mode that restates state across turns, create the opt-in flag file:

```bash
touch ~/.config/opencode/.i-have-adhd-always

```

Alternatively, invoke the skill explicitly for a single session:

```bash
/i-have-adhd

```

When active, the model produces output structured like this:

```

Step 2 of 4 done: schema updated.
Next: back‑fill the new column. Run the migration script?

```

This format provides immediate orientation without cognitive overhead, allowing ADHD users to resume work instantly regardless of when they last interacted with the conversation.

## Summary

- The skill defines a mandatory "Restate state every turn" rule in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) (lines 73-80) to accommodate working memory limitations.
- An always-on hook in `.opencode/plugins/i-have-adhd.mjs` (lines 55-70) injects these rules into the system prompt on every turn by reading and stripping the YAML front-matter from [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md).
- Fatigue prevention relies on Rule 10's prohibition of verbose pleasantries, ensuring only concise state recaps and next actions appear in the output.
- Activation requires either touching the flag file at `~/.config/opencode/.i-have-adhd-always` or invoking `/i-have-adhd` explicitly.

## Frequently Asked Questions

### How does the skill prevent the model from forgetting the current step?

The model never needs to remember the step because the always-on hook in `.opencode/plugins/i-have-adhd.mjs` injects the "Restate state every turn" rule into the system prompt on every API call. This persistent instruction ensures the model explicitly tracks and reports progress regardless of conversation length or context window limitations.

### Why doesn't repeating the state every turn cause user fatigue?

Fatigue is avoided through strict output constraints defined in Rule 10 of [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md), which bans preambles, closing pleasantries, and redundant explanations. The model outputs only a brief progress indicator (e.g., "Step 3 of 5 done") followed immediately by the next actionable item, eliminating the repetitive chatter that typically exhausts ADHD users.

### Where is the always-on logic implemented for non-OpenCode environments?

For runtimes outside of OpenCode, the equivalent always-on hook resides in `hooks/always-on.mjs`. This file mirrors the functionality found in `.opencode/plugins/i-have-adhd.mjs`, ensuring the skill can inject state-restating rules into system prompts across different AI coding platforms.

### Can I use this skill without enabling always-on mode?

Yes. While the always-on mode provides persistent state restatement across every turn via the flag file at `~/.config/opencode/.i-have-adhd-always`, you can invoke the skill for a single session by typing `/i-have-adhd`. This applies the ruleset to the immediate context without creating the permanent opt-in flag.