Why Specific Time Estimates Are Crucial for ADHD Developers in Software Projects

Specific time estimates (in exact minutes, not vague phrases like "a bit" or "a few hours") reduce cognitive load, lower transition friction, and trigger dopamine rewards that keep ADHD developers focused and motivated.

The open-source repository ayghri/i-have-adhd codifies this principle as a core architectural rule for AI-assisted development. The skill shapes every assistant response around the cognitive profile of developers with ADHD, with concrete time estimates serving as a foundational design element rather than a stylistic preference.

What Makes Time Estimation Architecture-Level for ADHD

Vague time descriptors create multiple failure points for ADHD cognition. The repository addresses four distinct cognitive challenges through its enforced time-estimate rule.

Limited Working Memory Demands Concrete Units

ADHD readers retain only a few items on screen at once. Phrases like "a bit of work" leave duration undefined, allowing the task to slip out of focus before execution begins. The skill forces concrete units—≈ 15 minutes, ~2 minutes—so developers can quickly gauge effort and keep the step anchored in working memory.

As specified in [SKILL.md ¶ 24-30](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md): "Give specific time estimates" prevents the memory displacement that vague language causes.

Transition Friction Requires Bounded Chunks

The gap between knowing and doing often stalls ADHD developers. A clear time budget signals a bounded, doable chunk, reducing hesitation to start. The rule eliminates the "a few hours" ambiguity that paralyzes the next-action mindset.

According to [SKILL.md ¶ 82-86](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), precise estimates transform overwhelming tasks into immediate entry points.

Dopamine Budgeting Depends on Visible Progress

ADHD brains reward visible, near-term completion. When a task carries an explicit ≈ 15 minutes estimate, the developer anticipates a short dopamine win—making the step feel attainable and motivating execution. This anticipatory reward loop is documented in [SKILL.md ¶ 84-88](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md).

Uniform Perception of Effort Prevents Miscommitment

Without precise numbers, "a bit of work" and "a few hours" are mentally conflated, leading to over- or under-commitment. Concrete minutes standardize the mental scale across the entire session. The [README.md ¶ 75-76](https://github.com/ayghri/i-have-adhd/blob/main/README.md) explicitly calls this out: "Specific time estimates (minutes, not 'a bit')".

How the Repository Enforces the Rule

The i-have-adhd skill treats time estimates as a cross-runtime guarantee, not a suggestion.

Runtime Consistency Across Platforms

The skill's runtime (Claude, Codex, OpenCode, and others) relies on the same rule set to produce predictable outputs. Embedding the time-estimate rule in every manifest ensures that every integration respects the same constraint. The file [.opencode/command/i-have-adhd.md ¶ 7](https://github.com/ayghri/i-have-adhd/blob/main/.opencode/command/i-have-adhd.md) defines this command-line interface, enforcing constraints at runtime.

Test Coverage for Rule Compliance

The test suite in [tests/test_opencode_plugin.py](https://github.com/ayghri/i-have-adhd/blob/main/tests/test_opencode_plugin.py) validates that the plugin respects the time-estimate rule across the OpenCode integration. This prevents regression and maintains user trust.

Practical Examples: Writing ADHD-Compatible Instructions

The repository provides explicit patterns for authoring time-estimated tasks. Each example satisfies the rule from SKILL.md by including concrete minute values.

Dependency Installation

Run `npm install jsonwebtoken@latest` **(~2 minutes)**, then edit `src/auth.ts:42`.

Multi-Step Refactoring

1. Open `src/auth.ts` (**~1 minute**).
2. Replace `verifyToken` (lines 42-58) with the snippet below (**~3 minutes**).
3. Run `npm test -- auth.spec.ts` (**~2 minutes**).

Inline Code Comments

// Action: Insert a console.log at the start of `handleRequest`
// Estimated time: 1 minute
function handleRequest(req) {
  console.log('Request received:', req.path); // <-- ~1 minute
  // …rest of the function
}

Each block follows the repository's structural requirements: starts with the next action, numbers steps when multiple, ends with a single concrete next step, and explicitly states the minutes required.

Key Files That Implement the Architecture

File	Purpose
[skills/i-have-adhd/SKILL.md](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md)	Full rule set including "Give specific time estimates"
[README.md](https://github.com/ayghri/i-have-adhd/blob/main/README.md)	End-user summary emphasizing minutes-based estimates
[INSTALL.md](https://github.com/ayghri/i-have-adhd/blob/main/INSTALL.md)	Models the behavior throughout installation steps
[.opencode/command/i-have-adhd.md](https://github.com/ayghri/i-have-adhd/blob/main/.opencode/command/i-have-adhd.md)	Runtime command definition enforcing constraints
[tests/test_opencode_plugin.py](https://github.com/ayghri/i-have-adhd/blob/main/tests/test_opencode_plugin.py)	Automated validation of time-estimate compliance

Summary

Specific time estimates function as a cognitive anchor for ADHD developers:

• Reduce memory load by keeping task scope within working memory limits
• Sharpen next-action cues through bounded, explicit time budgets
• Trigger dopamine rewards via anticipated near-term completion
• Ensure cross-platform consistency through manifest-level rule enforcement

The ayghri/i-have-adhd repository elevates this practice from documentation advice to architecture requirement, with automated testing and multi-runtime support guaranteeing adherence.

Frequently Asked Questions

What happens if I use vague time estimates like "soon" or "a while"?

The skill's rule set rejects such language. Per [SKILL.md](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), only concrete minute or hour values (e.g., ~5 minutes, ≈ 2 hours) satisfy the constraint. Vague estimates increase cognitive load and transition friction for ADHD developers.

Can I use hours instead of minutes for longer tasks?

Yes, but precision matters. The repository permits ≈ 2 hours or similar concrete units. The prohibition targets phrases like "a few hours" or "some time" that lack boundaries. The [README.md](https://github.com/ayghri/i-have-adhd/blob/main/README.md) explicitly prefers minutes for short tasks to maximize dopamine feedback frequency.

How does this integrate with AI coding assistants?

The skill manifests (for Claude, Codex, OpenCode) embed the time-estimate rule directly in system prompts. When using the [.opencode/command/i-have-adhd.md](https://github.com/ayghri/i-have-adhd/blob/main/.opencode/command/i-have-adhd.md) interface, the constraint is enforced automatically at runtime without user intervention.

Is there automated checking that estimates are actually specific?

Yes. The test suite in [tests/test_opencode_plugin.py](https://github.com/ayghri/i-have-adhd/blob/main/tests/test_opencode_plugin.py) validates plugin outputs for time-estimate compliance. This prevents regression and ensures that all generated guidance maintains ADHD-compatible structure.

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