How to Manage Team-Wide Deployments with Consistent Rule Configurations Using the i-have-adhd Skill

The i-have-adhd repository provides a Claude/Cursor skill that enforces a strict, ADHD-friendly output format across all LLM-generated responses, enabling teams to guarantee uniform formatting through declarative configuration files and automated CI validation.

Team-wide LLM deployments often suffer from inconsistent output styles as developers invoke models with different prompting habits. The i-have-adhd skill solves this by codifying a 10-rule style sheet into a reusable plugin that any team member can install and activate. This approach eliminates configuration drift and ensures every response follows the same structural contract—regardless of which developer triggered the generation.

Understanding the Skill Architecture

The repository organizes its components into five clear layers, each serving a specific purpose in the deployment pipeline:

Component	Purpose	Key Files
Skill definition	Declares the rule set and persistence behavior	[skills/i-have-adhd/SKILL.md](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md)
Plugin metadata	Exposes the skill to Claude/Cursor plugin system	[plugin.json](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json)
Agent configuration	Binds the skill to specific LLM backends without code changes	[agents/openai.yaml](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/agents/openai.yaml) & [agents/gemini.toml](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/agents/gemini.toml)
Installation scripts	Automates plugin registration for reproducible deployment	[scripts/run_evals.py](https://github.com/ayghri/i-have-adhd/blob/main/scripts/run_evals.py)
CI workflows	Validates skill definition on every push	[.github/workflows/plugin-load-check.yml](https://github.com/ayghri/i-have-adhd/blob/main/.github/workflows/plugin-load-check.yml)

How the Skill Enforces Consistency

The deployment mechanism follows a four-phase lifecycle:

1. Load Phase — The platform reads plugin.json to locate skill files when users run claude plugin install i-have-adhd@i-have-adhd

2. Activation — SKILL.md is parsed and its rules stored in persistent LLM session context (lines 17-21 of SKILL.md)

3. Enforcement — Every response is filtered through the rule engine, which rewrites output to satisfy the 10-rule contract

4. Persistence Control — The skill remains active until explicit deactivation phrases ("stop adhd mode" or "normal mode"), ensuring multi-turn workflows maintain uniform formatting

This persistence model is critical for team-wide deployments with consistent rule configurations—once activated, the skill survives across multiple API calls within the same session.

Installing the Skill Across Your Team

One-Line Installation

claude plugin uninstall i-have-adhd            # optional: clear old version

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

These commands originate from the Tune it section of README.md (lines 77-84). Teams can distribute this snippet via internal documentation or automated onboarding scripts.

Activating in a Claude Session

/i-have-adhd

The LLM immediately adopts the ADHD-friendly format. To revert:

stop adhd mode

This activation pattern ensures zero-code adoption—no IDE plugins, no configuration files, no environment variables.

Configuring Multi-Backend Deployments

The skill supports language-agnostic binding through YAML/TOML agent files. This design lets the same rule set attach to OpenAI, Gemini, or future providers without modifications.

OpenAI Agent Binding

# skills/i-have-adhd/agents/openai.yaml

name: i-have-adhd
description: Enforce ADHD-friendly output style
plugin: i-have-adhd

Gemini Agent Binding

# skills/i-have-adhd/agents/gemini.toml

name = "i-have-adhd"
description = "Enforce ADHD-friendly output style"
plugin = "i-have-adhd"

Teams can version these files in a shared repository, ensuring every developer's agent configuration matches the organizational standard.

Automating Validation with CI

The GitHub Action in .github/workflows/plugin-load-check.yml guarantees that rule changes don't break deployments:

name: Plugin Load Check
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Verify plugin loads
        run: |
          claude plugin install i-have-adhd@i-have-adhd
          claude plugin list | grep i-have-adhd

This workflow runs on every commit, catching malformed SKILL.md syntax or missing plugin metadata before changes reach production.

Updating Rules Through Pull Requests

Because SKILL.md is plain markdown, teams evolve their style guide through standard git workflows:

• Propose — Developer opens PR modifying SKILL.md
• Validate — CI workflow confirms plugin loads correctly
• Review — Team approves rule changes (e.g., adding an 11th rule)
• Deploy — Merged changes propagate automatically to all installations

This declarative approach eliminates the "works on my machine" problem common in prompt engineering.

Key Files for Deployment Management

File	Role
[README.md](https://github.com/ayghri/i-have-adhd/blob/main/README.md)	Overview and installation instructions
[skills/i-have-adhd/SKILL.md](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/SKILL.md)	Full rule set and behavioral contract
[plugin.json](https://github.com/ayghri/i-have-adhd/blob/main/plugin.json)	Plugin descriptor for Claude/Cursor
[skills/i-have-adhd/agents/openai.yaml](https://github.com/ayghri/i-have-adhd/blob/main/skills/i-have-adhd/agents/openai.yaml)	OpenAI backend binding example
[.github/workflows/plugin-load-check.yml](https://github.com/ayghri/i-have-adhd/blob/main/.github/workflows/plugin-load-check.yml)	CI validation workflow

These five files constitute the entire deployment surface—minimal, inspectable, and version-controlled.

Summary

• Declarative rules in SKILL.md — Single source of truth eliminates configuration drift
• Persistent session activation — Rules survive across multiple LLM calls without re-invocation
• Multi-backend YAML/TOML bindings — Same skill works with OpenAI, Gemini, and future providers
• Zero-code installation — claude plugin install command enables trivial team rollouts
• CI-validated changes — GitHub Action guarantees every modification loads correctly before deployment

Frequently Asked Questions

How does the skill maintain consistency across different developers' machines?

The skill stores its rule set in SKILL.md, a plain markdown file that installs identically on every machine through the claude plugin install command. Because the rules are packaged with the plugin—not configured per-user—every team member receives the exact same behavioral contract automatically.

Can the skill be used with LLM providers other than OpenAI?

Yes. The repository includes agent configuration files for multiple backends: skills/i-have-adhd/agents/openai.yaml and skills/i-have-adhd/agents/gemini.toml. The skill framework is designed to bind to any LLM provider that supports the plugin protocol.

What happens if someone modifies the rules incorrectly?

The GitHub Action in .github/workflows/plugin-load-check.yml validates every pull request. If a change to SKILL.md breaks the plugin load sequence, the CI check fails and the PR cannot merge without correction—preventing broken deployments.

How do team members deactivate the skill when needed?

Users issue the natural language commands "stop adhd mode" or "normal mode" (specified in rule 21 of SKILL.md). This returns the LLM to default behavior without uninstalling the plugin, allowing flexible workflow switching.

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