feat(skill): add raw colors scan skill

.claude-plugin/marketplace.json

@@ -7,7 +7,27 @@
     {
       "name": "pf-react",
       "source": "./plugins/pf-react",
-      "description": "PatternFly React coding standards and test generation agents"
+      "description": "PatternFly React coding standards and unit test generation agents"
+    },
+    {
+      "name": "pf-design-tokens",
+      "source": "./plugins/pf-design-tokens",
+      "description": "Design token auditing, validation, and migration for PatternFly styling"
+    },
+    {
+      "name": "pf-a11y",
+      "source": "./plugins/pf-a11y",
+      "description": "Accessibility auditing, reporting, and documentation for PatternFly applications"
+    },
+    {
+      "name": "pf-figma",
+      "source": "./plugins/pf-figma",
+      "description": "Figma design review, diffing, and asset identification for PatternFly"
+    },
+    {
+      "name": "pf-workflow",
+      "source": "./plugins/pf-workflow",
+      "description": "Issue tracking, PR management, and cross-repo coordination for PatternFly projects"
     }
   ]
 }

.cursor-plugin/marketplace.json

@@ -0,0 +1,33 @@
+{
+  "name": "ai-helpers",
+  "owner": {
+    "name": "PatternFly Team"
+  },
+  "plugins": [
+    {
+      "name": "pf-react",
+      "source": "./plugins/pf-react",
+      "description": "PatternFly React coding standards and unit test generation agents"
+    },
+    {
+      "name": "pf-design-tokens",
+      "source": "./plugins/pf-design-tokens",
+      "description": "Design token auditing, validation, and migration for PatternFly styling"
+    },
+    {
+      "name": "pf-a11y",
+      "source": "./plugins/pf-a11y",
+      "description": "Accessibility auditing, reporting, and documentation for PatternFly applications"
+    },
+    {
+      "name": "pf-figma",
+      "source": "./plugins/pf-figma",
+      "description": "Figma design review, diffing, and asset identification for PatternFly"
+    },
+    {
+      "name": "pf-workflow",
+      "source": "./plugins/pf-workflow",
+      "description": "Issue tracking, PR management, and cross-repo coordination for PatternFly projects"
+    }
+  ]
+}

CLAUDE.md

@@ -1,19 +1,20 @@
 # PatternFly AI Helpers
 
-This repository contains AI coding helpers for PatternFly development, including Claude Code plugins, Cursor rules, and AI-friendly documentation.
+This repository contains AI coding helpers for PatternFly development, including Claude Code and Cursor plugins and AI-friendly documentation.
 
 ## Key Directories
 
-- `plugins/` - Claude Code plugins with commands and agents
+- `plugins/` - Claude Code and Cursor plugins with skills and agents
 - `docs/` - AI-friendly PatternFly documentation, guidelines, and reference data
-- `.cursor/rules/` - Cursor IDE rules for PatternFly development
-- `.claude-plugin/` - Plugin marketplace configuration
+- `.claude-plugin/` / `.cursor-plugin/` - Marketplace config (identical manifests for each tool)
 
 ## Available Plugins
 
-- **pf-react** - PatternFly React coding standards and test generation agents
-  - `/coding-standards` - PatternFly v6 React coding standards
-  - `/test-generator` - Generate unit tests following Testing Library best practices
+- **pf-react** - PatternFly React coding standards and unit test standards agents
+- **pf-design-tokens** - Design token auditing, validation, and migration for PatternFly styling
+- **pf-a11y** - Accessibility auditing, reporting, and documentation for PatternFly applications
+- **pf-figma** - Figma design review, diffing, and asset identification for PatternFly
+- **pf-workflow** - Issue tracking, PR management, and cross-repo coordination for PatternFly projects
 
 ## Documentation
 

CONTRIBUTING-SKILLS.md

