Claude Code Templates: What They Are and Where to Get Them

Claude Code templates are ready-made configuration files for Claude Code: subagents, slash commands, hooks, settings, MCP server entries and skills that you drop into a project instead of writing from scratch. The best-known catalog is Claude Code Templates, an MIT-licensed community CLI at aitmpl.com. It is not from Anthropic. We checked the repo and docs on 31 October 2026.

Quick facts

The version mismatch above is normal for a fast-moving repo: the release tag lags the file on main. If you need to reproduce an install, pin a version rather than using @latest.

What a "template" means in Claude Code

Claude Code reads its extensions from plain files. That is why templates are possible at all. The docs list where each kind goes:

A template is a copy of one of these files that someone else already wrote and tested. Nothing more mysterious than that. Anything the installer does, you can do with cp.

Claude Code Templates (aitmpl.com)

What it is

A CLI plus a web catalog. The README describes "ready-to-use configurations" with a browsable site where you pick items and get the install command. The repo also bundles extras: usage analytics, a conversation monitor, a health check and a plugin dashboard.

The README's component table:

Install

From the README:

# Install a complete development stack
npx claude-code-templates@latest --agent development-team/frontend-developer --command testing/generate-tests --mcp development/github-integration --yes

# Browse and install interactively
npx claude-code-templates@latest

# Install specific components
npx claude-code-templates@latest --agent development-tools/code-reviewer --yes
npx claude-code-templates@latest --command performance/optimize-bundle --yes
npx claude-code-templates@latest --setting performance/mcp-timeouts --yes
npx claude-code-templates@latest --hook git/pre-commit-validation --yes
npx claude-code-templates@latest --mcp database/postgresql-integration --yes

The interactive mode is the safe way in. It shows what you are about to add. The --yes flag skips the prompts, so use it only after you have read the item on the site or in the repo.

The extras

npx claude-code-templates@latest --analytics      # session monitoring
npx claude-code-templates@latest --chats          # conversation monitor
npx claude-code-templates@latest --chats --tunnel # remote access via Cloudflare Tunnel
npx claude-code-templates@latest --health-check   # installation diagnostics
npx claude-code-templates@latest --plugins        # plugin dashboard

The tunnel option exposes a view of your conversations to the internet. Understand that before you use it, and do not run it on a machine with client work open.

Where the content comes from

The README's attribution section lists sources: Anthropic's skills repo (21 skills) and Claude Code repo (10 skills), a set of 139 scientific skills from K-Dense under MIT, 14 workflow skills from obra/superpowers, 36 role skills from alirezarezvani/claude-skills, 48 agents from wshobson/agents, and 21 commands from awesome-claude-code under CC0. It states that each resource keeps its own licence. Treat that as a pointer: if you ship a product, check the licence of the specific item you copied.

On the repo's components folder we saw directories for agents, commands, hooks, loops, mcps, mods, sandbox, settings and skills.

What to check before you install anything

Templates are code, even when they look like Markdown.

1. Read the file. A subagent prompt, a command with a shell injection line, or a hook can all run commands on your machine.
2. Check `allowed-tools` and `tools`. A broad grant removes permission prompts. See our skills guide and subagents guide.
3. Read hooks twice. A hook in settings.json runs shell commands on events such as before a tool call. Claude Code's docs treat these as powerful for a reason.
4. Check MCP entries for tokens. Never commit a token into .mcp.json. Use an environment variable.
5. Confirm the licence of the item, not just the repo.
6. Test in a throwaway repo before you add it to a real one.
7. Commit in a separate commit so you can revert the template alone.

Claude Code adds protection of its own: project MCP servers need your approval before first use, and workspace trust gates some project behaviour. Do not click through those prompts on a repo you just cloned.

Write your own starter set

If you want a small, readable setup you fully understand, start with four files. Our kit has fuller versions.

CLAUDE.md

Keep it to facts the agent cannot guess: build and test commands, naming rules, things to avoid.

# Project notes

## Commands
- Test: `pnpm test`
- Lint: `pnpm lint`
- Dev server: `pnpm dev` on port 4321

## Rules
- Use named exports.
- No default exports in `src/lib/`.
- Never edit files under `generated/`.

See the CLAUDE.md starter template and the AGENTS.md starter template for versions that also work across agents.

A read-only reviewer subagent

---
name: code-reviewer
description: Reviews changed code for bugs, security and maintainability. Use after writing or modifying code.
tools: Read, Grep, Glob, Bash
model: inherit
---

Run git diff, review only the changed files, and report Critical, Warning and Suggestion items with a fix for each.

Our code review subagent goes further.

A gated command

---
description: Draft release notes since a date
argument-hint: [YYYY-MM-DD]
disable-model-invocation: true
---

List merged commits since $ARGUMENTS and group them under New, Improve and Fix. Print only.

One settings file

.claude/settings.json holds permissions and hooks. Start with permission rules that allow your test and lint commands so you are not prompted for them, and deny anything destructive. Keep personal overrides in settings.local.json, which the docs say stays out of version control.

Where else to find templates

A safe first install, step by step

1. Make a scratch repo: mkdir ~/work-artifacts/scratch/tpl-test && cd ~/work-artifacts/scratch/tpl-test && git init.
2. Run npx claude-code-templates@latest with no flags so the interactive browser opens.
3. Pick one agent, such as a code reviewer, and read the description before you confirm.
4. Look at what changed with git status and git diff. You should see new files under .claude/.
5. Open the new agent file and read the whole prompt, including the tools line.
6. Start claude in the folder and ask it to use the new agent on a small file.
7. Run /agents or ask Claude to list its subagents, and check the name shows up.
8. If you keep it, copy the file into your real project and commit it on its own, with a message that says where it came from.
9. If you do not, delete the scratch folder. Nothing else was touched.

