# How the i-have-adhd Skill Handles Repeated 'Still Broken' User Feedback

> Learn how the i-have-adhd skill avoids debug spirals by pivoting to diagnostic questions after three 'still broken' reports, improving user experience.

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

---

**The i-have-adhd skill prevents debug spirals by stopping iteration after three consecutive "still broken" reports and pivoting to a diagnostic question about underlying assumptions.**

The `i-have-adhd` skill is an open-source framework designed to help AI coding assistants work effectively with users who have ADHD. When debugging sessions stall, the skill specifically handles repeated "still broken" user feedback by breaking unproductive iteration loops that can lead to frustration and cognitive overload.

## The Three-Strike Rule in SKILL.md

According to the source code in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) at line 123, the skill implements a strict counter that tracks consecutive "still broken" responses. When a user reports that a fix remains broken three times in a row, the skill **stops proposing new code changes** and instead **identifies potentially incorrect assumptions** underlying the current approach.

This rule is duplicated in the Cursor-compatible version at [`.cursor/skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/.cursor/skills/i-have-adhd/SKILL.md) to ensure consistent behavior across different AI coding environments.

## Implementation Logic and State Management

The skill maintains a counter that increments each time the user feedback matches the "still broken" pattern. When the threshold is reached, the logic shifts from iterative fixing to diagnostic inquiry.

The following pseudocode illustrates this guard mechanism:

```javascript
// Pseudocode illustrating the "still broken" guard
let brokenCount = 0;

function handleUserFeedback(feedback) {
  if (/still\s+broken/i.test(feedback)) {
    brokenCount++;
    if (brokenCount >= 3) {
      // Stop the normal iterative fix loop
      const assumption = guessWrongAssumption();
      return `It looks like the assumption "${assumption}" might be wrong. ` +
             `Can you confirm or provide more detail?`;
    }
  } else {
    brokenCount = 0; // reset when user reports success or a new issue
  }

  // Normal handling – propose next action, run tests, etc.
  return proposeNextAction();
}

```

The counter **resets to zero** immediately when the user reports success or describes a different issue, ensuring the guard only triggers during genuine stuck states.

## Real-World Interaction Flow

Consider a typical debugging session where an authentication test keeps failing:

```

User: The test still fails.
Assistant: Run `npm test` again…
User: Still broken.
Assistant: Check the auth header…
User: Still broken.
Assistant: Still broken.
Assistant: I've tried three times and the same error persists.
           It may be that the token is not being sent at all. 
           Could you verify that the Authorization header is present in the request?

```

At the third "still broken" signal, the skill pivots from suggesting additional code fixes to asking the user to verify whether the Authorization header is actually present in the request—a fundamental assumption that might have been overlooked.

## Summary

- The **"still broken" guard** triggers after three consecutive failure reports, as defined in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) at line 123.
- The skill **breaks the iteration loop** and asks a single diagnostic question rather than proposing more fixes.
- A **counter reset mechanism** clears the state when users report success or new issues.
- The same logic exists in both the main skill file and the [`.cursor/skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/.cursor/skills/i-have-adhd/SKILL.md) copy for cross-platform consistency.

## Frequently Asked Questions

### What exactly triggers the "still broken" handler in the i-have-adhd skill?

The handler activates when a user sends feedback matching the pattern "still broken" three consecutive times during a debugging session. This detection uses case-insensitive regex matching (`/still\s+broken/i`) to catch variations in user phrasing.

### Where is the repeated feedback logic defined in the codebase?

The canonical definition resides in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) at line 123, with a synchronized copy available at [`.cursor/skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/.cursor/skills/i-have-adhd/SKILL.md) for Cursor IDE compatibility. Both files contain identical rules governing the three-strike threshold.

### How does the skill know when to reset the broken counter?

The counter resets to zero whenever the user provides feedback that does not match the "still broken" pattern, such as reporting success, describing a new error, or asking unrelated questions. This prevents false positives from accumulating across separate debugging attempts.

### Can developers configure the threshold for how many "still broken" reports trigger the diagnostic pivot?

Based on the current implementation in the SKILL.md files, the threshold is hardcoded at three consecutive reports. The pseudocode shows `if (brokenCount >= 3)` as the fixed trigger point, with no configuration parameters exposed for adjusting this limit in the current version.