@@ -0,0 +1,170 @@
+# How to Create and Contribute a Skill
+
+## Step 1: Create your skill locally
+
+Work in any project directory or an empty one — NOT in the `ai-helpers` repo.
+
+```bash
+mkdir my-skill-workspace
+cd my-skill-workspace
+```
+
+Open your AI tool (Claude Code, Cursor, etc.):
+
+```bash
+claude  # or open the project in Cursor
+```
+
+## Step 2: Describe what you want
+
+Describe what you want. Be specific about what the skill should do, what the output should look like, and who it's for. For example:
+
+```
+Create a skill called "component-doc" that generates a usage guide
+from a React component's source code. It should output the component name,
+a plain-language description of what it does, a list of its props with types,
+and a basic usage example. Write it for someone who hasn't seen the component before.
+```
+
+This will create a `skills/your-skill-name/SKILL.md` file.
+
+## Step 3: Test it
+
+Use the skill right there in your workspace:
+
+```
+/your-skill-name
+```
+
+Point it at a real file or scenario and see if the output is useful. If not, iterate:
+
+```
+The output is too verbose. Keep each section to 2-3 sentences max.
+```
+
+```
+It's not explaining the props clearly enough. Add the default values.
+```
+
+Iterate until the output matches what you'd actually want to see.
+
+## Step 4: Review your SKILL.md
+
+Open the file and read it. It's just markdown. Ask yourself:
+
+- Are the instructions clear enough that any AI tool would produce the same quality output?
+- Is there anything tool-specific that wouldn't work in both Claude Code and Cursor?
+- Is it under 500 lines? Shorter is better.
+
+## Step 5: Pick the right plugin
+
+Every skill or agent must live in a plugin. Pick the one that matches your skill's domain:
+
+| Plugin | Domain | Example skills | When to use |
+|--------|--------|----------------|-------------|
+| **pf-react** | React components, coding standards, testing | `component-suggest`, `feasibility-check`, `pf-upgrade`, `unit-test-generator`, `bug-triage` | Your skill helps write, test, review, triage, or migrate PatternFly React code |
+| **pf-design-tokens** | Design tokens, CSS variables, color contrast | `hex-scan`, `css-var-audit`, `token-contrast`, `suggest-tokens` | Your skill audits, validates, or suggests design tokens |
+| **pf-a11y** | Accessibility, WCAG, ARIA, screen readers | `audit`, `doc-scaffold` | Your skill checks, reports on, or documents accessibility |
+| **pf-figma** | Figma designs, design-to-code, assets | `design-review`, `design-diff`, `icon-id`, `brand-assets` | Your skill works with Figma designs, icons, or brand assets |
+| **pf-workflow** | Issue tracking, PR management, cross-repo coordination | `create-issue`, `dependency-recommender`, `pr-description`, `changelog-entry`, `release-notes` | Your skill helps with PatternFly project workflows, issue/PR management, contributor coordination, or repo-level tooling (e.g. dependency suggestions) |
+
+**How to decide:**
+- Ask yourself: "Who installs this?" A React developer? → `pf-react`. A designer working in Figma? → `pf-figma`.
+- If your skill spans two domains (e.g., checking token contrast in a React component), pick the domain that best describes the *primary task*, not the input.
+- If it doesn't fit any plugin, open an issue to discuss — don't create a new plugin without coordination.
+
+**Skill vs agent:**
+- **Skill** — a task that produces a result: "generate tests," "audit for accessibility," "find an icon." Most contributions are skills.
+- **Agent** — domain knowledge the AI follows: "always follow these coding standards," "when reviewing designs, always verify brand colors and 8px grid spacing." Only create an agent if it's foundational context that improves *every* interaction in that plugin's area.
+
+**Litmus test:** Can someone use the result? Skill. Is it knowledge the AI should always follow? Agent. When in doubt, write a skill.
+
+**They work together:** An agent's knowledge is loaded automatically when the AI detects relevant context. So if you invoke a skill like `unit-test-generator`, the `coding-standards` agent's knowledge is also active — the agent makes the skill's output better.
+
+## Step 6: Contribute it
+
+Once you're happy with the skill:
+
+1. Fork and clone `patternfly/ai-helpers`
+2. Copy your `SKILL.md` into `plugins/<plugin-name>/skills/your-skill-name/SKILL.md`
+3. Open a pull request
+
+Your skill becomes available as `/<plugin-name>:your-skill-name` for anyone who installs the plugin.
+
+---
+
+## What makes a good skill?
+
+**Good skills are specific.** "Summarize a file" is good. "Help with code" is too vague.
+
+**Good skills define the output format.** Specify what sections to include, how long each should be, and what tone to use.
+
+**Good skills include examples.** Show what good output looks like AND what bad output looks like.
+
+**Good skills are short.** If your SKILL.md is over 200 lines, you're probably over-explaining. Say what you want, not how to think. The [Claude Code docs recommend under 500 lines](https://code.claude.com/docs/en/skills#add-supporting-files) as a ceiling — beyond that, move reference content into supporting files alongside your SKILL.md.
+
+**Good skills describe outcomes, not implementation.** Tell the AI what to accomplish, not how to do it. The AI already knows how to use `git`, `gh`, `grep`, and other tools — you don't need to spell out exact commands or multi-step conditional logic. A single sentence like "Check for issue templates locally, then via GitHub CLI, falling back to a blank issue" is better than 70 lines of bash scripts and if/else branches.
+
+**Good skills are tool-agnostic.** Skills in this repo work in both Claude Code and Cursor. Avoid referencing a specific tool in your instructions or examples (e.g., use "Assistant:" instead of "Claude:" in example conversations).
+
+## What does a SKILL.md look like?
+
+Here's an example `summarize` skill — the entire file:
+
+```markdown
+---
+name: summarize
+description: Summarize code, files, PRs, or directories for a mixed audience
+---
+
+Provide clear, concise summaries of code, files, pull requests,
+or entire directories. Write for a mixed audience of designers,
+developers, and stakeholders.
+
+## How to Summarize
+
+### When given a file or code block
+
+1. Read the file or code provided.
+2. Produce a summary with these sections:
+
+**What it does** — One or two sentences in plain language.
+
+**Key details** — 3-6 bullets of the important things happening inside.
+
+**Dependencies** — What does this file rely on?
+
+**Who cares** — Who needs to know about this file and why.
+
+## Tone and Style
+
+- Write like you're explaining to a coworker over coffee.
+- Use short sentences. Avoid filler.
+- No jargon without explanation.
+- Shorter is better.
+```
+
+We recommend adding YAML frontmatter with a `name` and `description` to every SKILL.md. While skills are discovered by directory path, frontmatter improves compatibility with third-party tooling:
+
+```yaml
+---
+name: summarize
+description: Summarize code, files, PRs, or directories for a mixed audience
+---
+```
+
+After the frontmatter, it's just instructions in markdown. No code. No config.
+
+## Skill ideas to get you started
+
+| Skill | What it does |
+|---|---|
+| `component-doc` | Generate a usage guide from a component's source |
+| `changelog` | Generate a changelog entry from recent git commits |
+| `migration-helper` | Help migrate PatternFly v5 code to v6 |
+| `test-plan` | Generate a QA test plan from a PR diff |
+| `design-review` | Check a component against PatternFly design guidelines |
+| `api-mock` | Generate mock data from a TypeScript interface |
+| `rename` | Suggest better names for variables and functions |
+| `pr-description` | Generate a clear PR description from a diff |
+| `bug-triage` | Preliminary triage of bug issues with fix suggestions and maintainer tagging |

