# How the i-have-adhd Plugin Estimates Time for ADHD-Friendly Responses

> Discover how the i-have-adhd plugin prompts AI to estimate time for ADHD-friendly responses using concrete units, enhancing your workflow.

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

---

**The plugin does not calculate time itself—it injects a behavioral rule into the system prompt that instructs the language model to "ballpark in concrete units."**

The *i-have-adhd* plugin helps developers with ADHD by restructuring AI responses for clarity and actionability. One of its most practical features is the **automatic inclusion of concrete time estimates** (e.g., "About 15 minutes" or "roughly an hour"). This article explains how the plugin enables time estimation behavior based on the rules defined in its source code.

## How Time Estimation Actually Works

The plugin **does not perform any deterministic calculation** of task duration. Instead, it relies on the underlying language model's knowledge and reasoning capabilities, guided by an explicit rule in the skill definition.

### The Rule That Drives Time Estimates

In [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md), **Rule 6 — "Give specific time estimates"** provides the instruction:

```markdown
- **Give specific time estimates**  
  Ballpark in concrete units (e.g., "About 15 minutes...", "roughly an hour...") instead of "a while".

```

This rule appears at lines 82–88 of the SKILL.md file. The directive is unambiguous: replace vague temporal language with quantified, concrete estimates.

### Plugin Architecture: Prompt Injection, Not Computation

The plugin's role is strictly **orchestration**. When activated, the code in `.opencode/plugins/i-have-adhd.mjs` performs these steps:

1. **Reads** the SKILL.md file
2. **Strips** YAML front-matter from the markdown
3. **Injects** the raw ruleset into the system prompt

The relevant implementation spans lines 35–42 and 55–70:

```javascript
// From .opencode/plugins/i-have-adhd.mjs
// The plugin loads SKILL.md and processes it for injection
async function loadSkill() {
  const skillPath = path.join(__dirname, '../../skills/i-have-adhd/SKILL.md');
  const content = await fs.readFile(skillPath, 'utf8');
  // Strip frontmatter and return body
  return content.replace(/^---[\s\S]*?---/, '').trim();
}

// Later, the ruleset is prepended to every system prompt
function injectSkill(systemPrompt) {
  return `${skillRules}\n\n${systemPrompt}`;
}

```

Once injected, the model receives the full rule set as context and generates time estimates **autonomously** based on:

- The complexity of the described task
- Its training knowledge about typical development workflows
- The explicit stylistic constraint to use concrete units

## Activating Time Estimates in Your Session

The ADHD-friendly time estimates appear automatically once the skill is loaded. You have two activation modes.

### On-Demand Activation

Trigger the skill for a single session by sending the command:

```javascript
await chat.sendMessage('/i-have-adhd');

```

### Always-On Activation

For persistent behavior across turns, create the flag file:

```bash
touch ~/.config/opencode/.i-have-adhd-always

```

The `hooks/always-on.mjs` runtime component monitors this flag and ensures the skill ruleset—including Rule 6—remains active for every interaction.

## What the Output Looks Like

With the skill active, model responses transform from vague to actionable. A typical reply includes time estimates inline:

```text
Run `npm install jsonwebtoken`, then edit `src/auth.ts:42`.

About **15 minutes** if tests already cover the change; an **hour** if they don't.

```

Notice the ** dual structure**: primary estimate with a conditional branch. This mirrors the rule's intent to provide concrete, scenario-aware time framing.

## Why This Architecture Matters

The plugin's design reflects a key insight: **time estimation for creative/development work is inherently uncertain**. Rather than bake in brittle heuristics, the plugin:

- **Leverages model reasoning** — the LLM assesses task complexity holistically
- **Remains maintainable** — rule changes require only editing SKILL.md
- **Preserves flexibility** — estimates adapt to context rather than following rigid formulas

According to the `ayghri/i-have-adhd` source code, no timing logic exists in the plugin's JavaScript files. The entire behavior emerges from prompt engineering and model compliance with the declared ruleset.

## Key Files for Time Estimation Behavior

| File | Function |
|------|----------|
| [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) | Contains **Rule 6** that mandates concrete time units; authoritative source of the behavior |
| `.opencode/plugins/i-have-adhd.mjs` | Loads and injects SKILL.md content into system prompts (lines 35–42, 55–70) |
| `hooks/always-on.mjs` | Runtime persistence mechanism for the always-on flag |

## Summary

- **Time estimation is model-driven**, not computed by the plugin
- **Rule 6 in SKILL.md** explicitly instructs the model to use concrete time units
- **The plugin only handles prompt injection** via `.opencode/plugins/i-have-adhd.mjs`
- **Activation modes**: `/i-have-adhd` command or `~/.config/opencode/.i-have-adhd-always` flag
- **No fixed algorithm** — estimates adapt to task context through LLM reasoning

## Frequently Asked Questions

### Does the plugin calculate how long tasks take?

No. The plugin contains no timing logic, heuristics, or lookup tables. It solely injects Rule 6 into the system prompt, which instructs the language model to provide its own time estimates based on context and training knowledge.

### Can I customize the time estimation behavior?

Yes—by editing [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md). Modify Rule 6's wording to change how estimates are phrased, or adjust other rules to complement the timing guidance. Changes take effect immediately on plugin reload; no code changes required.

### Why use ballpark estimates instead of precise calculations?

Precise software development time estimates are notoriously unreliable. The "ballpark in concrete units" approach from Rule 6 acknowledges uncertainty while still providing actionable framing—critical for ADHD users who benefit from temporal boundaries without false precision.

### What happens if the model ignores the time estimate rule?

The ruleset injection in `.opencode/plugins/i-have-adhd.mjs` places the instructions at the start of the system prompt, maximizing compliance likelihood. If estimates still fail to appear, verify the plugin activated correctly: check for the `/i-have-adhd` command response or confirm the always-on flag file exists.