Claude Code has superpowers, but nobody tells you how to unlock them, this plugin does that.

When I first started using Claude Code, I opened the terminal, typed claude, and then… sat staring at the blinking cursor. I knew it had hooks, MCP servers, skills, subagents, plugins - an entire ecosystem of extension points that Anthropic had been heavily promoting. But where to start? Which ones were actually useful for my project? How do I configure them after installation?

It turns out I wasn’t the only one. Browsing through Reddit, Zenn, Towards AI - dozens of developers had the same question: “Claude Code has too many things, how do I know what to use?”

Anthropic heard the concerns. They released claude-code-setup - an official plugin in the claude-plugins-official marketplace, built by Isabella He from Anthropic herself. Not a third-party plugin, not a community hack. This is the official answer to the “analysis paralysis” problem when approaching Claude Code.

And after dissecting the entire source code of it (especially the 11KB-long SKILL.md), I realized: this is not just a useful plugin - it’s also a masterclass on how to write skills for Claude Code.

First look: 1 command line, 0 config

No need to clone the repo, no need to set environment variables. Open Claude Code, type just one command:

/plugin install claude-code-setup@claude-plugins-official

The claude-plugins-official marketplace has been pre-registered when you installed Claude Code - no need to add marketplace or anything else. After installation, the plugin lies in wait, waiting for you to trigger it with natural language:

"recommend automations for this project"
"help me set up Claude Code"
"what hooks should I use?"

No need to remember slash commands, no need for special syntax. Claude automatically detects intent and loads the skill. Exactly the “it just works” standard that I like in carefully designed tools.

So, what’s inside it?

Architecture deep dive: 1 skill + 5 reference files

Unlike complex plugins with dozens of agents, commands, MCP configurations, and claude-code-setup has a surprisingly simple architecture:

claude-code-setup/
├── .claude-plugin/
│   └── plugin.json              # Metadata: name, version, author
└── skills/
    └── claude-automation-recommender/
        ├── SKILL.md             # Core logic (~11KB)
        └── references/
            ├── hooks-patterns.md
            ├── mcp-servers.md
            ├── skills-reference.md
            ├── plugins-reference.md
            └── subagent-templates.md

1 single skill. No commands, no agents, no .mcp.json. The entire intelligence is contained within the SKILL.md file - and 5 reference files serve as a knowledge base.

This is a notable architectural choice: instead of hardcoding every recommendation into SKILL.md, Anthropic separates the “domain knowledge” into reference files. Why? When there’s a new MCP server or hook pattern, they only need to update the reference file - without touching the core logic. Clean af.

The plugin operates on a 3-phase workflow clearly defined in SKILL.md:

Phase 1: Codebase Analysis - “reading” your project

Claude uses 4 allowlisted tools in the frontmatter (tools: Read, Glob, Grep, Bash) to scan the project:

• Check package.json, pyproject.toml, Cargo.toml, go.mod → detect language + framework
• Grep dependencies → know you’re using React, Express, Prisma, Stripe, or Supabase
• List directory structure → understand project layout
• Check .claude/ and CLAUDE.md → know what you’ve set up before

Everything is read-only. No files are modified, no configurations are touched. Claude only reads and understands, like a senior dev joining the team and reading the codebase for the first time.

Phase 2: Recommendation Generation - mapping patterns to automation

After getting a complete picture, Claude maps the “signals” from the codebase to specific recommendations:

The intelligent part: it doesn’t just use fixed reference lists. The SKILL.md instruction is clear: “Use web search to find recommendations specific to the codebase’s tools, frameworks, and libraries” - meaning that if you’re using a niche tool not in the reference, Claude can still search and suggest it.

Phase 3: Output Report - not overwhelming, just top picks

This is where I think Anthropic understands user psychology. Instead of dumping a long list of 20-30 recommendations that would overwhelm you, the plugin only returns 1-2 recommendations per category. If you want more in a specific category, just ask.

The standard output format is:

## Claude Code Automation Recommendations

### Codebase Profile
- **Type**: Python 3.11+
- **Framework**: FastAPI
- **Key Libraries**: SQLAlchemy, Pydantic, pytest

### 🔌 MCP Servers
#### context7 - Live documentation lookup
**Why**: You use FastAPI + SQLAlchemy, and documentation changes frequently
**Install**: `claude mcp add context7`

### ⚡ Hooks
#### Block .env edits
**Why**: Prevent API key exposure when editing files
**Where**: `.claude/settings.json`

...

**Want more?** Ask for additional recommendations for any category.

Accompanied by a priority table ranking with stars (★★★, ★★, ★) - so you know what to do first.

Feature walkthrough: 5 categories, 1 comprehensive picture

The plugin covers all 5 types of automation that Claude Code supports. Each type has a different role:

The special point: recommendations are completely context-aware. Not the type “you should use Prettier because everyone uses it” - but “I see .prettierrc in your project, why not add an auto-format hook?” Each recommendation has a specific Why, based on your own codebase.