CONTRIBUTING.md

@@ -1,51 +1,59 @@
 # Contributing to PatternFly AI Helpers
 
-We welcome contributions of new plugins, commands, agents, documentation, and Cursor rules.
+We welcome contributions of new plugins, skills, agents, and documentation.
+
+Plugins in this repo work in both **Claude Code** and **Cursor**. Each plugin has both a `.claude-plugin/` and `.cursor-plugin/` directory with identical manifests, so each tool discovers it natively.
 
 ## Repository Structure
 
 ```
-plugins/          # Claude Code plugins (each with commands/, agents/, skills/)
-docs/             # AI-friendly PatternFly documentation
-.cursor/rules/    # Cursor IDE rules
-.claude-plugin/   # Plugin marketplace configuration
+plugins/              # Plugins (skills, agents, MCP servers)
+docs/                 # AI-friendly PatternFly documentation
+.claude-plugin/       # Marketplace config (Claude Code)
+.cursor-plugin/       # Marketplace config (Cursor)
 ```
 
-## Adding a New Claude Code Plugin
+## Adding a Skill to an Existing Plugin
+
+This is the simplest way to contribute. See [CONTRIBUTING-SKILLS.md](CONTRIBUTING-SKILLS.md) for a full walkthrough.
+
+1. Create a directory under the plugin's `skills/` folder: `plugins/<plugin-name>/skills/your-skill/`
+2. Add a `SKILL.md` with your instructions in plain markdown
+3. Open a pull request
+
+Your skill becomes available as `/<plugin-name>:your-skill` once merged.
+
+## Creating a New Plugin
+
+Create a new plugin when your contribution doesn't fit into an existing one — for example, a new domain like charts, chatbot patterns, or migration tooling.
 
 1. Create a new directory under `plugins/your-plugin-name/`
