How i-have-adhd Handles Specific Time Estimates for Task Responses

i-have-adhd enforces concrete time estimates by instructing the LLM to output explicit durations in minutes or hours, never vague phrases like "some time" or "a while."

The ayghri/i-have-adhd repository implements a strict formatting rule that transforms how AI assistants communicate task effort to users. Rather than leaving duration ambiguous, the skill mandates that every actionable response include a precise, quantifiable time estimate. This article breaks down the mechanism, the source files involved, and how the rule propagates across multiple runtime environments.

The Time Estimate Rule in SKILL.md

The core requirement lives in skills/i-have-adhd/SKILL.md at lines 82–88. This file defines rule 6 of 10 formatting constraints governing how the LLM constructs replies.

The rule states: "Vague estimates fail. Ballpark in concrete units." It pairs this instruction with a concrete before-and-after example:

Bad (vague)	Good (concrete)
"This will take some work."	"About 15 minutes if tests already cover this. An afternoon if not."

The skill does not compute durations algorithmically. Instead, it shapes the LLM's output behavior through prompt engineering and constraint enforcement. When the model generates a response, it applies this formatting rule during token selection, ensuring the final text contains explicit time units.

How Time Estimates Appear in Generated Responses

The i-have-adhd skill follows a lead-with-next-action structure. This means the first line of any response must present the immediate actionable step with its associated time estimate.

Consider this response pattern enforced by the skill:

Run `npm install jsonwebtoken` – **~5 minutes**.  
Then edit `src/auth.ts:42` – **≈2 minutes**.

Each actionable item receives a parenthetical or inline time estimate using minutes, hours, or half-day units ("an afternoon"). The estimates use approximation symbols (~, ≈) to signal informed guessing rather than precision, but the units remain concrete and unambiguous.

Compare this to the incorrect, vague alternative that the rule explicitly forbids:

Run `npm install jsonwebtoken`. This will take some work.

The absence of any temporal unit violates rule 6 and would fail skill compliance.

Cross-Platform Enforcement Through Shared Skill Loading

One distinctive feature of i-have-adhd is how the time estimate rule propagates across different AI runtimes. Each platform-specific adapter loads identical skill definitions, ensuring consistent behavior.

OpenCode Plugin (i-have-adhd.mjs)

The file .opencode/plugins/i-have-adhd.mjs serves as the runtime loader for OpenCode environments. It reads skills/i-have-adhd/SKILL.md at initialization and injects the formatting constraints— including the specific time estimate rule—into the agent's system prompt.

Because this plugin loads the skill dynamically, any update to SKILL.md automatically propagates to all OpenCode deployments without code changes.

Claude Manifest (.claude-plugin/plugin.json)

The Claude-specific adapter at .claude-plugin/plugin.json references the same SKILL.md file. This guarantees that Claude-powered deployments enforce identical time estimate formatting.

The manifest structure ensures the Claude runtime recognizes and applies the 10 formatting rules, including rule 6, when generating responses through Claude Desktop or API integrations.

Additional Runtimes (Gemini, Pi, OMP)

The repository's architecture supports Gemini, Pi, and OMP through parallel adapter structures. Each maintains the same pattern: a lightweight manifest or loader that imports skills/i-have-adhd/SKILL.md and applies its constraints. This unified approach means users receive consistent time estimates regardless of which AI runtime they invoke.

CI Validation of Time Estimate Compliance

The repository includes a continuous integration check at .github/workflows/plugin-load-check.yml. This workflow validates that each platform plugin successfully loads its skill file.

While the CI does not parse response text to verify time estimates appear, it confirms that:

• The skill file is syntactically valid
• Plugin loaders can access and initialize the skill
• No structural changes have broken runtime integration

This indirect validation ensures the time estimate rule remains active in production builds across all supported platforms.

Key Implementation Files

File	Purpose
skills/i-have-adhd/SKILL.md	Defines rule 6 requiring specific time estimates; lines 82–88 contain the core instruction and example
.opencode/plugins/i-have-adhd.mjs	OpenCode runtime plugin that loads and applies the skill constraints
.claude-plugin/plugin.json	Claude platform manifest linking to the shared skill definition
.github/workflows/plugin-load-check.yml	CI workflow verifying plugin load integrity

Summary

• Rule location: Lines 82–88 of skills/i-have-adhd/SKILL.md mandate concrete time estimates and prohibit vague phrasing
• Implementation mechanism: LLM prompt engineering through skill constraints, not algorithmic computation
• Response format: Time estimates appear inline with the first actionable step using minutes, hours, or half-day units
• Cross-platform consistency: Shared skill loading via platform adapters (OpenCode, Claude, Gemini, Pi, OMP) ensures uniform behavior
• Validation: CI workflow at .github/workflows/plugin-load-check.yml confirms runtime loadability

Frequently Asked Questions

How does i-have-adhd calculate accurate time estimates?

It does not calculate them. The skill instructs the LLM to output explicit duration estimates based on its training knowledge and reasoning about task complexity. Estimates use approximation language (~5 minutes, ≈2 minutes, an afternoon) to signal informed judgment rather than precise measurement.

Why use concrete time estimates instead of letting the LLM decide?

Vague phrasing like "some work" or "a while" creates uncertainty for users with ADHD, who may struggle with time perception and task initiation. Concrete estimates reduce cognitive load by making effort visible and actionable immediately.

Can the time estimate rule be customized or disabled?

The rule is hardcoded in SKILL.md as part of the skill definition. Users could fork the repository and modify skills/i-have-adhd/SKILL.md, but the official distribution enforces this constraint uniformly across all supported platforms.

What units does i-have-adhd recommend for time estimates?

The skill examples favor minutes for short tasks (5–30 minutes), hours for medium tasks (1–3 hours), and half-day units like "an afternoon" for larger efforts. The key requirement is specificity—concrete numbers with concrete units—rather than exact precision.

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