Potential Future Enhancements for i-have-adhd: 7 High-Impact Development Paths

The i-have-adhd skill supports seven major enhancement vectors—including configurable rules, multi-language support, and interactive quick-fix modes—that leverage its lightweight YAML architecture without breaking existing functionality.

The ayghri/i-have-adhd repository provides a Claude-Code and Codex plugin that enforces ten strict output-shaping rules defined in skills/i-have-adhd/SKILL.md. Its deliberately minimalist architecture—comprising markdown rule definitions, JSON plugin metadata, and TOML agent configurations—creates natural extension points for these potential future enhancements for i-have-adhd. Below are seven high-impact development directions that align with the existing codebase and improve accessibility for neurodivergent developers.

User-Configurable Rule Sets

The current implementation hardcodes ten formatting rules in SKILL.md, but the architecture supports dynamic configuration through plugin.json. Exposing these rules as optional toggles—such as cap-list-size or show-time-estimates—would let users customize their experience without modifying core files.

Implement this by adding a settings block to plugin.json that merges with user-defined preferences at load time. The skill loader can then reference these flags when applying formatting constraints, maintaining backward compatibility while offering personalization.

{
  "cap_list_size": false,
  "show_time_estimates": true
}

Save this configuration to your user settings directory to override the default "cap-list-at-5" restriction and other constraints.

Multi-Language Localization Support

The repository already ships localized README files (e.g., README.zh-CN, README.ja), demonstrating existing infrastructure for internationalization. Extending this to the skill's rule text and example snippets would support the Chinese, Japanese, Korean, and Vietnamese communities already linked in the documentation.

Create a locales/ directory containing JSON translation bundles for each supported language. Modify the skill initialization logic to detect the user's language header and load the appropriate bundle before applying the ten output-shaping rules, ensuring consistent UX across regions.

Interactive Quick-Fix Mode

The "Restate state every turn" logic in SKILL.md (lines 75-82) already tracks user progress through numbered steps. A heuristic engine could hook into this flow to suggest next logical actions—such as "Run tests" or "Commit changes"—immediately after step completion.

Implement this feature by creating a next_action.py helper module that inspects the last completed step and returns probabilistic suggestions based on common development workflows. This maintains the skill's minimalist philosophy while adding proactive assistance for ADHD users who struggle with task initiation.

Web UI Dashboard for Visual Learning

Visual learners benefit from seeing task progress, time estimates, and completed wins in a graphical format. The skill's metadata.hermes block already structures data for UI consumption, making it ideal for a lightweight single-page application.

Add a dashboard/ folder containing index.html and a small JavaScript client that queries the plugin endpoint via existing Claude-Code APIs. This dashboard can display current steps and estimated completion times without requiring changes to the core rule engine, supporting users who process information better visually than textually.

Automated Test Suite for Skill Validation

While the repository contains a test harness in tests/test_run_evals.py, it lacks dedicated validation for the ten specific formatting rules. Adding comprehensive unit tests ensures that constraints like "no preamble/closing" and "cap lists at five items" remain enforced across updates.

Create new test files under tests/skill_rules_test.py using the existing evaluation framework. These tests should verify that each rule renders correctly and that the skill rejects prohibited output patterns, making future refactors safer and more reliable.

pytest tests/skill_rules_test.py

Plugin Marketplace Metadata Expansion

Discoverability remains crucial for accessibility tools. The .claude-plugin/marketplace.json file already supports tags, but currently lacks specific categorization for neurodivergent users.

Enrich the tags array in marketplace.json with terms like "accessibility", "neurodiversity", and "productivity". This single-line edit improves searchability while accurately representing the skill's target demographic and use cases, helping ADHD developers find the tool when browsing the marketplace.

Generic LLM Backend Adapter

The repository currently maintains separate configuration files for OpenAI (agents/openai.yaml) and Gemini (agents/gemini.toml), demonstrating multi-backend capability but lacking a unified interface. A generic adapter would let the skill run on any LLM following the same plugin contract.

Create agents/adapter.py as a thin abstraction layer that loads the appropriate configuration based on runtime environment variables. This eliminates backend-specific code duplication while expanding the skill's compatibility beyond Claude-Code to any compliant LLM platform, including local models.

Implementation Examples

Install the skill using the current platform-specific commands while the unified adapter remains in development. For Claude-Code:

claude plugin marketplace add ayghri/i-have-adhd
claude plugin install i-have-adhd@i-have-adhd

# Then type the command in a Claude‑Code session:

/i-have-adhd

For Codex environments:

codex plugin marketplace add ayghri/i-have-adhd --ref main
codex plugin add i-have-adhd@i-have-adhd

# Apply the style explicitly:

$i-have-adhd

Summary

The i-have-adhd skill's modular architecture supports significant evolution through these seven enhancement paths:

• User-configurable rules enable personalization via plugin.json settings
• Multi-language support leverages existing README localization infrastructure
• Interactive quick-fix mode extends the state-tracking logic in SKILL.md (lines 75-82)
• Web UI dashboard consumes existing metadata.hermes structured data
• Automated testing utilizes the tests/test_run_evals.py harness for validation
• Marketplace metadata improves discoverability through targeted tags in .claude-plugin/marketplace.json
• LLM backend adapter unifies agents/openai.yaml and agents/gemini.toml configurations

Frequently Asked Questions

How can I customize the rules in i-have-adhd?

Add a settings.json file to your user configuration directory containing boolean flags for specific rules, such as disabling list caps or enabling time estimates. The skill loader merges these preferences with defaults from plugin.json at initialization, allowing you to toggle constraints like the "cap-list-at-5" restriction without modifying the core SKILL.md file.

Can i-have-adhd work with LLMs other than Claude?

Yes. The repository already includes agents/openai.yaml and agents/gemini.toml configurations. Creating a generic agents/adapter.py module would allow seamless switching between any LLM backend that adheres to the plugin contract, including local models and alternative API providers.

Where are the core rules defined for this skill?

The ten output-shaping rules reside in skills/i-have-adhd/SKILL.md, which the skill parses at runtime. This markdown file defines constraints like "no preamble/closing" and "cap lists at five items" that govern all AI output formatting, with specific implementation logic referenced around lines 75-82 for state tracking.

How do I run tests for the i-have-adhd skill?

Execute pytest tests/test_run_evals.py to run the existing evaluation harness. For the proposed automated skill tests, run pytest tests/skill_rules_test.py after implementing the new validation files to verify rule compliance, formatting constraints, and the absence of prohibited preambles or closings.

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