What Programming Languages Does the i-have-adhd Plugin Support?

The i-have-adhd plugin is completely language-agnostic and supports all programming languages that the underlying LLM can generate, including Python, JavaScript, TypeScript, Rust, Go, Java, and C/C++.

The ayghri/i-have-adhd repository provides a response-formatting layer for AI coding assistants that enforces concise, action-oriented output regardless of the target programming language. While the plugin itself is implemented in TypeScript, it functions as a universal formatting skill that intercepts and restructures LLM responses according to a strict 10-rule system defined in the source code.

Language-Agnostic Architecture

The plugin operates as a skill rather than a language-specific compiler or linter. It does not parse, validate, or execute code; instead, it shapes how the assistant presents solutions.

Core Implementation in TypeScript

The plugin's runtime integration lives in extensions/i-have-adhd.ts, which registers the skill with various LLM runtimes (Claude, OpenCode, Pi, and others). This TypeScript file serves as the adapter layer between the runtime environment and the formatting rules.

According to the source code in extensions/i-have-adhd.ts, the plugin exposes a consistent interface that accepts any code generation request and returns a formatted response containing:

• A numbered Action item
• A fenced Code block
• A Next step instruction

The SKILL.md Definition

The canonical behavior is defined in skills/i-have-adhd/SKILL.md. This markdown file contains the 10-rule ADHD-friendly response protocol that the plugin enforces. Because these rules govern presentation structure rather than syntax semantics, they apply uniformly across all programming languages.

The opencode.json and plugin.json descriptors expose this skill to runtimes without language restrictions, allowing the formatter to trigger on Python requests, Rust requests, or any other code generation task.

Supported Programming Languages

Because the plugin acts as a post-processor on LLM output, it theoretically supports any language the underlying model can generate. The repository demonstrates usage with:

• Python (data analysis, algorithms, scripting)
• JavaScript/TypeScript (frontend, Node.js, Deno)
• Rust (systems programming)
• Go (backend services)
• Java (enterprise applications)
• C/C++ (embedded systems, performance-critical code)

The plugin imposes no language-specific constraints or syntax validation; it simply wraps the generated code in the ADHD-friendly format specified in SKILL.md.

How to Use the Plugin with Different Languages

Claude Code Integration

In Claude Code environments, the plugin activates automatically when installed via .claude-plugin/plugin.json. When requesting Python code:

// .claude-plugin/plugin.json
{
  "name": "i-have-adhd",
  "entry": "./extensions/i-have-adhd.ts",
  "type": "skill"
}

A request for a Python Fibonacci function produces:

1. **Action:** Write the function.
2. **Code:**

```python
def fib(n: int) -> int:
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a

3. Next step: Test the function with fib(10).

### OpenCode CLI Usage

The OpenCode runtime consumes the [`opencode.json`](https://github.com/ayghri/i-have-adhd/blob/main/opencode.json) manifest to load the skill. Install once and invoke with any language:

```bash

# Install the plugin

opencode install i-have-adhd

# Generate Rust code

opencode run i-have-adhd "Create a Rust struct for a 2-D point."

Output follows the same 10-rule structure:

1. **Action:** Define the struct.
2. **Code:**

```rust
struct Point {
    x: f64,
    y: f64,
}

3. Next step: Implement a method to calculate the distance from the origin.

### Pi Runtime Integration

For Node.js environments using the Pi runtime, import the skill directly:

```javascript
import { loadSkill } from '@pi/runtime';
const iHaveADHD = await loadSkill('i-have-adhd');

const prompt = "Give me a JavaScript snippet that debounces a function.";
const response = await iHaveADHD.apply(prompt);
console.log(response);

The resulting JavaScript output maintains the standardized format:

1. **Action:** Write a debounce helper.
2. **Code:**

```javascript
function debounce(fn, delay) {
  let timeout;
  return (...args) => {
    clearTimeout(timeout);
    timeout = setTimeout(() => fn.apply(this, args), delay);
  };
}

3. Next step: Use debounce around your event handler.

## Summary

- The i-have-adhd plugin is **language-agnostic** by design, supporting any programming language the LLM can generate.
- The TypeScript implementation in [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts) provides runtime adapters for Claude, OpenCode, and Pi environments.
- Formatting rules live in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md) and enforce a 10-rule structure (**Action**, **Code**, **Next step**) regardless of language.
- No language-specific parsing occurs; the plugin formats raw LLM text output uniformly.
- Configuration files ([`opencode.json`](https://github.com/ayghri/i-have-adhd/blob/main/opencode.json), [`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json)) register the skill without language restrictions.

## Frequently Asked Questions

### Is the i-have-adhd plugin limited to specific programming languages?

No. The plugin functions as a universal response formatter. While the examples in the repository demonstrate Python, JavaScript/TypeScript, Rust, and Java, the [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) rules apply to any code generation task. The LLM handles the language-specific syntax generation; the plugin only structures the presentation.

### What runtime environments support the i-have-adhd plugin?

The plugin supports multiple runtimes through specific manifest files. The [`extensions/i-have-adhd.ts`](https://github.com/ayghri/i-have-adhd/blob/main/extensions/i-have-adhd.ts) file provides the core TypeScript adapter, while [`opencode.json`](https://github.com/ayghri/i-have-adhd/blob/main/opencode.json) targets the OpenCode CLI and [`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json) configures Claude Code and Pi runtimes. Each runtime loads the same [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) definition, ensuring consistent behavior across platforms.

### How does the plugin format responses across different languages?

The plugin enforces a rigid three-part structure defined in [`skills/i-have-adhd/SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md). Every response must include: (1) a numbered **Action** describing what to do, (2) a fenced **Code** block containing the implementation, and (3) a **Next step** instruction. This structure remains identical whether the code inside the block is Python, Go, C++, or any other language.

### Can I use the plugin with languages not explicitly mentioned in the repository?

Yes. Because the plugin does not validate syntax or maintain language-specific grammars, it works with niche or domain-specific languages (DSL) as long as the underlying LLM can generate them. Simply request code in your target language (e.g., Zig, Haskell, or Julia), and the plugin will apply the ADHD-friendly formatting rules to that output.

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