# How Rule 6: Give Specific Time Estimates Transforms Task Perception for ADHD Workflows

> Discover how Rule 6, giving specific time estimates, transforms task perception for ADHD workflows. Make tasks tangible and boost initiation rates.

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

---

**Providing concrete minute-based estimates instead of vague durations converts abstract tasks into tangible, time-boxed activities that reduce cognitive load and increase task initiation rates for users with ADHD.**

The `i-have-adhd` repository offers a specialized skill framework that optimizes AI-assisted task management for neurodivergent users. Rule 6—*“Give specific time estimates (minutes, not ‘a bit’)”*—defined in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), fundamentally alters how workloads are perceived by replacing ambiguous language with quantifiable boundaries.

## Why Specific Time Estimates Reshape Task Perception

### Eliminating Ambiguity in Workload Assessment

Vague phrases like *“a bit of work”* or *“soon”* lack concrete boundaries, forcing the brain to interpret undefined effort levels. According to lines 84-90 in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), specifying exact minutes—such as *“about 15 minutes”*—provides a clear mental cue that quantifies the workload objectively. This precision prevents the ADHD brain from catastrophizing task difficulty or underestimating required effort.

### Triggering Dopamine Through Achievable Wins

Short, visible timeframes create dopamine-driven motivation loops. When an estimate reads *“5 minutes to rename the variable”*, the task shifts from overwhelming to immediately achievable. The i-have-adhd skill documentation emphasizes that concrete estimates let the reader see “this will finish quickly,” generating the neurological reward necessary to sustain focus.

### Reducing Startup Friction

The hardest part of task execution is often the initial decision to begin. Specific estimates remove the mental calculation of *“how long will this take?”*—a common sticking point that delays action. By stating *“About 5 minutes”* upfront, the assistant eliminates hesitation and enables immediate execution without additional planning overhead.

### Enabling Precise Calendar Integration

Concrete timing allows users to slot tasks into calendars and to-do lists without over-committing. The rule forces decomposition into bounded, timed steps that fit realistically between existing commitments, preventing the planning errors that lead to executive function overload.

## Technical Implementation in the Source Code

The rule is enforced through multiple layers in the repository. The definition resides in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), while runtime validation occurs in [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts). Persistent activation is maintained via [`hooks/always-on.sh`](https://github.com/ayghri/i-have-adhd/blob/main/hooks/always-on.sh), ensuring Rule 6 compliance across all interactions regardless of context switching.

Example response structure following Rule 6:

```yaml

# Example of a skill response that follows Rule 6

response: |
  1. Open `src/auth.ts`                     # 2 min

  2. Replace the `verifyToken` function      # 5 min

  3. Run `npm test -- auth.spec.ts`          # 3 min

  Next: run the test suite and paste any failing line.  # 2 min

```

For developers building similar tooling, the repository includes a Python helper that demonstrates automated time estimation:

```python

# Helper function you could embed in a plugin to auto-generate time estimates

def estimate_time(steps):
    """Return a list of (step, minutes) pairs."""
    base = 2  # default minutes per simple step

    return [(s, base + len(s) // 30) for s in steps]

steps = [
    "Open src/auth.ts",
    "Replace verifyToken function",
    "Run npm test",
]
for step, minutes in estimate_time(steps):
    print(f"{step:<40} # {minutes} min")

```

## Integration with Rule 1 and Hand-off Workflows

Rule 6 operates synergistically with **Rule 1: Lead with the next action**. When combined, the user receives both the *what* and the *how long*, creating a complete psychological contract for the task. This pairing is particularly effective in hand-off scenarios—when the assistant returns control to the user, the time-boxed next action eliminates ambiguity about immediate priorities.

The evaluation suite in [`scripts/run_evals.py`](https://github.com/ayghri/i-have-adhd/blob/main/scripts/run_evals.py) validates this integration, ensuring that responses containing next actions also include specific minute estimates, as documented in the [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md) overview of the 10 rules.

## Summary

- **Concrete minutes replace ambiguity**: Rule 6 mandates specific time units instead of vague phrases like "a bit" or "soon".
- **Defined in SKILL.md**: The rule specification lives at lines 84-90 in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md).
- **Runtime enforcement**: Logic in [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts) validates compliance during assistant operations.
- **Evaluated automatically**: [`scripts/run_evals.py`](https://github.com/ayghri/i-have-adhd/blob/main/scripts/run_evals.py) tests ensure estimates accompany task recommendations.
- **Pairs with Rule 1**: Specific time estimates combine with clear next actions to create actionable, time-boxed workflows that reduce ADHD paralysis.

## Frequently Asked Questions

### What exactly does Rule 6 require in the i-have-adhd skill?

Rule 6 requires that every task or step be annotated with a specific time estimate in minutes (e.g., "About 5 minutes") rather than using vague temporal language. This requirement is codified in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) and enforced by the runtime logic in [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts), ensuring users always receive concrete temporal boundaries for their work.

### How do specific time estimates help with ADHD task initiation?

Specific estimates reduce the cognitive load required to start a task by removing the need to mentally calculate duration. As implemented in the i-have-adhd framework, seeing "2 minutes" triggers a dopamine response that makes the task feel achievable, bypassing the executive function barriers that typically delay task startup and creating immediate psychological momentum.

### Where is Rule 6 validated in the codebase?

Compliance testing occurs in [`scripts/run_evals.py`](https://github.com/ayghri/i-have-adhd/blob/main/scripts/run_evals.py), which runs evaluation tests to verify that assistant responses include specific minute estimates. Additionally, [`hooks/always-on.sh`](https://github.com/ayghri/i-have-adhd/blob/main/hooks/always-on.sh) ensures the skill remains active so Rule 6 is consistently applied across all user interactions, preventing regression in output formatting.

### Can I automate time estimation in my own development tools?

Yes. The repository provides a reference implementation in Python that calculates time based on step complexity. You can embed similar logic into your IDE plugins or CLI tools to automatically append time estimates to code review checklists or task breakdowns, following the pattern validated by the evaluation suite.