-2. Add a `.claude-plugin/plugin.json` with required metadata:
+2. Add a `plugin.json` to both `.claude-plugin/` and `.cursor-plugin/` (identical content):
    ```json
    {
      "name": "your-plugin-name",
      "description": "What your plugin does",
-     "version": "0.0.1",
+     "version": "1.0.0",
      "author": {
        "name": "Your Name"
      }
    }
    ```
-3. Add commands under `commands/` and/or agents under `agents/` as `.md` files
-4. Register your plugin in `.claude-plugin/marketplace.json`
-5. Add a `README.md` documenting your plugin's commands and usage
+   Both directories contain the same file so each tool discovers the plugin natively.
+3. Add skills under `skills/`, agents under `agents/`, or both
+4. Register your plugin in both `.claude-plugin/marketplace.json` and `.cursor-plugin/marketplace.json` at the repo root
+5. Add a `README.md` documenting your plugin
 
-## Adding a Command or Agent to an Existing Plugin
+### Skills vs Agents
 
-1. Add your `.md` file to the appropriate `commands/` or `agents/` directory
-2. Commands need frontmatter with at minimum a `description` field
-3. Agents need frontmatter with `name`, `description`, and `color` fields
-4. Do **not** hardcode a `model:` in agent frontmatter -- let users choose their preferred model
+- **Skills** (`skills/your-skill/SKILL.md`) — tasks that produce a result. Use this for most contributions.
+- **Agents** (`agents/your-agent.md`) — domain knowledge the AI follows. Use for standards and guidelines.
 
 ## Adding Documentation
 
 1. Add markdown files under `docs/` following the existing directory structure
 2. Update `docs/README.md` (table of contents) to link to your new content
 
-## Adding Cursor Rules
-
-1. Add `.mdc` files to `.cursor/rules/`
-2. Follow the existing frontmatter pattern with `description`, `globs`, and `alwaysApply`
-
 ## Submitting Changes
 
 1. Fork the repository
@@ -57,5 +65,6 @@ docs/             # AI-friendly PatternFly documentation
 
 - Use kebab-case for directory and file names
 - Include clear descriptions in all frontmatter
-- Test your plugins locally before submitting
+- Test your skills locally before submitting
 - Keep documentation concise and AI-friendly
+- Don't hardcode a `model:` in agent frontmatter — let users choose their preferred model