Analyzing SKILL.md: How Anthropic Writes “Standard” Skills

This is the part that I found most impressive. If you’re planning to write skills for Claude Code (or any AI agent), the SKILL.md of this plugin is the number one reference.

1. Frontmatter - Explicit, Not Ambiguous

---
name: claude-automation-recommender
description: Analyze a codebase and recommend Claude Code automations...
tools: Read, Glob, Grep, Bash
---

Three lines, each with a clear purpose:

• name: identifier for the skill - used by Claude when invoking
• description: trigger condition in natural language - Claude knows when to load this skill
• tools:: this is a crucial detail that many people overlook. By whitelisting Read, Glob, Grep, Bash, Anthropic ensures that this skill never edits files. It forces the skill to be read-only at the protocol level - not just “instructions say read-only”.

If you write a skill without setting tools:, Claude can use any tool in the context - including Edit, Write. For a recommender skill, that’s a disaster waiting to happen.

2. Workflow - 3 Clear Phases, Each with Specific Output

Not just “do something and return the result”. Each phase is defined with:

• Purpose: What does this phase do?
• Tools: Which tools are used? (with specific bash code examples)
• Key indicators: What information needs to be captured? (in a table format for easy scanning)
• Output: What does the output look like? (complete markdown template)

The way Anthropic structures the “Key Indicators to Capture” table is an excellent example:

| Category           | What to Look For          | Informs Recommendations For |
|--------------------|---------------------------|-----------------------------|
| Language/Framework | package.json, go.mod...   | Hooks, MCP servers           |
| Frontend stack     | React, Vue, Angular...    | Playwright MCP, frontend skills |
| Database           | Prisma, Supabase...       | Database/backend MCP servers  |

Three columns: signal → detection method → used for recommendations. Claude doesn’t need to “think” about what to do - just follow the table.

3. Decision Framework - Teaching Claude “When” Instead of Just “What”

This is the part that 90% of skill tutorials skip. SKILL.md doesn’t just list patterns - it has a whole section “When to Recommend” for each type of automation:

### When to Recommend MCP Servers
- External service integration needed (databases, APIs)
- Documentation lookup for libraries/SDKs
- Browser automation or testing
- Team tool integration (GitHub, Linear, Slack)

### When to Recommend Hooks
- Repetitive post-edit actions (formatting, linting)
- Protection rules (block sensitive file edits)
- Validation checks (tests, type checks)

### When to Recommend Skills
- Frequently repeated prompts or workflows
- Project-specific tasks with arguments
- Applying templates or scripts to tasks

This is different from just saying “recommend MCP server if you see a database” - it teaches Claude decision principles, so Claude can reason for itself in situations not covered in the reference files.

4. Output Templates - Not Letting Claude “Make Up” Formats

Instead of saying “output a report with recommendations”, SKILL.md provides a complete markdown template, including:

Claude Code Automation Recommendations

Codebase Profile

• Type: [detected language/runtime] …

🔌 MCP Servers

[server name]

Why: [specific reason] Install: claude mcp add [name] …

This template ensures consistent output, has a clear structure, and most importantly - **always includes "Why" to explain the reason**. There's no case where Claude dumps a list of tool names and leaves you to Google them.

### 5. Reference Files Architecture - separation of concerns

As mentioned above, 5 reference files are separated from the core logic. But the good thing is **how they are structured inside**: each reference file also uses a table format with "Detection → Recommendation" mapping. Consistency throughout the entire plugin.

For example, from `hooks-patterns.md`:

Simple, easy to maintain, and easy to extend. Each time a new hook pattern is added, just add a line to the table.

### 6. Configuration Tips - not only recommend, but also teach how to do

At the end of SKILL.md, there's a section guiding best practices:

- **Team sharing**: Check `.mcp.json` into git so the whole team can use the same MCP servers
- **Debugging**: Use the `--mcp-debug` flag when troubleshooting
- **Headless mode**: Pre-commit hook with `claude -p` for CI/CD pipeline
- **Permissions**: Configure `allowedTools` in settings.json

These are things that a newbie won't think of on their own - and also aren't easily found in Claude Code's official documentation. Anthropic uses this plugin itself to "educate" users about the entire extension system.

**Lesson for those who want to write skills:**
- ✅ Whitelist `tools:` in frontmatter to limit capability
- ✅ Use reference files for domain knowledge, don't hardcode into prompts
- ✅ Have a decision framework, not just a pattern list
- ✅ Provide specific template output, don't let AI format itself
- ✅ Include configuration tips - skills aren't just "recommend", but also "educate"
## DX: Easy to Install, Still Requires Manual Setup

The installation experience is 10/10. One command, no configuration, natural language trigger. It's true to the spirit of "get out of your way" that I expected from an official plugin.

