# How to Format Time Estimates to Be Compatible With ADHD Cognitive Styles

> Learn how to format time estimates for ADHD by using concrete minute units instead of vague durations. Improve focus and reduce decision fatigue with these practical tips.

- Repository: [Ayoub Ghriss/i-have-adhd](https://github.com/ayghri/i-have-adhd)
- Tags: how-to-guide
- Published: 2026-09-13

---

**The ayghri/i-have-adhd repository formats time estimates as concrete, numeric minute units (e.g., "5 minutes") rather than vague durations, enabling rapid cognitive processing and reducing decision fatigue for users with ADHD.**

The `ayghri/i-have-adhd` project enforces strict formatting guidelines for temporal estimates to accommodate ADHD cognitive styles. Instead of subjective phrases like "a bit of work" or "a few hours," the system requires specific minute-based declarations according to the source code. This approach minimizes ambiguity and supports executive function by allowing users to immediately assess task scope without mental translation.

## The Concrete Minutes 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) (lines 28-84), the specification mandates that responses must **give specific time estimates** and explicitly warns that **vague estimates fail**. The standard unit is always minutes, ensuring that users encounter predictable, quantifiable durations rather than subjective qualifiers.

The rule prohibits language like "a bit" or "a few hours" because such terms require cognitive effort to interpret. By standardizing on minutes, the codebase creates a **uniform temporal language** that appears consistently across all interface touchpoints.

## Repository-Wide Enforcement

The concrete-minutes standard propagates through multiple documentation and implementation files to ensure consistent behavior across runtime adapters including Claude, Gemini, and OpenCode:

- [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md) at line 76 emphasizes the use of **concrete units** and rejects vague phrasing.
- [`INSTALL.md`](https://github.com/ayghri/i-have-adhd/blob/main/INSTALL.md) at line 47 reiterates the rule across installation instructions, insisting on "never 'a bit'" formatting.
- [`.opencode/command/i-have-adhd.md`](https://github.com/ayghri/i-have-adhd/blob/main/.opencode/command/i-have-adhd.md) at line 7 implements the rule in the OpenCode command interface, ensuring adapter compliance.

This cross-file enforcement guarantees that users receive identically formatted time estimates regardless of which component generates the response.

## Why Minutes Reduce Cognitive Load

**Concrete numeric units** bypass the ambiguity tax—the mental energy required to translate subjective terms like "soon" or "a while" into personal time frameworks. When a user encounters "5 minutes," their brain processes the information through direct numerical pathways rather than interpretive reasoning.

For ADHD cognitive styles, this reduction in **interpretive overhead** is critical. Immutable minute values eliminate the working memory load associated with converting vague durations into actionable plans. The format also supports **time blindness** compensation by grounding abstract tasks in measurable units.

## Code Examples for ADHD-Compatible Time Formatting

The following implementations demonstrate how to generate compliant time estimates in various programming languages. Each function returns concrete minute-based output without vague modifiers, following the standards defined in the repository's skill definition.

### Python Implementation

```python
def format_time_estimate(minutes: int) -> str:
    """Return a concrete time estimate in minutes."""
    return f"{minutes} minute{'s' if minutes != 1 else ''}"

def respond_with_estimate(action: str, minutes: int) -> str:
    """
    Build an ADHD‑friendly response that leads with the next action
    and includes a concrete time estimate.
    """
    estimate = format_time_estimate(minutes)
    return f"Next: {action} (≈ {estimate})"
    

# Example usage

print(respond_with_estimate("run the linting script", 3))

# Output: Next: run the linting script (≈ 3 minutes)

```

### JavaScript Implementation

```javascript
function formatTime(minutes) {
  return `${minutes} minute${minutes === 1 ? '' : 's'}`;
}

function response(action, minutes) {
  return `Next: ${action} (≈ ${formatTime(minutes)})`;
}

console.log(response('install dependencies', 4));
// → Next: install dependencies (≈ 4 minutes)

```

### Bash Implementation

```bash
format_time() { 
  echo "${1} minute${1:-1}s"; 
}

respond() {
  local action=$1 minutes=$2
  echo "Next: $action (≈ $(format_time $minutes))"
}

respond "run tests" 5

# → Next: run tests (≈ 5 minutes)

```

These patterns ensure that all generated responses follow the **concrete-minute standard** required by the `i-have-adhd` skill definition.

## Summary

- **Concrete minutes** replace vague duration phrases throughout the `ayghri/i-have-adhd` codebase, specifically mandated in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) (lines 28-84).
- The rule propagates through [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md) (line 76), [`INSTALL.md`](https://github.com/ayghri/i-have-adhd/blob/main/INSTALL.md) (line 47), and [`.opencode/command/i-have-adhd.md`](https://github.com/ayghri/i-have-adhd/blob/main/.opencode/command/i-have-adhd.md) (line 7) to ensure consistent cross-platform behavior.
- Formatting functions must return integer minute values with proper pluralization to maintain cognitive accessibility.
- This formatting eliminates the **ambiguity tax** by removing subjective interpretation from temporal estimates.

## Frequently Asked Questions

### Why does the i-have-adhd repository reject vague time estimates?

Vague phrases like "a bit" or "a few hours" create interpretive ambiguity that increases cognitive load for users with ADHD. The repository mandates concrete minute units to enable immediate, unambiguous decision-making without requiring mental translation of subjective terms into personal time frameworks.

### Which source files define the time estimate formatting rules?

The primary 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 lines 28-84. Supporting documentation in [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md) (line 76) and [`INSTALL.md`](https://github.com/ayghri/i-have-adhd/blob/main/INSTALL.md) (line 47) reinforces the standard, while [`.opencode/command/i-have-adhd.md`](https://github.com/ayghri/i-have-adhd/blob/main/.opencode/command/i-have-adhd.md) (line 7) implements the rule across runtime adapters for Claude, Gemini, and OpenCode.

### What is the standard unit for ADHD-compatible time estimates?

The standard unit is **minutes**, expressed as concrete numeric values (e.g., "5 minutes"). This unit provides sufficient granularity for task planning while remaining intuitively understandable without conversion calculations, directly supporting executive function in ADHD cognitive styles.

### How should I implement time estimate formatting in my own ADHD-friendly applications?

Use integer-based minute calculations with proper pluralization logic, as demonstrated in the Python, JavaScript, and Bash examples above. Avoid floating-point hours or subjective qualifiers. Structure responses to place the time estimate immediately adjacent to the action description to minimize working memory load.