> ## Documentation Index
> Fetch the complete documentation index at: https://agentic.proxify.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Composing a Skills Stack

> How to discover, install, and compose skills into a layered knowledge system for your project.

<Tip>**Official reference** — For how skills work under the hood, see the [official skills docs](https://code.claude.com/docs/en/skills). This page is about picking the right ones and making them work together.</Tip>

Skills are reusable knowledge packages that load on demand. A skills stack is the set you install for a project — chosen to match your tech stack and workflow. For why skills exist and how they fit into the broader instruction hierarchy, see [Context Distribution](/patterns/distribution).

## The Layered System

Your Claude Code knowledge lives in layers:

| Layer      | Purpose                  | Example                                        |
| ---------- | ------------------------ | ---------------------------------------------- |
| CLAUDE.md  | Project-specific context | "We use Prisma, run `npm test` for tests"      |
| Skills     | Domain patterns          | How to write Zod schemas, Tailwind conventions |
| References | Deep docs                | Full API guides, architecture specs            |

CLAUDE.md tells Claude *about your project*. Skills teach Claude *how to work in your domain*. Together they replace the need to explain things every session.

## Building Your Stack

Search for skills that match your tech stack, then install the ones that fit.

<Tabs>
  <Tab title="React / Next.js">
    ```bash theme={null}
    npx skills search nextjs
    npx skills search tailwind
    npx skills search react-query
    ```

    Good for: SPAs, Next.js apps, component libraries. Look for skills that cover component patterns, styling conventions, and data fetching.
  </Tab>

  <Tab title="Node.js API">
    ```bash theme={null}
    npx skills search zod
    npx skills search postgres
    npx skills search express
    ```

    Good for: Express/Fastify APIs, microservices, serverless functions. Add validation and database skills that match your stack.
  </Tab>

  <Tab title="Fullstack">
    Combine frontend and backend skills. They don't conflict — skills load only when triggered by relevant tasks. A Tailwind skill won't fire when you're writing a database migration.

    ```bash theme={null}
    # Frontend
    npx skills search nextjs
    npx skills search tailwind

    # Backend
    npx skills search zod
    npx skills search postgres
    ```
  </Tab>
</Tabs>

## Discovering Skills

```bash theme={null}
# Search by keyword
npx skills search <keyword>

# Browse the community directory
# https://skills.sh

# Install from any public GitHub repo
npx skills add owner/repo@skill-name
```

<Warning>**Vet before you install.** Skills are markdown files injected into Claude's system prompt — they control what the agent does. Always read the source before installing community skills. See [The Supply Chain](/patterns/supply-chain) for the trust model and what to look for.</Warning>

## Composing Skills That Work Together

Skills are independent by design — each triggers on its own conditions. But some combinations are particularly effective:

* **Testing skill + framework skill** — Test patterns that match your framework conventions
* **Validation skill (Zod) + API skill** — Input validation patterns that align with your API layer

## Writing Effective Descriptions

Skills have two loading phases. **Descriptions** are always in context — Claude loads every skill's `description` frontmatter at startup as a routing signal. **Bodies** load on demand — the full content only enters context when the task matches.

```yaml theme={null}
---
name: react-testing
description: React testing patterns. Use when writing tests, setting up test infrastructure, or debugging failing tests.
---

# 200 lines of framework, examples, and patterns
# None of this exists in context until triggered
```

This means description quality matters more than skill quality. A great skill with a vague description sits in your filesystem doing nothing. Write descriptions as "use when" rules, not documentation:

* **Bad:** "Testing things" — too vague, rarely triggers
* **Good:** "Use when writing tests, debugging failing test output, or setting up test infrastructure" — matches how people actually ask for help

Two frontmatter flags control invocation:

* **`disable-model-invocation: true`** — removes the description from context entirely. Claude doesn't know the skill exists. Use for side-effectful workflows you control: `/deploy`, `/commit`.
* **`user-invocable: false`** — keeps the description in context (Claude auto-triggers) but hides it from the `/` menu. Use for background knowledge that isn't a meaningful user command.

See the [official frontmatter reference](https://docs.anthropic.com/en/docs/claude-code/skills#frontmatter-reference) for the full list of fields.

## When to Create Your Own

Install existing skills when:

* A community skill covers your need
* The patterns are standard (React, Tailwind, etc.)

Create your own when:

* Your team has specific conventions not covered elsewhere
* You have internal libraries or frameworks
* You want to encode institutional knowledge (how *your team* does auth, deploys, etc.)

For the full workflow — scaffold, dev loop, and what to put in it — see [Make It Yours →](/setup/make-it-yours).