# How i‑have‑ADHD Generates Specific Time Estimates for Tasks

> Discover how the i-have-ADHD agent generates precise time estimates for tasks by enforcing strict formatting rules. Learn how vague durations are replaced with exact minutes and hours.

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

---

**The i‑have‑ADHD agent enforces concrete time estimates by loading a strict formatting rule from `skills/i‑have‑adhd/SKILL.md` that instructs the LLM to replace vague duration phrases with exact minutes or hours in every response.**

The *i‑have‑ADHD* skill helps neurodivergent developers manage cognitive load by eliminating ambiguity in task planning. Unlike traditional project management tools that rely on algorithmic calculations, this open‑source agent uses a declarative rule system to mandate **specific time estimates for tasks** directly within the LLM's prompt context. By embedding time constraints into the skill definition, the system ensures consistent, actionable duration information across all supported platforms including OpenCode, Claude, and Gemini.

## The "Vague Estimates Fail" Rule in SKILL.md

The definitive source for time estimation behavior resides in `skills/i‑have‑adhd/SKILL.md` at **lines 82‑88**. This file contains a set of 10 strict formatting rules that the agent must follow when constructing replies. Rule 6 explicitly states: *"Vague estimates fail. Ballpark in concrete units."*

The skill definition rejects subjective duration language. Instead of permitting the LLM to generate fuzzy outputs like *"This will take some work,"* the rule mandates precise temporal units. The approved pattern requires estimates formatted as **concrete time ranges** (e.g., *"About 15 minutes if tests already cover this. An afternoon if not."*), ensuring users receive immediately actionable scheduling information.

### Concrete vs. Vague Language Examples

The SKILL.md file provides explicit contrast examples to guide the model:

```markdown

# Incorrect (vague)

This will take some work.

# Correct (concrete)

About 15 minutes if tests already cover this. An afternoon if not.

```

When the agent processes a request, it references these examples within its prompt context, forcing the underlying language model to self‑correct any ambiguous duration statements before returning output to the user.

## Runtime Enforcement Across Platforms

The time estimate rule propagates through **platform‑specific adapters** that each load the canonical skill file at runtime. Because every adapter reads from the same [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) source, concrete time estimates appear consistently whether the user interacts via OpenCode, Claude, Gemini, Pi, or OMP.

### OpenCode Plugin Implementation

The OpenCode runtime initializes the skill through `.opencode/plugins/i‑have‑adhd.mjs`. This plugin loads `skills/i‑have‑adhd/SKILL.md` into the agent's prompt context, making the 10 formatting rules—including the concrete time estimate directive—available to the inference engine. During response generation, the harness validates that the LLM output adheres to the skill constraints before streaming text to the user interface.

### Claude and Multi‑Platform Manifests

Similarly, the Claude adapter references the skill via `.claude‑plugin/plugin.json`. This manifest imports the same [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) file, ensuring that Claude‑based deployments enforce identical formatting standards. The shared dependency on a single skill definition prevents drift across environments; every runtime presents **specific time estimates for tasks** using the same concrete unit requirements.

## Answer Composition Strategy

When generating multi‑step responses, the agent applies the **lead‑with‑next‑action** pattern. This architectural decision places the time estimate immediately adjacent to the first actionable instruction, minimizing cognitive overhead for the user.

### Inserting Estimates in the First Actionable Line

Following the lead‑with‑next‑action protocol, the agent constructs replies where the initial command includes the duration inline. For example:

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

```

By binding the **specific time estimate** directly to the command using visual separators (em‑dashes or tildes), the system ensures the duration information is unmistakable and scannable. The LLM does not append estimates as footnotes; it embeds them into the primary action statement as mandated by the skill rules.

## Continuous Integration Validation

The repository maintains enforcement integrity through automated testing. The workflow defined in `.github/workflows/plugin‑load‑check.yml` validates that each platform adapter correctly loads the skill file without parsing errors. This CI check indirectly confirms that the concrete time estimate rule remains active in production builds, catching configuration regressions before deployment.

## Summary

- **Rule Location:** The concrete time estimate requirement is defined at lines 82‑88 in `skills/i‑have‑adhd/SKILL.md`.
- **Enforcement Method:** The rule is not algorithmically calculated but **prompt‑injected** into the LLM context, forcing explicit minute or hour declarations.
- **Cross‑Platform Consistency:** Adapters for OpenCode (`.opencode/plugins/i‑have‑adhd.mjs`), Claude (`.claude‑plugin/plugin.json`), and other runtimes share the same skill file.
- **UI Pattern:** Estimates follow the lead‑with‑next‑action format, appearing inline with the first command using concrete units (e.g., **~5 minutes**).
- **Quality Assurance:** CI workflows verify skill file loading to prevent rule degradation.

## Frequently Asked Questions

### Does i‑have‑ADHD calculate time estimates algorithmically?

No. According to the source code, the system does **not** compute durations through algorithms or historical data analysis. Instead, it instructs the language model to output explicit time ranges via prompt engineering rules defined in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md). The LLM generates estimates based on its training knowledge, constrained by the strict formatting requirement to use concrete units.

### Where is the time estimate rule defined?

The rule resides in `skills/i‑have‑adhd/SKILL.md` between **lines 82‑88**. This section forms part of a broader set of 10 formatting rules that govern all agent responses. The file explicitly contrasts acceptable concrete estimates (*"About 15 minutes"*) against prohibited vague phrasing (*"This will take some work"*), giving the LLM few‑shot examples for compliance.

### Which platforms enforce concrete time estimates?

Every runtime that loads the i‑have‑ADHD skill enforces the rule, including **OpenCode**, **Claude**, **Gemini**, **Pi**, and **OMP**. Each platform uses a dedicated adapter (such as `.opencode/plugins/i‑have‑adhd.mjs` or `.claude‑plugin/plugin.json`) that imports the canonical [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) file, ensuring uniform behavior across environments.

### How does the agent format time estimates in responses?

The agent uses the **lead‑with‑next‑action** pattern, inserting the estimate immediately after the first actionable command in the format `Action – **~X minutes**`. This inline placement ensures the duration appears at the exact moment the user reads the instruction, eliminating the need to search for timing information elsewhere in the response.