# Environment variables
Source: https://docs.aitmpl.com/cli/environment-variables

Environment variables that change what the claude-code-templates CLI does: tracking opt-outs, error reporting, debug output and the catalog URL.

| Variable | Default | Effect |
| - | - | - |
| `CCT_NO_TRACKING` | unset | `true` disables the anonymous download count sent on each install. |
| `CCT_NO_ANALYTICS` | unset | `true` does the same as `CCT_NO_TRACKING`. |
| `CI` | set by CI systems | `true` disables tracking too. |
| `CCT_ERROR_REPORTING` | unset | `true` sends crash reports to the project's Sentry. Off unless you set it, and always off when tracking is off. |
| `CCT_SENTRY_DSN` | the project's DSN | Send error reports to a different Sentry project (for testing). |
| `CCT_DEBUG` | unset | `true` prints debug output. |
| `CCT_CATALOG_URL` | `https://www.aitmpl.com/api/v1` | Where the catalog browser reads the catalog. The GitHub copy is the fallback. |

What a download count contains, and what it never contains, is on [Download tracking](/developers/download-tracking).


# CLI flags
Source: https://docs.aitmpl.com/cli/flags

Every flag of npx claude-code-templates, generated from the CLI's own --help.

```bash theme={null}
npx claude-code-templates@latest [flags]
```

With no flags, in a terminal, the CLI opens the catalog browser. Without a terminal it prints a short usage text and exits with code 0, so agents and CI never hang waiting for input.