But this is where many people get it wrong (I've seen quite a few on Reddit): **this plugin does not automatically apply any configuration**. It only analyzes and suggests. You still have to manually create `.claude/settings.json`, write hook config, install MCP server, and create `SKILL.md` for custom skills.

This is **read-only by design** - Anthropic intentionally does it this way. Why? Trust. If the plugin automatically modifies your config files without asking, it will break your current setup. Instead, it gives you full control: read recommendation → decide which one is suitable → apply it yourself or ask Claude to help.

There's a nice trick: after the plugin finishes running, you can tell Claude something like *"help me install .env block hook and context7 MCP"* - Claude will re-read the recommendation report and run the setup steps. No need to copy-paste each command.
## Weaknesses: The Less-Discussed Drawbacks

Despite my 4/5 star rating, there are a few points that need to be honestly addressed:

### 1. Quality Depends Entirely on Project Structure

If your project lacks a `package.json`, `pyproject.toml`, or clear config files (like some legacy script-only projects), the plugin is almost blind. It relies on structured signals to detect and provide recommendations - no signals means no quality recommendations.

### 2. One-Shot, Not Continuous

The plugin runs once and then stops. There is no watcher to detect when you add new dependencies or change your tech stack. Each time your project evolves, you must manually trigger it again.

### 3. Not Team-Aware

Recommendations are per-developer. There is no concept of "team shared config" or "org-wide policy". If 5 developers in a team run it, each person may receive different recommendations based on the context Claude sees.

### 4. Only One Skill - Not "Project Scaffolding"

Many people on Reddit install it and wonder "why it doesn't automatically create a project structure for me?" This is not `create-react-app` or `npm init`. It is a **automation recommender**, not a project generator. This expectation mismatch is more of a naming issue than an implementation issue.

### 5. No Auto-Update for Reference Files

Reference files are embedded in the plugin and maintained by Anthropic. When there are new MCP servers or hook patterns, you must wait for the plugin to update (or add custom references manually). There is no mechanism for "live sync" with an upstream knowledge base.
## Comparison: Alongside other official plugins

claude-code-setup is not the only plugin in the official ecosystem. A quick comparison:

| Plugin | Role | Compared to claude-code-setup |
|--------|---------|--------------------------|
| **github** | GitHub MCP integration | Supplemental: setup recommends GitHub MCP → install this plugin for integration |
| **commit-commands** | Git commit workflow | Supplemental: setup recommends commit skill → install this plugin for `/commit` command |
| **frontend-design** | UI generation skill | Supplemental: if codebase has React → recommend installing this plugin |
| **security-guidance** | Auto security review | Different: security-guidance runs automatically, setup only recommends |
| **claude-mem** (third-party) | Memory persistence | Different category: setup is "what to use", mem is "what to remember" |

Bottom line: claude-code-setup does not compete with other plugins - it **supplements** by helping you discover them. It is a "meta-plugin": install it first, and it will guide you on what to install next.

Compared to Claude-Mem (a popular memory persistence plugin in the community): one is a **setup recommender** (answering the question "what to use?"), the other is a **memory layer** (answering the question "what to remember?"). The two plugins serve two completely different needs, and using them together is even better.
## Verdict: ⭐⭐⭐⭐ (4/5)

### Who should use it?

- **New to Claude Code**: This is the first plugin you should install. It helps you understand the entire extension ecosystem without having to read hundreds of pages of documentation.
- **Experienced Claude Code users who haven't optimized yet**: If you're still using "vanilla" Claude Code without hooks, MCP, or skills, this plugin will open up a world of automation you never thought possible.
- **Those who want to learn how to write skills for Claude Code**: The SKILL.md of this plugin is an excellent reference document. Read, analyze, and apply similar patterns to your own skills.

### When not to use it?

- Your project is a simple script with 1-2 files and no complex dependencies
- You already have a full Claude Code setup with hooks, MCP, and custom skills
- You need to automatically apply configurations (not just recommendations) - this plugin doesn't do that

### Bottom line

claude-code-setup solves the pain point that most Claude Code users face: **"knowing it's powerful but not knowing where to start."** It doesn't do anything overly complex - just analyzes, recommends, and educates. But it does these things well, with "standard Anthropic" code quality, making it more valuable than many over-engineered plugins out there.

And if you're planning to write skills for Claude Code: read the SKILL.md of this plugin at least twice. I've learned more from these 11KB of markdown than from the entire official documentation on skill authoring.

---

*Have you used claude-code-setup yet? What's the most surprising recommendation you've received for your project? Share in the comments or ping me at [@luandnh](https://github.com/luandnh).

**Links:**
- [GitHub repo](https://github.com/anthropics/claude-plugins-official/tree/main/plugins/claude-code-setup)
- [Claude Code plugins docs](https://code.claude.com/docs/en/discover-plugins)
- [Plugin marketplace](https://claude.com/plugins)