# Primary Technologies Used in the i-have-adhd Project: YAML, TOML, and Python

> Discover the core technologies powering the i-have-adhd project. Learn how YAML TOML and Python enable a lightweight AI agent with no heavy dependencies.

- Repository: [Ayoub Ghriss/i-have-adhd](https://github.com/ayghri/i-have-adhd)
- Tags: primary-technologies
- Published: 2026-07-30

---

**The i-have-adhd project leverages a declarative technology stack comprising YAML, TOML, JSON, Markdown, Python, and Bash to create a lightweight AI-agent skill without compiled binaries or heavy runtime dependencies.**

The i-have-adhd repository is a lightweight AI-agent skill designed to shape output for readers with ADHD. Developed under `ayghri/i-have-adhd`, this project demonstrates how primary technologies like YAML and TOML can power cross-platform agent configurations. Understanding these core technologies reveals why the project maintains a pure-data implementation that deploys seamlessly across Claude, Codex, and Gemini agents.

## Declarative Configuration Formats

The project relies on human-readable data formats to define agent behavior and metadata. These declarative files eliminate the need for complex build steps or runtime compilation.

### YAML for OpenAI Agent Configuration

**YAML** powers the OpenAI-style agent configuration in [`agents/openai.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/openai.yaml). This file instructs Claude Code and similar agents how to load and invoke the skill.

```yaml

# agents/openai.yaml

name: i-have-adhd
description: Shape output for a reader with ADHD …
disable-model-invocation: true

```

The `disable-model-invocation` flag set to `true` ensures the skill operates as a formatting layer rather than triggering additional model calls.

### TOML for Gemini Agent Configuration

**TOML** provides the equivalent configuration for Gemini agents in [`agents/gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/gemini.toml). This format offers the same semantic structure with Gemini-specific syntax requirements.

```toml

# agents/gemini.toml

name = "i-have-adhd"
description = "ADHD‑friendly output for Gemini"
disable_model_invocation = true

```

Both configuration files serve identical purposes but use format-specific conventions—hyphens in YAML versus underscores in TOML for the `disable-model-invocation` parameter.

### JSON for Plugin Metadata

**JSON** stores minimal plugin metadata in [`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json). This file acts as a machine-readable descriptor for the hosting platform's plugin system.

```json
{
  "name": "i‑have‑adhd",
  "description": "Shape Antigravity output for an ADHD reader …"
}

```

The JSON structure provides essential identity information without requiring complex parsing logic.

## Documentation and Skill Logic

Human-readable documentation encodes the actual skill behavior and usage guidelines.

### Markdown for Skill Definitions

**Markdown** houses the core skill logic in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) and project documentation in [`README.md`](https://github.com/ayghri/i-have-adhd/blob/main/README.md). The [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md) file contains the ADHD-focused output rules that agents apply when formatting responses. Unlike compiled code, these Markdown files allow for immediate editing and version control of the skill's behavioral parameters.

## Evaluation and Automation

Python and Bash scripts provide the executable components for testing and development workflows.

### Python Evaluation Harness

**Python** implements the evaluation harness in [`scripts/run_evals.py`](https://github.com/ayghri/i-have-adhd/blob/main/scripts/run_evals.py) and its corresponding test suite in [`tests/test_run_evals.py`](https://github.com/ayghri/i-have-adhd/blob/main/tests/test_run_evals.py). The evaluation script processes JSONL case files to verify skill functionality.

```python

# scripts/run_evals.py

import json, pathlib

def main():
    case_file = pathlib.Path('evals/cases.jsonl')
    for line in case_file.read_text().splitlines():
        case = json.loads(line)
        # … evaluate the case …

```

This lightweight interpreter handles test case validation without requiring external dependencies or compiled extensions.

### Bash Hooks for Development

**Bash** manages repository hooks in [`hooks/always-on.sh`](https://github.com/ayghri/i-have-adhd/blob/main/hooks/always-on.sh). This shell script keeps the skill active within the development environment, ensuring the ADHD formatting rules remain engaged during coding sessions.

The combination of Python for logic and Bash for automation creates a minimal runtime footprint compatible with standard Unix-like development environments.

## Summary

The i-have-adhd project demonstrates a **pure-data architecture** using six primary technologies:

- **YAML** configures OpenAI-compatible agents via [`agents/openai.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/openai.yaml)
- **TOML** defines Gemini-specific settings in [`agents/gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/gemini.toml)
- **JSON** provides plugin metadata in [`plugin.json`](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json)
- **Markdown** encodes skill logic and documentation in [`SKILL.md`](https://github.com/ayghri/i-have-adhd/blob/main/SKILL.md)
- **Python** powers evaluation scripts in [`scripts/run_evals.py`](https://github.com/ayghri/i-have-adhd/blob/main/scripts/run_evals.py) and [`tests/test_run_evals.py`](https://github.com/ayghri/i-have-adhd/blob/main/tests/test_run_evals.py)
- **Bash** manages development hooks in [`hooks/always-on.sh`](https://github.com/ayghri/i-have-adhd/blob/main/hooks/always-on.sh)

This declarative approach eliminates compiled binaries and heavy runtime dependencies, enabling cross-platform deployment across Claude, Codex, and Gemini agents.

## Frequently Asked Questions

### What is the main purpose of the i-have-adhd project?

The i-have-adhd project is an AI-agent skill that formats output specifically for readers with ADHD. According to the `ayghri/i-have-adhd` source code, it uses declarative configuration files rather than compiled code to shape how AI assistants present information, making content more accessible through structured formatting rules stored in Markdown.

### Why does i-have-adhd use both YAML and TOML for agent configuration?

The project uses YAML for OpenAI-style agents (Claude/Code) and TOML for Gemini agents to match each platform's native configuration preferences. While [`agents/openai.yaml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/openai.yaml) uses YAML's indentation-based syntax with hyphenated keys like `disable-model-invocation`, [`agents/gemini.toml`](https://github.com/ayghri/i-have-adhd/blob/main/agents/gemini.toml) adopts TOML's key-value format with snake_case equivalents like `disable_model_invocation`, ensuring compatibility with both ecosystems.

### How does the Python evaluation script verify the i-have-adhd skill works?

The [`scripts/run_evals.py`](https://github.com/ayghri/i-have-adhd/blob/main/scripts/run_evals.py) file implements a lightweight evaluation harness that reads test cases from `evals/cases.jsonl`. It uses Python's standard `json` and `pathlib` libraries to parse each line, validate the skill's formatting output against expected results, and report pass/fail status without requiring external testing frameworks or compiled dependencies.

### Is the i-have-adhd project dependent on any compiled binaries?

No. The project maintains a **pure-data implementation** using only human-readable formats (YAML, TOML, JSON, Markdown) and interpreted scripts (Python and Bash). As implemented in `ayghri/i-have-adhd`, this architecture ensures the skill installs easily across different AI agents without platform-specific compilation steps or heavy runtime dependencies.