That loop takes a few minutes and teaches you what a good template looks like. After two or three rounds you will start writing your own, which is the real goal.

Keeping templates healthy

Treat every installed template like a dependency with an owner. Note its source in a comment or in the commit message. Re-read it when Claude Code ships a major change to agents, skills or hooks, since field names and defaults move. Run /skill-doctor to see which skills cost the most context and which you never trigger, and remove those. Run /context to see whether your descriptions are crowding the window. A template you have not used in a month is a template you can delete.

Read a template the way a reviewer reads a pull request

A template is instructions plus, sometimes, code that runs. Most of the risk sits in a few places, and a short audit finds them. After you install one into a scratch repository, run a search for the patterns that deserve a second look.

grep -rnE "curl|wget|eval|base64|sudo|rm -rf|chmod|ssh|nc |bash -c" .claude/ .mcp.json 2>/dev/null
grep -rn "allowed-tools\|tools:" .claude/ 2>/dev/null
ls -la .claude/hooks .claude/scripts 2>/dev/null

The first command finds network fetches, encoded strings and destructive commands. The second shows which tools each agent or skill may use without asking. The third lists scripts that a hook could run. A match is not proof of a problem, because a deploy skill may legitimately call ssh. It is a prompt to read that line and ask whether the template's stated purpose needs it. Hooks deserve the closest look, since they run automatically around tool calls, and a hook that sends data to an unfamiliar host is the one thing you cannot spot from a description.

What a good subagent file looks like

Templates differ widely in quality, and the quickest way to judge one is to compare it with a small, tight example. A subagent is a markdown file with a short frontmatter block and a prompt. This one is our own sketch of a read-only reviewer, written to show the shape, and you should adapt the wording.

---
name: diff-reviewer
description: Reviews the current git diff for bugs and missing tests. Use after finishing a change and before committing.
tools: Read, Grep, Glob, Bash
---

You review code changes. Run `git diff` and read the touched files.

Report only problems that affect correctness, security or missing tests.
For each, give the file, the line and the reason in one sentence.
Do not rewrite code and do not comment on style.
If you find nothing serious, say so in one line.

Compare any template against it with four questions. Does the description say when to use it, since Claude reads that to decide? Does the tools line grant only what the job needs? Is the prompt specific about what to report and what to ignore? Is it short enough to read in a minute? A template with a 400-line prompt and every tool granted is rarely better than one you would write yourself in ten minutes.

A team template repository

Once a few templates earn their place, give them a home so the team shares one copy.

Two rules keep it healthy. Every item records where it came from and who reviewed it, and every change goes through a pull request. For distribution, the plugin system described on our plugins page can bundle these items so teammates install one package instead of copying files, which suits larger teams. Small teams can get by with a script that copies the folder, and a note in each project's README on which version of the template set it uses.

Updating without breaking anything

Upstream templates change. When you want a newer version of something you installed, treat it like a dependency upgrade.

1. Install the new version in a scratch repository next to your current one.
2. Run diff -ru between the two .claude/ folders and read every change.
3. Pay attention to new tools, new hooks and new network calls.
4. Port the changes you want into your own copy by hand, keeping your local edits.
5. Commit the update on its own, with the upstream version in the message.

If the diff is too large to read, that is information: the template has drifted far from what you reviewed, and you may be better off writing the part you need yourself.

Limits and known issues

• Quality varies. A catalog of 100+ items cannot all be tuned for your stack. Expect to edit.
• Context cost. Every agent and skill description loads into context. Installing a lot makes Claude choose between more options and spends tokens.
• Version drift. Claude Code changes its fields and commands quickly. A template written months ago may use a field that is now ignored. The docs say unknown fields are ignored without an error.
• Open contributions. The tracker is mostly additions: new plugins, skills and MCP entries, and display fixes for plugin cards. Check that an item you want is still maintained.
• Not official. Anthropic's own sources for examples are the skills repo and the plugin directory, which we cover in the plugins guide.
• Overlap with plugins. Claude Code's plugin system now bundles skills, agents, hooks and MCP servers for sharing. For team use, a plugin may be a better distribution method than copied files.

Which should you use?

Our take

We did not run the installer or test the catalog items for this page. This is a reading of the README, the CLI package file and Claude Code's docs.

The idea is good. Most people never write a hook or a subagent because they do not know what a good one looks like, and a catalog fixes that. The honest weakness is the same as any large collection: breadth over depth. You will find a "security auditor" and a "database architect", and you should expect to rewrite both for your own stack.

Use it as a library to learn from, not as a bundle to install whole. Take one item, read it, change it, commit it with your name on it. After a month, delete what you did not use. The strongest setups we know of are small.

Remember that npx ...@latest pulls whatever is current. For a team, pin the version and treat the result like any dependency.

Frequently asked questions

What is Claude Code Templates? An MIT-licensed CLI and catalog at aitmpl.com that installs agents, commands, MCP configs, settings, hooks and skills.

How do I install a template? npx claude-code-templates@latest for the interactive mode, or flags with --yes.

Is it official? No, it is a community project.

What does a template change on my machine? It writes files into your project's .claude folders and settings. Read each one.

Do I need the installer? No. Copy the files by hand.

*Product names are used descriptively. We are not affiliated with Anthropic or the Claude Code Templates project.*