# What Are the 12 Domains Covered by the Claude-Skills Plugin?

> Explore the 12 domains of the Claude-Skills plugin, from language and backend to data ML and security. Understand its 66 specialized skills and how they are organized for efficient development.

- Repository: [Jeffallan/claude-skills](https://github.com/jeffallan/claude-skills)
- Tags: tutorial
- Published: 2026-02-16

---

**The Claude-Skills plugin organizes its 66 specialized skills into 12 fixed domain categories—language, backend, frontend, infrastructure, api-architecture, quality, devops, security, data-ml, platform, specialized, and workflow—defined in the core [`CLAUDE.md`](https://github.com/Jeffallan/claude-skills/blob/main/CLAUDE.md) configuration file.**

The Jeffallan/claude-skills repository implements a domain-driven architecture that categorizes every skill into one of these 12 distinct domains. This classification system enables precise skill routing, CLI filtering, and automatic activation based on the technical context of user requests.

## The 12 Domains Defined in CLAUDE.md

The canonical list of domains is explicitly defined in [[`CLAUDE.md`](https://github.com/Jeffallan/claude-skills/blob/main/CLAUDE.md)](https://github.com/Jeffallan/claude-skills/blob/main/CLAUDE.md) at lines 72‑73. These domains represent high-level technical disciplines that group the 66 specialized skills for targeted activation.

| Domain | Description |
|--------|-------------|
| **language** | Core programming-language expertise (Python, TypeScript, Go, Rust, Swift, etc.) |
| **backend** | Server-side frameworks and services (NestJS, Django, FastAPI, Laravel, Spring Boot, .NET Core) |
| **frontend** | Client-side UI frameworks (React, Next.js, Vue, Angular, React-Native, Flutter) |
| **infrastructure** | Cloud and container orchestration (Kubernetes, Terraform, Postgres, Cloud Architecture) |
| **api-architecture** | API design and integration (GraphQL, REST, WebSocket, Microservices, MCP) |
| **quality** | Testing, code review, and quality assurance (Test Master, Playwright, Code Reviewer) |
| **devops** | CI/CD, monitoring, reliability, chaos testing, and CLI tooling |
| **security** | Secure coding, vulnerability review, and security hardening |
| **data-ml** | Data engineering and machine-learning pipelines (Pandas, Spark, ML Pipeline, Prompt Engineer, RAG) |
| **platform** | Platform-specific extensions (Salesforce, Shopify, WordPress, Atlassian MCP) |
| **specialized** | Niche technical areas (Embedded Systems, Game Development, Legacy Modernization) |
| **workflow** | Project-level workflow orchestration (Feature Forge, Spec Miner, Debugging Wizard, The Fool) |

## How Domain Classification Works in the Plugin

The domain system operates through metadata enforcement and automated routing. Every skill in the repository must declare its domain in the front-matter of its [`SKILL.md`](https://github.com/Jeffallan/claude-skills/blob/main/SKILL.md) file, ensuring consistent classification across all 66 available skills.

### Domain Declaration in Skill Front-Matter

Each skill defines its domain using the `metadata.domain` field in its YAML front-matter. This field must contain exactly one of the twelve canonical values defined in [`CLAUDE.md`](https://github.com/Jeffallan/claude-skills/blob/main/CLAUDE.md).

```yaml
---
name: react-expert
description: Use when building modern React applications
license: MIT
metadata:
  author: https://github.com/Jeffallan
  version: "1.0.0"
  domain: frontend          # ← matches one of the 12 domains

  triggers: react, component
  role: specialist
  scope: implementation
  output-format: code
  related-skills: fullstack-guardian, test-master
---

```

The `domain: frontend` entry ensures the skill is categorized under the **frontend** domain for routing and discovery.

### Domain Validation and Routing

The plugin validates all skill metadata against the canonical domain list during initialization. This enforcement occurs in the core configuration parsing logic, preventing invalid domain assignments that would break the routing system.

## Navigating Skills by Domain

Users interact with the domain system through CLI commands and automatic request matching. The plugin leverages domain classification to filter skill lists and activate relevant specialists based on conversation context.

### CLI Filtering by Domain

The `/skill list` command accepts a `--domain` parameter to filter the 66 skills by their assigned category. This enables developers to quickly discover tools relevant to their current technical stack.

```bash

# List all skills that belong to the "data-ml" domain

/skill list --domain data-ml

```

The plugin parses each skill's metadata and returns only those whose `domain` field matches the requested value, displaying skills such as Pandas Expert, Spark Specialist, or RAG Architect.

### Automatic Skill Activation

The domain system enables context-aware skill selection without explicit commands. When a user submits a request, the plugin analyzes the content for domain-specific keywords and automatically activates skills from the matching category.

```bash
User: "Help me design a GraphQL API with subscriptions."

# Claude matches the "api-architecture" domain and activates:

#   - GraphQL Architect

#   - WebSocket Engineer

#   - Fullstack Guardian (if UI is needed)

```

This automatic routing ensures that specialized expertise in **api-architecture**, **backend**, or **data-ml** is immediately available based on the technical context of the conversation.

## Key Files Supporting the Domain Architecture

The domain system is enforced and documented through several critical files in the repository. These files define the canonical domain list, validate skill metadata, and generate domain-based documentation.

| File | Role in the Domain System |
|------|---------------------------|
| **[[`CLAUDE.md`](https://github.com/Jeffallan/claude-skills/blob/main/CLAUDE.md)](https://github.com/Jeffallan/claude-skills/blob/main/CLAUDE.md)** | Defines the canonical list of 12 domains at lines 72‑73 and establishes the metadata schema used for validation. |
| **`skills/*/SKILL.md`** | Each skill's front-matter includes `metadata.domain` that must match one of the 12 canonical values. |
| **[`SKILLS_GUIDE.md`](https://github.com/Jeffallan/claude-skills/blob/main/SKILLS_GUIDE.md)** | Provides a navigable overview that groups the 66 skills by their assigned domain for easy discovery. |
| **[`ROADMAP.md`](https://github.com/Jeffallan/claude-skills/blob/main/ROADMAP.md)** | Documents the total skill count across the 12 domains and tracks domain coverage expansion. |
| **[`scripts/update-docs.py`](https://github.com/Jeffallan/claude-skills/blob/main/scripts/update-docs.py)** | Generates documentation from skill metadata, ensuring domain groupings remain synchronized with the canonical list. |

These files work together to maintain the integrity of the domain classification system across the entire plugin ecosystem.

## Summary

- The Claude-Skills plugin organizes its 66 specialized skills into **12 fixed domain categories** defined in [`CLAUDE.md`](https://github.com/Jeffallan/claude-skills/blob/main/CLAUDE.md).
- The domains cover the full software development lifecycle: **language**, **backend**, **frontend**, **infrastructure**, **api-architecture**, **quality**, **devops**, **security**, **data-ml**, **platform**, **specialized**, and **workflow**.
- Each skill declares its domain in the `metadata.domain` field of its [`SKILL.md`](https://github.com/Jeffallan/claude-skills/blob/main/SKILL.md) front-matter, enabling automatic routing and CLI filtering via commands like `/skill list --domain`.
- The domain system is enforced through the core configuration in [`CLAUDE.md`](https://github.com/Jeffallan/claude-skills/blob/main/CLAUDE.md) (lines 72‑73) and maintained by documentation generators in [`scripts/update-docs.py`](https://github.com/Jeffallan/claude-skills/blob/main/scripts/update-docs.py).

## Frequently Asked Questions

### Where are the 12 domains defined in the claude-skills repository?

The canonical list of 12 domains is explicitly defined in the [[`CLAUDE.md`](https://github.com/Jeffallan/claude-skills/blob/main/CLAUDE.md)](https://github.com/Jeffallan/claude-skills/blob/main/CLAUDE.md) file at lines 72‑73. This file serves as the central configuration that validates all skill metadata and ensures consistent domain assignment across the plugin's 66 skills.

### How do I assign a domain to a custom skill?

To assign a domain, add the `metadata.domain` field to your skill's YAML front-matter in its [`SKILL.md`](https://github.com/Jeffallan/claude-skills/blob/main/SKILL.md) file. The value must exactly match one of the 12 canonical domains listed in [`CLAUDE.md`](https://github.com/Jeffallan/claude-skills/blob/main/CLAUDE.md), such as `domain: backend` or `domain: data-ml`. This metadata enables the plugin to route requests to your skill when the corresponding domain is detected.

### Can a skill belong to multiple domains?

No, each skill must declare exactly one domain in its `metadata.domain` field. The plugin enforces a single-domain classification to ensure unambiguous routing and clear skill organization. If a skill spans multiple technical areas, it should select the primary domain that best represents its core expertise and use the `related-skills` field to link to complementary skills in other domains.

### How does the plugin use domains to select skills?

The plugin uses domains for both explicit CLI filtering and automatic request routing. When you run `/skill list --domain`, the plugin filters the 66 skills to show only those matching the specified domain. During conversations, the plugin analyzes your request for domain-specific keywords and automatically activates skills from the matching category, such as triggering **api-architecture** skills when you mention GraphQL or REST design.