| Flag | Description |
| - | - |
| `-V`, `--version` | output the version number |
| `-l`, `--language <language>` | specify programming language (deprecated, use `--template`) |
| `-f`, `--framework <framework>` | specify framework (deprecated, use `--template`) |
| `-t`, `--template <template>` | specify template (e.g., common, javascript-typescript, python, ruby) |
| `-d`, `--directory <directory>` | target directory (default: current directory) |
| `-y`, `--yes` | skip prompts and use defaults |
| `--dry-run` | show what would be copied without actually copying |
| `--analytics` | launch the local Claude Code analytics dashboard ([http://localhost:3333](http://localhost:3333)) |
| `--chats` | browse your Claude Code conversations in a local web UI ([http://localhost:9876](http://localhost:9876)) |
| `--verbose` | enable verbose logging for debugging and development |
| `--health-check`, `--health` | run comprehensive health check to verify Claude Code setup |
| `--agent <agent>` | install specific agent component (supports comma-separated values) |
| `--command <command>` | install specific command component (supports comma-separated values) |
| `--mcp <mcp>` | install specific MCP component (supports comma-separated values) |
| `--setting <setting>` | install specific setting component (supports comma-separated values) |
| `--hook <hook>` | install specific hook component (supports comma-separated values) |
| `--skill <skill>` | install specific skill component (supports comma-separated values) |
| `--loop <loop>` | install specific loop component and its referenced components (supports comma-separated values) |
| `--mod <mod>` | install specific Claude Mod (function-hooks plugin) as a local plugin (supports comma-separated values) |
| `--plugin <plugin>` | install a Claude Code plugin from the aitmpl marketplace with Claude Code itself, pinned to its reviewed commit (supports comma-separated values) |
| `--scope <scope>` | where `--plugin` enables the plugin: project (`.claude/settings.json`, default), user (`~/.claude/settings.json`) or local (`.claude/settings.local.json`) |
| `--workflow <workflow>` | install workflow from hash (#hash) OR workflow YAML (base64 encoded) when used with `--agent`/`--command`/`--mcp` |
| `--prompt <prompt>` | execute the provided prompt in Claude Code after installation |
| `-h`, `--help` | display help for command |

## Notes

* **Paths.** Every install flag takes `category/name`, the path shown on the component's page. Separate several with commas: `--agent security/security-auditor,development-team/backend-architect`.
* **Combining.** Install flags combine in one run: one plan, one location prompt for settings and hooks.
* **`--yes`.** Skips every prompt. Settings and hooks go to `.claude/settings.local.json`.
* **`--prompt`.** After installing, starts `claude` with that prompt as a single argument (never through a shell). Without a terminal it prints the command to run instead.
* **`--analytics`, `--chats`, `--health-check`.** Local tools, see [Local dashboards](/guides/local-dashboards).
* **Removed flags.** Seventeen flags were removed in 1.31.0 and now print their replacement. See [Removed in 1.31.0](/cli/removed-in-1-31).

This table is generated from `--help` by `docs-site/scripts/generate_snippets.py`, and CI fails when it falls behind the code. Check yours with `npx claude-code-templates@latest --version`.


# Removed in 1.31.0
Source: https://docs.aitmpl.com/cli/removed-in-1-31

Flags removed from the CLI in version 1.31.0 (2026-11-02), what replaced each one, and how to run the old version if you still need it.

Version 1.31.0 removed seventeen flags that saw little or no use (0 to 65 runs each in the 30 days before, against 16.8K npm downloads). Running one now prints what replaced it and exits with code 1.

| Removed flag | Use instead |
| - | - |
| `--plugins` | Run `/plugin` inside Claude Code, or install the stack viewer mod: `npx claude-code-templates@latest --mod ui/stack-viewer`, then `/stack` in Claude Code. |
| `--skills-manager` | Install the stack viewer mod: `npx claude-code-templates@latest --mod ui/stack-viewer`, then `/stack` in Claude Code. |
| `--command-stats` | Install the stack viewer mod: `npx claude-code-templates@latest --mod ui/stack-viewer`, then `/stack` in Claude Code. |
| `--commands-stats` | Install the stack viewer mod: `npx claude-code-templates@latest --mod ui/stack-viewer`, then `/stack` in Claude Code. |
| `--hook-stats` | Run `/hooks` inside Claude Code, or install the stack viewer mod: `npx claude-code-templates@latest --mod ui/stack-viewer`, then `/stack` in Claude Code. |
| `--hooks-stats` | Run `/hooks` inside Claude Code, or install the stack viewer mod: `npx claude-code-templates@latest --mod ui/stack-viewer`, then `/stack` in Claude Code. |
| `--mcp-stats` | Run `/mcp` inside Claude Code, or install the stack viewer mod: `npx claude-code-templates@latest --mod ui/stack-viewer`, then `/stack` in Claude Code. |
| `--mcps-stats` | Run `/mcp` inside Claude Code, or install the stack viewer mod: `npx claude-code-templates@latest --mod ui/stack-viewer`, then `/stack` in Claude Code. |
| `--agents` | Run `npx claude-code-templates@latest --analytics`: it is the same dashboard. |
| `--chats-mobile` | Run `npx claude-code-templates@latest --chats`. |
| `--teams` | No replacement. |
| `--2025` | No replacement. |
| `--tunnel` | The dashboards now listen on 127.0.0.1 only. To reach one from another machine, forward the port over SSH: `ssh -L 3333:localhost:3333 <host>` (9876 for `--chats`). |
| `--studio` | No replacement. |
| `--sandbox` | The sandbox launchers are still in the repository: [https://github.com/davila7/claude-code-templates/tree/main/cli-tool/components/sandbox](https://github.com/davila7/claude-code-templates/tree/main/cli-tool/components/sandbox) |
| `--create-agent` | Install the agent into Claude Code instead: `npx claude-code-templates@latest --agent <category/name>`. Global agents created before 1.31.0 keep working. |
| `--list-agents` | Global agents created with earlier versions are in `~/.claude-code-templates/agents/` and keep working. |
| `--remove-agent` | To delete a global agent by hand, remove `~/.claude-code-templates/bin/<name>` (or `/usr/local/bin/<name>`) and `~/.claude-code-templates/agents/<name>.md`. |
| `--update-agent` | Global agents created with earlier versions keep working as they are. For the latest version, install the agent into Claude Code: `npx claude-code-templates@latest --agent <category/name>`. |
| `--clone-session` | No replacement. |

## Still need one?

`npx claude-code-templates@1.30.0 <flag>` runs the last version that had them, with one exception: `--tunnel` published your conversation history on an unauthenticated public URL, which is why it was removed. Use SSH port forwarding instead.

Global agents created with `--create-agent` are standalone scripts and keep working without the CLI.

The sandbox launchers (E2B, Cloudflare, Docker) are no longer in the npm package, but their code is still in [`cli-tool/components/sandbox/`](https://github.com/davila7/claude-code-templates/tree/main/cli-tool/components/sandbox) as a reference.


# Agents
Source: https://docs.aitmpl.com/components/agents

Specialist subagents for Claude Code: what they are, where the CLI writes them and how Claude uses them.

An agent is a Markdown file with YAML frontmatter that defines a [Claude Code subagent](https://code.claude.com/docs/en/sub-agents): a specialist with its own system prompt, its own context window and, optionally, a restricted tool list. Claude delegates to it when a task matches its description, or when you ask for it by name.

```bash theme={null}
npx claude-code-templates@latest --agent security/security-auditor
```

Written to `.claude/agents/security-auditor.md`. It appears in `/agents` the next time Claude Code starts.

## Anatomy

```markdown .claude/agents/security-auditor.md theme={null}
---
name: security-auditor
description: Use this agent when conducting security audits, compliance assessments or risk evaluations…
tools: Read, Grep, Glob
---

You are a senior security auditor…
```

| Field | Meaning |
| - | - |
| `name` | How you and Claude refer to the agent. Matches the file name. |
| `description` | When Claude should delegate to it. Claude reads this to decide, so it matters most. |
| `tools` | Optional allowlist. Omit it to inherit every tool; list only read tools for a reviewer. |
| `model` | Optional: `sonnet`, `opus`, `haiku` or `inherit`. |

## Using it

* Let Claude choose: describe the task and Claude delegates when the description fits.
* Ask explicitly: "Use the security-auditor agent to review `src/auth`".
* Edit the file freely after install. It is yours.

## Popular agents

| Path | What it does |
| - | - |
| `development-team/frontend-developer` | Builds and reviews UI code |
| `development-team/backend-architect` | Designs APIs and services |
| `security/security-auditor` | Read-only security and compliance review |
| `development-tools/code-reviewer` | Reviews a diff for bugs and maintainability |

Browse all of them at [aitmpl.com/agents](https://www.aitmpl.com/agents/).


# Commands
Source: https://docs.aitmpl.com/components/commands

Custom slash commands for Claude Code: a saved prompt you run as /name, with optional arguments and tool permissions.

A command is a Markdown file that becomes a slash command. Typing `/generate-tests src/cart.ts` sends the file's body to Claude, with `$ARGUMENTS` replaced by what you typed after the name.

```bash theme={null}
npx claude-code-templates@latest --command testing/generate-tests
```

Written to `.claude/commands/generate-tests.md`, available as `/generate-tests`.

## Anatomy

```markdown .claude/commands/generate-tests.md theme={null}
---
allowed-tools: Read, Write, Edit, Bash
argument-hint: "[file-path] | [component-name]"
description: Generate a complete test file for a specified source file or component.
---

Generate tests for: $ARGUMENTS
…
```

| Field | Meaning |
| - | - |
| `description` | Shown in the `/` menu. |
| `argument-hint` | Shown after the command name while you type. |
| `allowed-tools` | Tools the command may use without asking. |

Project commands (`.claude/commands/`) are shared with anyone who clones the repository. To have a command in every project, move the file to `~/.claude/commands/`.

## Commands or skills?

Use a command when you decide when it runs. Use a [skill](/components/skills) when Claude should decide, based on the task. Claude Code also exposes skills in the `/` menu, so the line between them is mostly who triggers it.

Browse all commands at [aitmpl.com/commands](https://www.aitmpl.com/commands/).


# Hooks
Source: https://docs.aitmpl.com/components/hooks

Claude Code hooks: shell commands that run on events such as before a tool call or when Claude stops, installed into your settings.

A hook is a shell command Claude Code runs on an event: before or after a tool call, when you submit a prompt, when Claude stops, when it needs your attention. Unlike an instruction, a hook always runs, so it is the right tool for checks that must never be skipped.

```bash theme={null}
npx claude-code-templates@latest --hook automation/simple-notifications
```

The CLI asks which settings file to use (local, project, user or enterprise; local with `--yes`) and merges the hook into its `hooks` key. Hooks that need a script get it in `.claude/hooks/`.

## Anatomy

```json automation/simple-notifications.json theme={null}
{
  "description": "Send desktop notifications when Claude Code finishes working or needs user input.",
  "hooks": {
    "Stop": [
      { "hooks": [{ "type": "command", "command": "osascript -e 'display notification …'" }] }
    ],
    "Notification": [
      { "hooks": [{ "type": "command", "command": "osascript -e 'display notification …'" }] }
    ]
  }
}
```

The events, matchers and exit codes are Claude Code's own: see the [hooks reference](https://code.claude.com/docs/en/hooks). A `PreToolUse` hook that exits with code 2 blocks the tool call and shows its stderr to Claude.

## Before you install a hook

A hook runs with your permissions every time its event fires. Read the command on the component page, and prefer hooks that only read (linters, scanners, notifications) unless you trust the author.

Run `/hooks` in Claude Code to see every hook that is active and which file it came from.

Browse all hooks at [aitmpl.com/hooks](https://www.aitmpl.com/hooks/).


# Loops
Source: https://docs.aitmpl.com/components/loops

Autonomous Claude Code workflows with a goal, an interval and a stop condition, installed together with the agents and commands they use.

A loop is a recurring goal: Claude observes, plans, acts and verifies on an interval until a stop condition is true. A loop file describes the goal and lists the components it relies on.

```bash theme={null}
npx claude-code-templates@latest --loop engineering/docs-sweep-loop
```

Writes `.claude/loops/docs-sweep-loop.md` and installs every component in its `components` list.

## Anatomy

```markdown .claude/loops/docs-sweep-loop.md theme={null}
---
name: docs-sweep-loop
description: Keeps documentation aligned with the current codebase and opens a reviewable pull request on every pass.
interval: 30m
stop-condition: Every public API, command and config option is documented and the docs build passes with no warnings.
components: [agent:documentation/documentation-engineer, command:documentation/update-docs, command:git-workflow/create-pr]
---
```

## Running it

Each loop says how to start it. Most use Claude Code's `/loop` command:

```text theme={null}
/loop 30m "Compare the docs against the current code… Continue until docs and code fully agree."
```

A loop keeps spending tokens until its stop condition is met or you stop it. Start with a long interval and watch the first passes.

Browse all loops at [aitmpl.com/loops](https://www.aitmpl.com/loops/).


# MCP servers
Source: https://docs.aitmpl.com/components/mcps

Model Context Protocol servers for Claude Code: connect Claude to databases, GitHub, browsers and documentation through .mcp.json.

An MCP server gives Claude new tools backed by an external service: query a database, open GitHub issues, drive a browser, read current library docs. The catalog entry is the server's configuration.

```bash theme={null}
npx claude-code-templates@latest --mcp devtools/context7
```

Merged into `.mcp.json` at the project root. Servers already there are kept.

## Anatomy

```json database/supabase.json theme={null}
{
  "mcpServers": {
    "supabase": {
      "command": "npx",
      "args": ["-y", "@supabase/mcp-server-supabase@latest", "--read-only", "--project-ref=<project-ref>"],
      "env": { "SUPABASE_ACCESS_TOKEN": "<personal-access-token>" }
    }
  }
}
```

Values in angle brackets are placeholders. Replace them in `.mcp.json` after the install; the CLI never writes real keys. Keep tokens out of git: reference an environment variable (`"${SUPABASE_ACCESS_TOKEN}"`) and set it in your shell.

Some servers are remote (`"type": "http"` with a `url`) and sign you in with OAuth the first time you use them in Claude Code.

## After installing

Restart Claude Code and run `/mcp` to see the server, its status and its tools. Claude Code asks before it uses a project MCP server for the first time.

Browse all MCP servers at [aitmpl.com/mcps](https://www.aitmpl.com/mcps/).


# Mods
Source: https://docs.aitmpl.com/components/mods

Claude Mods: plugins that hook Claude Code's engine events to change its interface and behaviour. Installation, requirements, options and debugging.

A mod is a Claude Code plugin whose behaviour lives in a function-hooks module: TypeScript that registers middleware on engine events (`$.turn.step`, `$.tool.call`, `$.ui.render`…) to add a pane, a status line, a slash command, or to change a request before it is sent. Anthropic's reference is [anthropics/claude-code/mods](https://github.com/anthropics/claude-code/tree/main/mods) and the [mods documentation](https://code.claude.com/docs/en/plugins/mods/overview).

```bash theme={null}
npx claude-code-templates@latest --mod ui/stack-viewer
```

Writes the complete plugin to `.claude/skills/stack-viewer/`, which Claude Code loads as `stack-viewer@skills-dir`. Then run `/stack` in Claude Code.

## Requirements

| Claude Code | Mods |
| - | - |
| 2.1.287 or newer | On by default |
| 2.1.259 to 2.1.286 | Set `CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1` |
| Older | Not supported |

The `$` API can change between Claude Code releases. Every mod in the catalog is type-checked against the current API in CI, and its README states the minimum version it was tested on.

> [!WARNING]
>
> A mod in a project's `.claude/skills/` loads only after you accept the trust prompt for that folder. `claude -p` never shows the prompt, so a headless run in a fresh folder will not load it. Open `claude` once in the folder, or install to `~/.claude/skills/`, which always loads.

## Options

Options are declared in the mod's `.claude-plugin/plugin.json` (`userConfig`) and read from your **user** or managed settings, never from project settings:

```json ~/.claude/settings.json theme={null}
{
  "pluginConfigs": {
    "stack-viewer@skills-dir": { "options": { } }
  }
}
```

The key is the plugin's full id: `<name>@skills-dir` when it is auto-loaded from `.claude/skills/`, plain `<name>` when you load it with `--plugin-dir`.

## A mod that seems silent

Check these before suspecting the mod's code:

1. **Untrusted project.** See the warning above.
2. **Wrong place to look.** `$.ui.log` writes a dim transcript line; in `claude -p` there is no transcript, so look in `~/.claude/debug/<session-id>.txt`. A mod that rewrites the model or effort changes each request, not the header or status line.
3. **Options under the wrong key.** The debug log says `no pluginConfigs["<name>@skills-dir"].options` when it finds none.
4. **Function hooks off** on Claude Code below 2.1.287.

`claude --debug` shows `hooks module <name>@skills-dir loaded … events: …` when the mod is running.

Browse all mods at [aitmpl.com/mods](https://www.aitmpl.com/mods/). To write one, see [Building a mod](/contributing/mods).


# Component types
Source: https://docs.aitmpl.com/components/overview

The ten kinds of component in the catalog, what each one changes in Claude Code, and how to choose between them.

Every component is one or more plain files with a path of the form `type/category/name`. You install it with the flag of its type and its `category/name`.

| Type | Count | What it is |
| - | - | - |
| [Agents](/components/agents) | 422 | Specialist subagents Claude can delegate to |
| [Commands](/components/commands) | 288 | Slash commands for repeatable workflows |
| [Skills](/components/skills) | 918 | Folders of instructions and scripts Claude loads when relevant |
| [Hooks](/components/hooks) | 63 | Shell commands that run on Claude Code events |
| [MCP servers](/components/mcps) | 119 | Connections to external tools and services |
| [Settings](/components/settings) | 80 | Permissions, status lines, models and other configuration |
| [Loops](/components/loops) | 18 | Recurring goals with an interval and a stop condition |
| [Mods](/components/mods) | 50 | Plugins that change Claude Code's interface and behaviour |
| [Plugins](/components/plugins) | 2 | Complete Claude Code plugins from the aitmpl marketplace |
| [Templates](/components/templates) | 14 | A CLAUDE.md starting point per language |

## Which type do I need?

| You want Claude to… | Use |
| - | - |
| Hand a task to a specialist with its own context and tool list | [Agent](/components/agents) |
| Run the same prompt whenever you type `/something` | [Command](/components/commands) |
| Know how to do something, loaded only when the task calls for it | [Skill](/components/skills) |
| Always run a check or script when an event happens (before a tool, at the end of a turn) | [Hook](/components/hooks) |
| Reach an external service: a database, GitHub, a browser, docs | [MCP server](/components/mcps) |
| Behave differently by default: permissions, model, status line | [Setting](/components/settings) |
| Keep working towards a goal on an interval until a condition is true | [Loop](/components/loops) |
| Change Claude Code's own interface or request handling | [Mod](/components/mods) |
| Get a complete, multi-part plugin from its author | [Plugin](/components/plugins) |
| Start a project with a `CLAUDE.md` for its language | [Template](/components/templates) |

Hooks and skills are often confused. A skill is advice Claude may follow; a hook is code that always runs. If something must happen every time, use a hook.

## Before you install

Components that run code (hooks, MCP servers, status lines, mods) run with your user's permissions. Read the files on the component page first: every page shows the exact files the CLI will write and the [SkillSpector](/guides/security) scan of them.


# Plugins
Source: https://docs.aitmpl.com/components/plugins

Complete Claude Code plugins from the aitmpl marketplace, installed and managed by Claude Code itself and pinned to the reviewed commit.

Some components are whole Claude Code plugins: commands, agents, skills and hooks that reference each other and must stay together. The catalog publishes them as a Claude Code marketplace named `aitmpl`, at `https://www.aitmpl.com/marketplace.json`. Each entry points at the author's repository, pinned to the commit that was reviewed and scanned.

```bash theme={null}
npx claude-code-templates@latest --plugin productivity/champion-kit
```

The CLI asks Claude Code to do the install (`claude plugin marketplace add` and `claude plugin install champion-kit@aitmpl`), so the files land in `~/.claude/plugins/cache/aitmpl/` and you manage the plugin with `/plugin` like any other. If `claude` is not on your PATH, the CLI writes the same two settings keys (the marketplace and the enabled plugin) instead, and Claude Code offers to install the plugin the next time it starts in that folder.

## Scope

| `--scope` | Enabled in |
| - | - |
| `project` (default) | `.claude/settings.json` |
| `user` | `~/.claude/settings.json` |
| `local` | `.claude/settings.local.json` |

## Without the CLI

Add the marketplace in Claude Code directly:

```text theme={null}
/plugin marketplace add https://www.aitmpl.com/marketplace.json
/plugin install champion-kit@aitmpl
```

Browse plugins at [aitmpl.com](https://www.aitmpl.com).


# Settings
Source: https://docs.aitmpl.com/components/settings

Ready-made Claude Code settings: permissions, status lines, models, cleanup and themes, merged into the settings file you choose.

A setting is a fragment of Claude Code's `settings.json`. Installing it merges that fragment into the file you choose, so you can combine several.

```bash theme={null}
npx claude-code-templates@latest --setting permissions/read-only-mode
```

The CLI asks for the scope (local, project, user or enterprise; local with `--yes`). See [Settings scope](/installation#settings-scope).

## Categories

| Category | Examples |
| - | - |
| `permissions` | `read-only-mode`, allow and deny lists |
| `statusline` | `context-monitor`: a status line with context usage, cost and duration |
| `model` | Default model and effort |
| `cleanup` | `retention-7-days`: how long transcripts are kept |
| `environment`, `telemetry`, `authentication`, `api` | Environment variables and provider options |
| `appearance` | Themes |

## Status lines with scripts

Some status lines run a script:

```json statusline/context-monitor.json theme={null}
{
  "statusLine": { "type": "command", "command": "python3 .claude/scripts/context-monitor.py" }
}
```

The CLI downloads the script next to it, into `.claude/scripts/`, and makes it executable. The relative path resolves from the project root, so start Claude Code there.

## Themes

A setting can ship a custom theme. Claude Code only reads themes from `~/.claude/themes/`, so the CLI writes theme files there whatever scope you chose for the rest.

Browse all settings at [aitmpl.com/settings](https://www.aitmpl.com/settings/).


# Skills
Source: https://docs.aitmpl.com/components/skills

Agent Skills for Claude Code: folders with a SKILL.md that Claude loads when a task calls for them, including skills installed from their author's repository.

A skill is a folder with a `SKILL.md` and, optionally, scripts, references and templates. Claude sees only each skill's name and description until a task matches; then it reads the whole `SKILL.md` and follows it. That keeps hundreds of skills cheap to have installed.

```bash theme={null}
npx claude-code-templates@latest --skill development/systematic-debugging
```

Written to `.claude/skills/systematic-debugging/`, every file of the folder included.

## Anatomy

```markdown .claude/skills/systematic-debugging/SKILL.md theme={null}
---
name: systematic-debugging
description: You MUST use this whenever something is broken, before proposing or making any fix…
license: MIT
---

# Systematic debugging
…
```

The `description` decides when the skill is used, so good skills say both what they do and when to use them. The format follows the open [Agent Skills specification](https://agentskills.io).

## Skills from their author's repository

Some skills are not copied into this repository. Their catalog folder holds only a `source.json` that points at the author's repo, pinned to a full commit:

```json source.json theme={null}
{
  "repo": "t3dotgg/tstack",
  "path": "skills/babysit-pr",
  "commit": "7de017b3fc9d50c03cf3ecb98fb71e0ca65a78bd",
  "license": "MIT",
  "author": "Theo Browne",
  "requires": ["git/leaving-pr-comments"]
}
```

You install them the same way (`--skill git/babysit-pr`). The CLI downloads the files at that exact commit, checks each one against its git blob hash, and installs the skills listed in `requires` too. An upstream change reaches you only after a pull request here moves the pinned commit, so what you get is what was reviewed and scanned. How to add one: [External skills](/contributing/external-skills).

## Security

Skills can ship scripts that Claude will run. Every skill in the catalog is scanned by [NVIDIA SkillSpector](/guides/security), and a pull request that adds a high-risk skill is blocked. Read the files on the component page before installing.

Browse all skills at [aitmpl.com/skills](https://www.aitmpl.com/skills/).


# Templates
Source: https://docs.aitmpl.com/components/templates

Project templates that write a CLAUDE.md with conventions and commands for your language and framework.

A template is a starting `CLAUDE.md`, the file Claude Code reads at the start of every session, written for a language and, optionally, a framework.

```bash theme={null}
npx claude-code-templates@latest --template python
```

With `--yes` and no `--template`, the CLI uses the language it detects in the project, or `common`. Available languages: `common` (language-agnostic), `javascript-typescript` (React, Vue.js, Angular, Node.js), `python` (Django, Flask, FastAPI), `ruby` (Rails 8, Sinatra), `rust` and `go`.

A template is a starting point. Edit `CLAUDE.md` with your project's real commands, structure and rules; a short, accurate file beats a long generic one.

`--language` and `--framework` still work but are deprecated in favour of `--template`.


# Add a component
Source: https://docs.aitmpl.com/contributing/adding-components

Contribute an agent, command, skill, hook, MCP server, setting, loop or mod to the catalog: file layout, rules, checks and review.

Components live in [`cli-tool/components/`](https://github.com/davila7/claude-code-templates/tree/main/cli-tool/components) as `{type}/{category}/{name}`. Fork the repository, add yours, and open a pull request.

## Where each type goes

| Type | Path | Required |
| - | - | - |
| Agent | `agents/{category}/{name}.md` | frontmatter `name`, `description` |
| Command | `commands/{category}/{name}.md` | frontmatter `description` |
| Skill | `skills/{category}/{name}/SKILL.md` | frontmatter `name` (= folder), `description` |
| Hook | `hooks/{category}/{name}.json` | `description`, `hooks`; scripts next to it with the same name |
| MCP server | `mcps/{category}/{name}.json` | `mcpServers`, placeholders instead of keys |
| Setting | `settings/{category}/{name}.json` | `description` and the settings keys |
| Loop | `loops/{category}/{name}.md` | `interval`, `stop-condition`, `components` that already exist |
| Mod | `mods/{category}/{name}/` | see [Build a mod](/contributing/mods) |

Names are kebab-case and match the file or folder name. Pick an existing category when one fits.

## Rules

* **Only commit your component.** Never run `scripts/generate_components_json.py` or commit `docs/components.json` or anything under `dashboard/public/`. They are regenerated after merge, and the `generated-files-guard` check fails a pull request that touches them.
* **No secrets.** API keys go in placeholders (`<your-api-key>`) or environment variables, never in the file.
* **Relative paths only.** Use `.claude/hooks/`, `.claude/scripts/`; never a home directory or absolute path.
* **One component, or one small related set, per pull request.**
* **A clear `description`** that says what it does and when to use it. Claude reads it to decide.

## Test it before opening the PR

The CLI installs from `main`, so it cannot install your branch yet. Copy the files where Claude Code reads them and try them in a real session: an agent into `.claude/agents/`, a skill folder into `.claude/skills/`, a hook into `.claude/settings.local.json`. Then run Claude Code's validator on it:

```bash theme={null}
python3 scripts/validate_components.py --changed cli-tool/components/agents/security/my-agent.md
```

## What reviews your pull request

| Check | Blocks merge? |
| - | - |
| `claude plugin validate` on the changed components | Yes, on errors |
| SkillSpector on changed skills | Yes, when the score is above 50 |
| SkillSpector on other types | No, reported as a comment |
| Mods type check | Yes |
| AI review, then a maintainer | Yes |

Hooks with scripts, mods and anything that runs code or sends data off the machine always get a maintainer's manual review.

Sponsored placements on aitmpl.com never change review, ranking or search.


# Edit these docs
Source: https://docs.aitmpl.com/contributing/docs

How docs.aitmpl.com is built: the docs-site folder of the repository, local preview, generated snippets and the checks that keep it in sync with the CLI.

These docs are the [`docs-site/`](https://github.com/davila7/claude-code-templates/tree/main/docs-site) folder of the main repository, published by Mintlify on every push to `main`. Change them in the same pull request as the code they describe.

## Preview locally

```bash theme={null}
cd docs-site
npx mint dev            # http://localhost:3000
npx mint broken-links   # check internal links
```

## Generated snippets

Three tables come from the code and must not be edited by hand:

| Snippet | Source |
| - | - |
| `snippets/component-counts.mdx` | `dashboard/public/counts.json` |
| `snippets/cli-flags.mdx` | the CLI's `--help` |
| `snippets/removed-flags.mdx` | `cli-tool/src/removed-commands.js` |

Regenerate them after changing the CLI or the catalog:

```bash theme={null}
(cd cli-tool && npm ci)
python3 docs-site/scripts/generate_snippets.py
```

## Rules

* Every install example uses a real `category/name` path. CI checks each one against `cli-tool/components/`.
* Do not document a flag the CLI no longer has; link to [Removed in 1.31.0](/cli/removed-in-1-31) instead.
* Lead each page with what the reader can do, then the details. Short sentences, no marketing.
* Keep the colors, logo and fonts in `docs.json` and `style.css` in line with aitmpl.com (`dashboard/src/styles/global.css`).


# List a skill from your repository
Source: https://docs.aitmpl.com/contributing/external-skills

Add a skill or plugin to the catalog without copying it: a source.json pinned to a commit of your own GitHub repository.

If your skill lives in your own repository, you can list it instead of copying it. Its catalog folder holds only a `source.json`, and the CLI downloads the files from your repository at the pinned commit.

```bash theme={null}
python3 scripts/external_skills.py add OWNER/REPO path/to/skill CATEGORY [--requires category/name ...] [--author NAME]
```

The script resolves your repository's current commit, checks the license and writes `cli-tool/components/skills/{category}/{name}/source.json`:

| Field | Required | Meaning |
| - | - | - |
| `repo` | yes | `owner/name` on GitHub |
| `path` | yes | Folder of the skill inside the repository |
| `commit` | yes | Full 40-character sha. Never a branch or tag |
| `license` | yes | SPDX id; must match the repository's LICENSE at that commit |
| `author` | no | Shown on aitmpl.com |
| `requires` | no | Other catalog skills to install with it |
| `include` | no | Files or folders under `path` to keep, when the folder also holds demos or tests. Must list `SKILL.md` |

Limits after filtering: 200 files and 5 MB.

## Updating

A new commit in your repository does not reach users on its own. Open a pull request that moves `commit`. A weekly job opens an issue listing skills whose upstream has newer commits.

## Whole plugins

A `source.json` can also point at a complete Claude Code plugin (a folder with `.claude-plugin/plugin.json`). Those live under `cli-tool/components/plugins/` and are published in the `aitmpl` marketplace. See [Plugins](/components/plugins).


# Build a mod
Source: https://docs.aitmpl.com/contributing/mods

Contribute a Claude Mod: plugin layout, the engine rules every module must follow, type checking, validation and testing on the oldest supported Claude Code.

A mod is a complete plugin directory in Anthropic's `mods/` layout. Read Anthropic's [mods overview](https://code.claude.com/docs/en/plugins/mods/overview) and the three reference mods in [anthropics/claude-code/mods](https://github.com/anthropics/claude-code/tree/main/mods) first.

## Layout

```text theme={null}
cli-tool/components/mods/{category}/{name}/
├── .claude-plugin/plugin.json   name (= folder), description, license, author, userConfig
├── hooks/hooks.json             { "modules": ["register.ts"] }
├── hooks/register.ts            export default function register(on, options) { … }
├── commands/*.md                optional slash commands
├── tests/                       optional, run by `claude plugin test`
└── README.md                    shown on aitmpl.com
```

Names starting with `claude-`, `anthropic-` or `cc-plugin-` are reserved by Claude Code.

## Engine rules

* Import types only from `'claude-code'`; use relative imports for your own files.
* Write `$` as `$.noun.event(...)` at the call site. Never pass `$` to a helper.
* Treat the event `e` as frozen.
* To block something, return `{ deny }` without calling `next`. Returning `{}` lets it through.
* Options come from `plugin.json` `userConfig` and are read from user or managed settings, never project settings. Lists are comma-separated strings.
* No secrets in code, no absolute paths, no `$.process.run` through a shell.

## Before the pull request

```bash theme={null}
cd cli-tool/components/mods
npx -y -p typescript@5 tsc -p tsconfig.json   # must type-check against types/claude-code.d.ts
claude plugin validate {category}/{name}
claude plugin test {category}/{name}          # if the mod ships tests
```

Type-checking against the current API does not prove an older Claude Code draws your mod. Test a pane on the oldest supported engine too:

```bash theme={null}
npm i @anthropic-ai/claude-code@2.1.287   # in a scratch folder
# then, from cli-tool/components/mods:
npx claude plugin test {category}/{name}
```

The README must state the command, the options, the minimum Claude Code version and, for vendored code, the license and attribution.


# Use these docs with AI tools
Source: https://docs.aitmpl.com/developers/ai-tools

Give Claude Code or another agent these docs and the catalog: the docs MCP server, llms.txt files and Markdown pages.

## Docs MCP server

These docs are available as an MCP server, so Claude Code can search them while it works:

```bash theme={null}
claude mcp add --transport http aitmpl-docs https://docs.aitmpl.com/mcp
```

Every page also has a menu (top right) to copy it as Markdown or open it in Claude, ChatGPT, Cursor or VS Code.

## llms.txt

| URL | What |
| - | - |
| [docs.aitmpl.com/llms.txt](https://docs.aitmpl.com/llms.txt) | Index of these docs |
| [docs.aitmpl.com/llms-full.txt](https://docs.aitmpl.com/llms-full.txt) | All of these docs in one file |
| [aitmpl.com/llms.txt](https://www.aitmpl.com/llms.txt) | The catalog site, its API and how to install |

Add `.md` to any docs URL to get the page as Markdown, for example `https://docs.aitmpl.com/quickstart.md`.

## For agents installing components

Run the CLI with explicit paths and `--yes`, so it never waits for input:

```bash theme={null}
npx claude-code-templates@latest --skill development/systematic-debugging --yes
```

Find paths in the [Catalog API](/developers/catalog-api): each component carries its exact `install.command`.


# Catalog API
Source: https://docs.aitmpl.com/developers/catalog-api

Read the whole aitmpl.com catalog as versioned JSON: every component with its install command, files and scan result.

The catalog is published as static JSON under `https://www.aitmpl.com/api/v1/`. No key, no rate limit beyond normal CDN caching. The full reference and stability policy live at [aitmpl.com/developers/catalog-api](https://www.aitmpl.com/developers/catalog-api); this page is the short version.

| File | Contents |
| - | - |
| [`catalog.json`](https://www.aitmpl.com/api/v1/catalog.json) | Every component |
| `catalog/{type}.json` | One type: `agents`, `commands`, `mcps`, `settings`, `hooks`, `skills`, `loops`, `mods` |
| [`version.json`](https://www.aitmpl.com/api/v1/version.json) | `schemaVersion`, `generatedAt`, `sha256`, counts. Poll this, then fetch the catalog only when `sha256` changes |
| [`schema.json`](https://www.aitmpl.com/api/v1/schema.json) | JSON Schema (draft 2020-12) for all of the above |

## A component

```json theme={null}
{
  "id": "agents/accessibility/accessibility-tester",
  "type": "agents",
  "name": "accessibility-tester",
  "category": "accessibility",
  "install": {
    "command": "npx claude-code-templates@latest --agent accessibility/accessibility-tester",
    "args": ["--agent", "accessibility/accessibility-tester"]
  },
  "urls": {
    "page": "https://www.aitmpl.com/component/agents/accessibility/accessibility-tester",
    "source": "https://github.com/davila7/claude-code-templates/blob/main/cli-tool/components/agents/accessibility/accessibility-tester.md"
  }
}
```

Other fields: `path`, `description`, `author`, `repo`, `version`, `license`, `keywords`, `downloads`, `files`, `scan` (the SkillSpector result) and `source` (the pinned repository of an external skill, otherwise `null`).

## Stability

* Within v1 every change is additive: fields are added, never removed or renamed.
* A breaking change ships at `/api/v2/`, and v1 stays published for at least six months.
* Components are ordered by `id`. Sponsored placements are never part of this API.
* Every format change is recorded in the [Catalog API changelog](https://github.com/davila7/claude-code-templates/blob/main/docs/catalog-api/CHANGELOG.md).


# Download tracking
Source: https://docs.aitmpl.com/developers/download-tracking

What the CLI sends when you install a component, what the server stores, how the counts are used and how to turn it off.

Each install sends one anonymous request so the catalog can show download counts and trending components. Turn it off with `CCT_NO_TRACKING=true` (or `CCT_NO_ANALYTICS=true`). Runs with `CI=true` are never tracked.

## What the CLI sends

Up to three small requests per run, all to `www.aitmpl.com`:

| Request | Fields |
| - | - |
| Download (`/api/track-download-supabase`), one per component | type, name, category, CLI version; the install folder relative to where you ran the CLI when you pass `--directory`; and, from CLI 1.32.0, the three client signals below |
| Install outcome (`/api/track-installation-outcome`) | type, name, success or failure, error type and message, duration, CLI and Node.js versions, OS, architecture |
| Command usage (`/api/track-command-usage`) | which CLI command ran (for example `--analytics`), CLI and Node.js versions, OS, architecture, a random id for that run |

Client signals:

| Signal | Example |
| - | - |
| AI agent that ran the CLI | `claude`, `cursor`, or none |
| How Claude Code was started | the value of `CLAUDE_CODE_ENTRYPOINT`, such as `cli` |
| Whether output was a terminal | `true` / `false` |

The agent signal is read from environment markers that tools set themselves (`AI_AGENT`, `CLAUDECODE` and similar). It is self-reported and used only for the "Agents vs humans" statistic on [aitmpl.com/trending](https://www.aitmpl.com/trending#agents).

The CLI never sends file contents, your account email, account id or Claude Code session id. An install error message can include a file path from your machine; set `CCT_NO_TRACKING=true` if that matters to you.

## What the server stores

With each download, the endpoint also stores the request's IP address, country and user agent, as received by Cloudflare. They are used to count unique installs and filter bulk traffic. Counts are public on each component page; individual rows are not.

The endpoint is `POST https://www.aitmpl.com/api/track-download-supabase`. Its source is in [`dashboard/src/pages/api/track-download-supabase.ts`](https://github.com/davila7/claude-code-templates/blob/main/dashboard/src/pages/api/track-download-supabase.ts).


# Local dashboards and health check
Source: https://docs.aitmpl.com/guides/local-dashboards

Analytics, a conversation browser and a setup health check for Claude Code, run locally by the CLI.

These tools read the Claude Code data on your own machine (`~/.claude/projects`) and never upload it.

## Analytics

```bash theme={null}
npx claude-code-templates@latest --analytics
```

Opens `http://localhost:3333`: sessions, token usage, and activity over time.

## Conversation browser

```bash theme={null}
npx claude-code-templates@latest --chats
```

Opens `http://localhost:9876` to read and search past conversations.

Both servers listen on 127.0.0.1 only and reject requests from other sites (foreign `Host` or `Origin` headers), so another web page cannot read your history. To open one from another machine, forward the port over SSH:

```bash theme={null}
ssh -L 3333:localhost:3333 your-server
```

## Health check

```bash theme={null}
npx claude-code-templates@latest --health-check
```

Checks your Node.js version (18+), the Claude Code install and authentication, and your settings files, and prints what to fix.


# How components are checked
Source: https://docs.aitmpl.com/guides/security

What happens to every component before it reaches the catalog: Claude Code's plugin validator, NVIDIA SkillSpector scans and review, and how to report a problem.

Hooks, MCP servers, status lines, mods and skill scripts run code with your permissions. These are the checks every component goes through before it appears on aitmpl.com.

| Check | What it does | When |
| - | - | - |
| `claude plugin validate` | Claude Code's own validator on the component's format | Every pull request; the whole catalog weekly |
| [NVIDIA SkillSpector](https://github.com/NVIDIA/skillspector) | Static analysis with 64 patterns: prompt injection, data exfiltration, dangerous code, supply chain | Every pull request; results shown on each component page |
| Mods type check | Every mod module must type-check against Claude Code's API | Every pull request |
| Review | Automated review plus a maintainer | Every pull request |

A pull request that adds or changes a skill with a SkillSpector score above 50 (high or critical) is blocked until it is fixed. For other types the scan is reported on the pull request without blocking, because it raises more false positives there.

Each component page shows a "Scanned by NVIDIA SkillSpector" seal and the scan's findings. The scan is information, not a verdict: read the files before you install, especially for anything that runs commands.

External skills and plugins are pinned to a full commit, so the code you install is the code that was scanned.

## Report a problem

Found a malicious or unsafe component, or a vulnerability in the CLI? Follow [SECURITY.md](https://github.com/davila7/claude-code-templates/blob/main/SECURITY.md) and report it privately. Please do not open a public issue for a vulnerability.


# Install a stack
Source: https://docs.aitmpl.com/guides/stacks

Set up a project in one command: combine agents, commands, skills, MCP servers, settings and hooks, from the aitmpl.com stack builder or by hand.

A stack is several components installed in one run. The CLI shows one plan, asks once where settings and hooks go, and reports each result.

## From aitmpl.com

1. Open [aitmpl.com](https://www.aitmpl.com) and add components to your stack with the **+** button on each card.
2. Open the stack panel and copy the generated command.
3. Run it in your project.

## By hand

```bash theme={null}
npx claude-code-templates@latest \
  --agent development-team/backend-architect,security/security-auditor \
  --command testing/generate-tests,security/security-audit \
  --skill development/test-driven-development \
  --mcp database/supabase \
  --setting statusline/context-monitor \
  --hook security/secret-scanner
```

Add `--dry-run` to see the files first, and `--yes` for a run without prompts (CI, scripts, agents).

## Ideas

| Goal | Stack |
| - | - |
| Safer reviews | `--agent security/security-auditor --command security/security-audit --hook security/secret-scanner --setting permissions/read-only-mode` |
| Test-first work | `--skill development/test-driven-development,development/systematic-debugging --command testing/generate-tests` |
| Better context | `--mcp devtools/context7 --setting statusline/context-monitor` |

## Install, then prompt

`--prompt` starts Claude Code with a prompt once the install finishes:

```bash theme={null}
npx claude-code-templates@latest --agent security/security-auditor \
  --prompt "Use the security-auditor agent to review this repository"
```


# Installation and file locations
Source: https://docs.aitmpl.com/installation

Where the CLI writes each component type, which scope it uses, and how it merges into existing Claude Code configuration.

The CLI writes into the current folder unless you pass `--directory <path>`. It never deletes your files: JSON configuration is merged key by key, and Markdown components are written next to the ones you already have.

## Where each type goes

| Type | Flag | Written to |
| - | - | - |
| Agent | `--agent` | `.claude/agents/<name>.md` |
| Command | `--command` | `.claude/commands/<name>.md` |
| Skill | `--skill` | `.claude/skills/<name>/` (the whole folder) |
| Hook | `--hook` | merged into the `hooks` key of the settings file you choose; scripts go to `.claude/hooks/` |
| MCP server | `--mcp` | merged into `.mcp.json` |
| Setting | `--setting` | merged into the settings file you choose; status line scripts go to `.claude/scripts/` |
| Loop | `--loop` | `.claude/loops/<name>.md`, plus every component the loop lists |
| Mod | `--mod` | `.claude/skills/<name>/` (a complete plugin directory) |
| Plugin | `--plugin` | installed by Claude Code itself into `~/.claude/plugins/cache/aitmpl/` |
| Template | `--template` | `CLAUDE.md` and starter files in the project |

## Settings scope

Settings and hooks ask where to go. With `--yes`, or when there is no terminal to ask, they go to **local**.

| Scope | File | Use it for |
| - | - | - |
| Local (default) | `.claude/settings.local.json` | Personal settings, not committed |
| Project | `.claude/settings.json` | Settings the whole team shares |
| User | `~/.claude/settings.json` | Every project on your machine |
| Enterprise | `managed-settings.json` in the system folder | Organisation policy; needs admin rights |

Claude Code reads custom themes only from `~/.claude/themes/`, so a setting that ships a theme writes it there whatever scope you pick.

## Preview before writing

```bash theme={null}
npx claude-code-templates@latest --agent security/security-auditor --dry-run
```

`--dry-run` lists every file the install would write and changes nothing.

## Updating a component

Run the same install command again. The CLI downloads the current version from `main` and replaces the file. Your own edits to that file are overwritten, so commit them first or keep them under a different name.


# Claude Code Templates
Source: https://docs.aitmpl.com/introduction

An open catalog of Claude Code components and the CLI that installs them: agents, commands, skills, hooks, MCP servers, settings, loops, mods and plugins.

Claude Code is configured through small files: an agent is a Markdown file, a hook is a few lines of JSON, a skill is a folder with a `SKILL.md`. Claude Code Templates collects the good ones in one catalog at [aitmpl.com](https://www.aitmpl.com) and installs them into your project with one command.

```bash theme={null}
npx claude-code-templates@latest --agent development-team/frontend-developer
```

Every component is a plain file you can read before installing and edit afterwards. Nothing is hidden in a binary.

> [card] [Quickstart](/quickstart)
>
> Install your first component in two minutes.

> [card] [Browse the catalog](https://www.aitmpl.com)
>
> Search every component, preview its files and build a stack.

> [card] [Component types](/components/overview)
>
> What each type does and where it is written.

> [card] [CLI flags](/cli/flags)
>
> Every flag of `claude-code-templates`.

## What you can install

| Type | Count | What it is |
| - | - | - |
| [Agents](/components/agents) | 422 | Specialist subagents Claude can delegate to |
| [Commands](/components/commands) | 288 | Slash commands for repeatable workflows |
| [Skills](/components/skills) | 918 | Folders of instructions and scripts Claude loads when relevant |
| [Hooks](/components/hooks) | 63 | Shell commands that run on Claude Code events |
| [MCP servers](/components/mcps) | 119 | Connections to external tools and services |
| [Settings](/components/settings) | 80 | Permissions, status lines, models and other configuration |
| [Loops](/components/loops) | 18 | Recurring goals with an interval and a stop condition |
| [Mods](/components/mods) | 50 | Plugins that change Claude Code's interface and behaviour |
| [Plugins](/components/plugins) | 2 | Complete Claude Code plugins from the aitmpl marketplace |
| [Templates](/components/templates) | 14 | A CLAUDE.md starting point per language |

## How it fits together

1. **The catalog** lives in [`cli-tool/components/`](https://github.com/davila7/claude-code-templates/tree/main/cli-tool/components) on GitHub. Every pull request is checked by Claude Code's own plugin validator and scanned by [NVIDIA SkillSpector](https://github.com/NVIDIA/skillspector) before merge.
2. **aitmpl.com** renders that catalog: search, file previews, security scan results and a stack builder that produces one install command.
3. **The CLI** (`npx claude-code-templates`) downloads the files you ask for and writes them where Claude Code reads them, merging into existing configuration instead of overwriting it.

The project is open source (MIT), maintained by [Daniel Avila](https://github.com/davila7) and contributors, and listed in Anthropic's Claude Code documentation.


# Quickstart
Source: https://docs.aitmpl.com/quickstart

Install your first Claude Code component in two minutes, from the catalog browser or with one command.

You need Node.js 18 or newer (the CLI uses the built-in `fetch`) and Claude Code. Nothing is installed globally: `npx` runs the latest CLI each time.

**1. Open the catalog browser**

Run the CLI with no arguments, from the root of your project:

```bash theme={null}
npx claude-code-templates@latest
```

Pick a type, search, select one or more components (across types too), then confirm the install plan. Without a terminal (an AI agent, CI, a pipe) it prints a short usage text and exits instead of waiting for input.

**2. Or install by path**

Every component has a path, `category/name`, shown on its page at [aitmpl.com](https://www.aitmpl.com):

```bash theme={null}
npx claude-code-templates@latest --agent development-team/frontend-developer
```

Always pass the category. A bare name such as `frontend-developer`, without its category, is not found.

**3. Use it in Claude Code**

Start `claude` in the same folder. An agent shows up in `/agents`, a command as `/name`, an MCP server in `/mcp`, a hook in `/hooks`. Skills and mods load on their own.

## Install a whole stack at once

Flags combine, and each takes a comma-separated list:

```bash theme={null}
npx claude-code-templates@latest \
  --agent development-team/frontend-developer,security/security-auditor \
  --command testing/generate-tests \
  --mcp devtools/context7 \
  --setting permissions/read-only-mode \
  --hook automation/simple-notifications \
  --yes
```

`--yes` skips every prompt and writes settings and hooks to `.claude/settings.local.json`. The stack builder on aitmpl.com produces the same command for you. See [Stacks](/guides/stacks).

## Next

> [card] [Where files are written](/installation)
>
> Project vs user scope, and how existing config is merged.

> [card] [Component types](/components/overview)
>
> Pick the right type for what you want Claude to do.


# Troubleshooting
Source: https://docs.aitmpl.com/troubleshooting

Fixes for the most common problems: a component that is not found, a mod that stays silent, a removed flag, an empty dashboard.

> [accordion] Component not found (404)
>
> Pass the full path, `category/name`: `--agent development-team/frontend-developer`, not just `frontend-developer`. Copy it from the component's page on [aitmpl.com](https://www.aitmpl.com) or from the [Catalog API](/developers/catalog-api). Names are lowercase with hyphens.

> [accordion] A flag prints 'was removed in 1.31.0'
>
> That flag no longer exists. The message names what replaced it, and [Removed in 1.31.0](/cli/removed-in-1-31) lists them all.

> [accordion] A mod installs but does nothing
>
> Check, in order: your Claude Code version is 2.1.287 or newer; the project is trusted (open `claude` in the folder once and accept the prompt, since `claude -p` never asks); you are looking at the right place (`$.ui.log` lines go to `~/.claude/debug/<session>.txt` in headless runs); and options are under `pluginConfigs["<name>@skills-dir"]`. Details in [Mods](/components/mods#a-mod-that-seems-silent).

> [accordion] An MCP server does not show up in /mcp
>
> Restart Claude Code after the install, and fill in any API key the server needs: the CLI writes placeholders, never real keys. Check `.mcp.json` in the project root.

> [accordion] The analytics or chats dashboard shows 0 conversations
>
> Update to 1.31.0 or newer. Older versions stopped at a dangling symlink that Claude Code leaves in `~/.claude/debug/`.

> [accordion] I need a dashboard from another machine
>
> Since 1.31.0 the dashboards listen on 127.0.0.1 only. Forward the port over SSH: `ssh -L 3333:localhost:3333 <host>` (9876 for `--chats`).

> [accordion] npx installs an old version
>
> Use `@latest` explicitly; `npx` may reuse a cached copy otherwise. `npx claude-code-templates@latest --version` prints the version you ran.

Still stuck? [Open an issue](https://github.com/davila7/claude-code-templates/issues) with the command you ran and its output.