# The Best Claude Code Skills to Make Claude Work Like a Senior Engineer

> A lean, audited checklist of the Claude Code skills worth installing — the ones that make Claude plan, test, review, and ship like a senior engineer.

Source: https://camnangai.com/en/for/developers/best-claude-code-skills  
Published: 2026-06-28  
Updated: 2026-07-31

By the end of this page your `~/.claude/skills/` folder holds only the **Claude Code skills** you
  actually use, every description fits inside the context budget, and you have a 30-day review on
  the calendar so the folder stops growing back.

The catalog in the second half is where you pick those skills.

What you need first: Claude Code installed and signed in, a terminal, and write access to `~/.claude/`. If you have no skills installed yet, skip Step 1 and start at Step 2.

![Cover image: a lean Claude Code toolbox — around 8 curated skills instead of dozens installed](https://camnangai.com/articles/best-claude-code-skills/01-infographic-en.webp)

## Step 1 — Measure your context budget before installing anything else

Run this inside a Claude Code session:

```
/doctor
```

It estimates what the skill listing costs you in context and names the biggest contributors. The listing gets a character budget of roughly 1% of the model's context window, and each entry is truncated at 1,536 characters — that is `description` plus `when_to_use` combined, while `description` alone is capped at 1,024 characters in SKILL.md. Go past the budget and the engine shortens, then drops, descriptions altogether, starting with the skills you invoke least. Both numbers are configurable: `skillListingBudgetFraction` for the budget, `skillListingMaxDescChars` for the per-entry cap.


  The skill names stay in the list, but stripped of their descriptions they silently stop
  auto-triggering — you will assume the skill is broken rather than that you installed too many.


![Diagram of the context tax: each skill's description fills the context window, contrasting a crowded junior setup of 30+ skills with a lean senior setup of about 8](https://camnangai.com/articles/best-claude-code-skills/02-en.webp)

A bloated skill folder charges you on every turn, whether or not a given skill fires, and the token bill is the smallest part of it:

- **Wasted budget** — every description is reloaded into the system prompt each turn, spending tokens even when nothing fires.
- **Wrong tool picked** — similar skills confuse the model, which attempts a database migration when you asked to format a file.
- **Shallower thinking** — redundant tool schemas crowd out working memory, so bug detection and cross-module understanding both get worse.

## Step 2 — Install one skill and confirm the engine loaded it

Pick one path and skip the other.

### The official path: marketplace

```bash
/plugin marketplace add anthropics/claude-code
/plugin install skill-creator@claude-plugins-official
```

### The community path: clone into your skills folder

```bash
git clone https://github.com/disler/agent-sandbox-skill.git ~/.claude/skills/agent-sandbox
```

Then ask in the session: "What skills are available?". The skill you installed must appear in the list; if it doesn't, the engine hasn't compiled it. Claude Code watches `~/.claude/skills/` live, so you never restart a session after adding or removing a folder.

## Step 3 — Install skill-creator before any other skill

Install [skill-creator](https://github.com/anthropics/skills/tree/main/skills/skill-creator) first. It's a meta-skill — a tool for building other tools — and it handles three jobs you will repeat constantly:

- Writes YAML frontmatter with a `description` narrow enough that the model triggers it at the right time, avoiding false positives.
- Surfaces competing trigger phrases that make the model hesitate, and suggests merging fragmented skills (three Git helpers into one, say).
- Flags one-shot requests: anything that needs no complex logic or tool chaining belongs in `CLAUDE.md`, not in a skill.

A description that does its job looks like this:

```yaml
name: review-pr
description: Review the current PR diff and flag risks. Use before commit.
allowed-tools: Bash(git diff *), Bash(gh pr *)
```

## Step 4 — Pick your skills from the catalog below

Scan the catalog groups further down and choose by four rules — the third is the one I find hardest to hold to, because adding a skill is always easier than deleting one:

- Take only the groups matching work you actually do every week. No frontend work means skipping the entire frontend group.
- The three design skills travel together: install all three or none, and don't cherry-pick one.
- The budget decides, not a fixed number. Re-run `/doctor` after each round of installs; once the listing starts overflowing, delete before you add more.
- For community skills, read the YAML `description` before installing — a sloppy one wastes tokens and fights your existing triggers.

## Step 5 — Schedule a review every 30 days

Treat skill maintenance like code maintenance. Every 30 days, re-run `/doctor` and put each skill through four questions:

1. **Frequency** — did you trigger it in the last 30 days? If not, delete it and reinstall when you need it.
2. **Overlap** — is its description distinct from every other skill? If not, merge the two competing triggers.
3. **Replaceability** — does it run bash or chain tools? If not, it's a one-line rule in `CLAUDE.md`, not a skill.
4. **Footprint** — does its monthly token cost justify the hours it saves? If not, delete it and log why.

The textbook deletion candidate is the **Caveman** skill: it gets passed around for promised token savings, but the community has largely debunked it — it only trims tokens on the final output, a tiny slice of total usage.

## Catalog: engineering discipline

This group deliberately slows the model down to raise first-pass quality, so if you just want code on the screen now, every skill in it will annoy you.

- **[grill-me](https://github.com/mattpocock/skills/tree/main/skills/productivity/grill-me)** — interviews you across 16–50 questions, mapping every branch of a decision before code is written.
- **[interview-me](https://github.com/Sorbh/interview-me)** — scans the codebase, then asks hard questions one at a time like a senior architect, producing a spec with a decisions log.
- **[superpowers](https://github.com/obra/superpowers)** — requires plan-test-review in an isolated environment; shifts first-pass success from 60% to 80%.
- **[GSD (Get-Shit-Done)](https://github.com/gsd-build/get-shit-done)** — builds in phases for long projects; `/gsd:map-codebase` reads existing code to pick up mid-flight. Archived, still installs.
- **[visual-plan](https://github.com/BuilderIO/skills/tree/main/skills/visual-plan)** — turns a prose plan into architecture diagrams, wireframes, and API specs grounded in your real repo files.
- **`/simplify` and `/review`** (built in) — refactor a diff for maintainability before you commit; a ~25K-token compaction budget keeps this command family reachable, alongside `/debug`, `/batch`, `/loop`.

The middle two install via `npx`, run from your project folder:

```bash
npx get-shit-done-cc@latest --claude --local
npx @agent-native/skills@latest add --skill visual-plan
```

## Catalog: Matt Pocock's skills

grill-me belongs to [Matt Pocock's skills collection](https://github.com/mattpocock/skills), aimed at four failure modes: drift between intent and execution, agents that lack domain language, untested code, and architectural entropy.

- **[tdd](https://github.com/mattpocock/skills/tree/main/skills/engineering/tdd)** — enforces red-green-refactor, one vertical slice at a time instead of testing last.
- **[diagnosing-bugs](https://github.com/mattpocock/skills/tree/main/skills/engineering/diagnosing-bugs)** — reproduce → minimize → hypothesize → instrument → fix.
- **[codebase-design](https://github.com/mattpocock/skills/tree/main/skills/engineering/codebase-design)** — a deep-module philosophy with interface, seam, and adapter vocabulary.
- **[improve-codebase-architecture](https://github.com/mattpocock/skills/tree/main/skills/engineering/improve-codebase-architecture)** — HTML reports of architectural deepening opportunities.
- **[grill-with-docs](https://github.com/mattpocock/skills/tree/main/skills/engineering/grill-with-docs)** — the "grill" interview plus domain-model building and CONTEXT.md updates.
- **[handoff](https://github.com/mattpocock/skills/tree/main/skills/productivity/handoff)** — compacts a whole conversation into a handoff document for the next agent.

## Catalog: frontend and design

All three count as a single slot. They exist to get you out of default AI output: neutral palettes, default fonts.

- **[frontend-design](https://github.com/anthropics/claude-code/tree/main/plugins/frontend-design)** — forces a design direction (brutalist, retro-futuristic, editorial) before any CSS is generated.
- **[theme-factory](https://github.com/anthropics/skills/tree/main/skills/theme-factory)** — injects design-token schemas, generating consistent CSS variables and Tailwind config across the app.
- **[ui-ux-pro-max](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill)** — databases of UI styles, palettes, font pairings, and UX guidelines that build a design system up front.

## Catalog: testing, security, and safe execution

- **[webapp-testing](https://github.com/anthropics/skills/tree/main/skills/webapp-testing)** — headless Playwright reads the DOM accessibility tree, so the agent fixes `z-index` and occlusion bugs.
- **[static-analysis](https://github.com/trailofbits/skills)** — Semgrep and CodeQL catch SQL injection, hard-coded secrets, and missing CSRF tokens before you open a pull request.
- **[agent-sandbox](https://github.com/disler/agent-sandbox-skill)** — E2B runs code in an isolated environment, preventing recursive deletes and leaked `.env` files; only the verified diff returns.

Try a command inside the sandbox:

```bash
uv run sbx init --timeout 1800
uv run sbx exec <sandbox_id> "npm test"
```

## Catalog: memory across sessions

- **[context-mode](https://github.com/mksglu/context-mode)** — filters junk command output before it enters agent memory; sessions hold for hours instead of failing after 30 minutes.
- **[claude-mem](https://github.com/thedotmack/claude-mem)** — local long-term memory: summarizes architectural decisions and bug fixes, then auto-injects them into new sessions.

## Catalog: extending Claude Code itself

- **[document-skills](https://github.com/anthropics/skills/tree/main/skills)** — ships real PDF, XLSX, DOCX, and PPTX files via local scripts, replacing up to 4 MCP servers.
- **[mcp-builder](https://github.com/anthropics/skills/tree/main/skills/mcp-builder)** — generates small, purpose-built MCP servers from plain English.

The governing rule is skills-first: use local skills for the reasoning layer, and reach for MCP (Model Context Protocol) only when the agent must touch external systems or live data. The default is a skill; MCP is the exception you have to justify.

## Catalog: work beyond coding

The work around the code — writing, research, meetings. Same rule: install only what you use.

- **[last30days-skill](https://github.com/mvanhorn/last30days-skill)** — pulls live discussion from Reddit, X, YouTube, Hacker News, GitHub, and Polymarket odds into a cited summary. Add the `mvanhorn/last30days-skill` marketplace.
- **[content-research-writer](https://github.com/ComposioHQ/awesome-claude-skills/tree/master/content-research-writer)** — hunts references, adds citations, sharpens hooks, and critiques section by section in your voice.
- **[academic-research-skills](https://github.com/Imbad0202/academic-research-skills)** — research → write → review → revise → finalize, with citation formatting and consistency checks. Explicitly not an "AI humanizer."
- **[Meeting Insights Analyzer](https://github.com/ComposioHQ/awesome-claude-skills/tree/master/meeting-insights-analyzer)** — reads meeting transcripts for speaking ratios, filler words, facilitation style, and conflict avoidance.
- **[Twitter Algorithm Optimizer](https://github.com/ComposioHQ/awesome-claude-skills/tree/master/twitter-algorithm-optimizer)** — rewrites tweets against Twitter's open-sourced ranking algorithm instead of guessing.

## Catalog: community bundles and directories

- **[Find Skills](https://github.com/vercel-labs/skills/tree/main/skills/find-skills)** — ask "is there a skill for X?" and it searches the open skills ecosystem and wires the match in. The companion to skill-creator.
- **[gstack](https://github.com/garrytan/gstack)** — Garry Tan's (YC) exact setup: ~23 opinionated slash-command skills that turn Claude into a virtual team — CEO, designer, eng manager, reviewer, QA, security, release engineer.
- **[baoyu-skills](https://github.com/JimLiu/baoyu-skills)** — a 20+ skill collection for content and utility work: article illustrators, cover-image generators, diagrams, publishing helpers.
- **[NotebookLM Skill](https://github.com/PleasePrompto/notebooklm-skill)** — lets Claude Code query your Google NotebookLM notebooks for source-grounded, citation-backed answers.
- **[awesome-claude-skills](https://github.com/ComposioHQ/awesome-claude-skills)** — the map to all of them: a curated, categorized index of hundreds of skills, kept current by the community. Two more directories worth bookmarking: [travisvn/awesome-claude-skills](https://github.com/travisvn/awesome-claude-skills) and [VoltAgent/awesome-agent-skills](https://github.com/VoltAgent/awesome-agent-skills).

## Catalog: maintaining your skill library

- **[skill-optimizer](https://github.com/hqhq1025/skill-optimizer)** — diagnoses existing skills using session data and static analysis, flagging what to tighten, merge, or cut.
- **[one-skill-to-rule-them-all](https://github.com/rebelytics/one-skill-to-rule-them-all)** — watches your sessions, logs improvement opportunities for every skill including itself, and applies them in scheduled autonomous runs. The author logged 600+ improvements across ~40 skills in three months.

## Troubleshooting

- **You name the skill and Claude does nothing** — the engine never compiled the folder. Ask "What skills are available?"; if it's missing, check the folder structure under `~/.claude/skills/`.
- **A skill that used to fire stopped auto-triggering** — its description was trimmed past the ~1% budget. Run `/doctor` and delete low-use skills until no description is being shortened.
- **Claude reaches for the wrong skill** — two descriptions compete for the same trigger. Merge them, or use skill-creator to narrow the `description`.
- **The agent deletes a directory or reads `.env`** — commands ran directly on your machine. Install agent-sandbox and execute in isolation, returning only the verified diff.

## What to do next

Open a Claude Code session and run `/doctor` right now to see what your skill listing costs in context. If it is already overflowing its budget, delete before you add anything from the catalog above. Put the next 30-day review on the calendar while you're there — and when you need a skill nobody has written, reach for skill-creator instead of searching for one.
