The 10 Claude Code Skills I Actually Use at Work
Welcome, Developer 👋
I want to be upfront about something: I’ve written a few posts on Claude Code skills already. Curated lists, ranked by stars, organized by category. Useful as a starting point, maybe. But none of them answer the question I actually get asked the most, which is: what do you personally have installed?
So here it is. These are the 10 skills I’m running right now, across the projects I work on day to day — a React Native platform serving a large student user base, and a side project built on MySQL and Metabase.
Real work. Real context. No filler.
1. superpowers
Source: github.com/obra/superpowers
Stars: ~40,900
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace
This one changed how I work more than anything else on this list.
Before Superpowers, I’d drop a task into Claude Code and it would start writing immediately. Sometimes that worked. More often, it went in a direction I didn’t want and I’d spend time unwinding it.
Superpowers forces a different sequence:
clarify → spec → plan → execute → review
The test-driven-development skill inside it is strict — it won’t write implementation before a failing test exists. The plan-eng-review step locks in architecture and data flow before any code is touched.
I use this for every feature that takes more than a session to build.
It’s overkill for small fixes. For anything real, it’s the skill I’d keep if I had to keep only one.
2. vercel-react-best-practices
Source: Vercel official — VoltAgent/awesome-agent-skills
Installs: 176,400 via skills.sh
npx skills@latest add vercel/react-best-practices
I spend most of my day in React Native and Expo. This skill isn’t Native-specific, but the React fundamentals it encodes — component structure, data fetching patterns, error boundaries — transfer directly.
The concrete difference: before this skill, Claude would generate components that worked in isolation and broke in context.
After installing it, the output follows patterns I’d actually write myself.
Proper hook usage, clean prop interfaces, no mystery side effects.
If React is part of your stack in any form, this belongs at user level.
3. frontend-design
Source: Anthropic official — github.com/anthropics/skills — already bundled
Installs: 124,100
This one’s already in your install and most people never touch it.
I didn’t for the first two months.
The difference it makes is less dramatic than the others but it’s consistent: Claude stops defaulting to the same visual output every time.
Inter font, purple gradient, grid cards — that’s the statistical center of every UI Claude has seen.
This skill pulls it away from that center and toward something that looks considered rather than generated.
I use it mostly for internal tools, reports, and dashboards where the design was never specified and someone needs to ship something that doesn’t look terrible.
4. spartan-ai-toolkit
Source: github.com/spartan-stratos/spartan-ai-toolkit
npx @c0x12c/ai-toolkit@latest --local
Quality gates.
That’s the reason I keep this installed.
It runs:
typecheck → lint → test → review
in sequence and won’t move to the next step if the previous one fails.
That sounds obvious.
In practice, it changes everything.
Without quality gates, Claude Code will write code, notice a failing test, patch the test to pass, and present that as done.
With this toolkit, that path doesn’t exist.
The gates force the right order.
I also use the React stack profile specifically, which gives Claude React and TypeScript conventions rather than generic JavaScript advice.
Eight profiles are available — Go, Python, Java, Kotlin, React, and more.
Pick yours.
5. mattpocock/skills
Source: github.com/mattpocock/skills
Skills: 17 dev workflow skills — install individually:
npx skills@latest add mattpocock/skills/write-a-prd
npx skills@latest add mattpocock/skills/request-refactor-plan
npx skills@latest add mattpocock/skills/git-guardrails-claude-code
Matt Pocock runs Total TypeScript.
If you write TypeScript, you’ve probably read something he’s written.
His skills reflect the same TypeScript-first perspective: strict type discipline, clean interface boundaries, and refactoring patterns that don’t just make the code shorter but make it more honest about what it does.
The ones I use most: tdd (stricter than Claude’s default, closer to what I’d actually enforce in a PR review) and refactoring-plan (generates a step-by-step plan for a refactor before touching anything).
The refactoring one in particular has saved me from making things worse in the name of making them better.
6. planetscale
Source: PlanetScale official — planetscale.com/docs
npx skills@latest add planetscale/skills
Database work is where I’ve seen Claude make its worst mistakes.
Not syntax errors — those are obvious.
The expensive kind:
- Schema decisions that seem fine and cause pain six months later
- Queries that run cleanly at 100 rows and fall apart at 100,000
- Missing indexes that only show up in production
Without this skill, Claude treats your database like any other code.
It writes something that runs and moves on.
The PlanetScale skill changes that default. It gives Claude the branching model — one database branch per feature, merge when done, never touch production schema directly — plus the query performance fundamentals that matter: index design, N+1 detection, query plan awareness.
I work with MySQL day to day and the skill earns its place even if you’re not on PlanetScale specifically.
The schema discipline and query hygiene it encodes transfer directly to any MySQL-compatible database.
It’s the most complete SQL skill available right now.
7. web-design-guidelines
Source: github.com/vercel-labs/web-interface-guidelines
Stars: 22,000 · Weekly installs: 133,400
npx skills@latest add vercel-labs/web-interface-guidelines
Where frontend-design improves what Claude generates, this skill reviews what you’ve already built.
It fetches Vercel’s interface guidelines and checks your code against them — outputs a list of violations with specifics.
I use it at the end of a UI session, not the beginning.
Think of it as a linter that catches the things ESLint doesn’t touch:
- Visual hierarchy issues
- Inconsistent spacing
- Accessibility patterns that are technically fine but practically terrible
The 133K weekly installs tell you it’s not just me.
8. doc-coauthoring
Source: Anthropic official — github.com/anthropics/skills
/plugin marketplace add anthropics/skills
/plugin install example-skills@anthropic-agent-skills
Every engineering team has documentation debt.
At UC, I work with infrastructure docs, runbooks, and the occasional disaster recovery plan.
On the side project side, there are specs, data dictionaries, and API docs that are always half-written.
The doc-coauthoring skill changes how Claude approaches any writing task: it starts by transferring context, building an outline, getting sign-off on structure, then drafting section by section.
The output reads like a human wrote it because the process required a human to guide it.
I’ve used this for a full DR plan, multiple technical specs, and a handful of onboarding guides.
Every time, the result was something I was comfortable putting my name on.
9. code-simplifier
Source: Anthropic official — github.com/anthropics/claude-plugins-official
/plugin marketplace add anthropics/claude-plugins-official
/plugin install code-simplifier@claude-plugins-official
AI moves fast and writes faster.
The code it produces works but accumulates complexity quickly — nested ternaries, functions doing three things at once, abstractions that made sense in the moment and don’t six weeks later.
The code-simplifier skill is focused on one thing: take recently modified code and make it cleaner without changing what it does.
It follows your project’s conventions from CLAUDE.md, applies them consistently, and flags clarity issues like nested conditionals and overly compact logic in favour of explicit, readable alternatives.
The rule it enforces that I appreciate most:
Never change behaviour, only how behaviour is expressed.
It won’t refactor your logic or suggest architecture changes — it cleans up the code you just wrote and moves on.
That constraint is what makes it trustworthy.
10. TerraShark
Source: github.com/LukasNiessen/terrashark
/plugin marketplace add LukasNiessen/terrashark
/plugin install terrashark
I manage Azure infrastructure as part of my day job and Terraform is where I’ve seen Claude make the worst mistakes — not obvious ones, but the kind that are fine at first and painful six months later.
Missing lifecycle rules, hardcoded values that should be variables, modules that don’t compose cleanly.
Most Terraform skills dump a wall of reference text into context on every activation — 4,400+ tokens — and then leave Claude to figure out what applies.
TerraShark is different.
The core SKILL.md is 79 lines and costs around 600 tokens on activation.
Instead of front-loading docs, it runs a diagnostic sequence:
capture context → identify failure mode → load only the relevant references → propose fixes with explicit risk controls → validate → deliver structured output
It’s grounded in HashiCorp’s official recommended practices.
When anything conflicts, it sides with HashiCorp.
That’s the right call.
Two Skills I’d Add Today
The list above is what I’m actually running.
But the Claude Code skills ecosystem is moving quickly, and if I were rebuilding this setup today, there are two areas I’d make sure to cover: browser testing and security.
These aren’t part of my original 10. I’m adding them because they fill two gaps that become increasingly important once Claude is doing more of the implementation work.
11. playwright
Browser automation is one of the areas where coding agents can go beyond simply writing code.
A good Playwright skill can help Claude interact with a real browser, test user flows, inspect pages, validate responsive behaviour, and catch issues that unit tests won’t see.
That matters especially for applications with:
- Authentication flows
- Checkout processes
- Forms
- Responsive layouts
- Navigation
- Client-side interactions
There are multiple Playwright skills available for Claude Code, including skills designed around browser automation and end-to-end testing.
The one I’d look at first is a well-maintained Playwright skill that keeps the workflow focused on actual browser testing rather than dumping the entire Playwright API into Claude’s context.
The important part isn’t just having Claude write tests.
It’s having Claude actually verify the application from the perspective of a user.
12. Security Review
This one is slightly different because Claude Code now has a built-in /security-review capability rather than requiring a separate third-party skill.
And honestly, I’d put this much higher on the list for production applications.
AI-generated code can look perfectly reasonable while still introducing problems around:
- Authentication and authorization
- SQL injection
- XSS
- Insecure data handling
- Dependency vulnerabilities
- Secrets
Claude Code's security review can scan for several of these classes of issues and can be run directly from the terminal.
The bigger point is this:
Code that works is not necessarily code that's safe.
As AI becomes more involved in writing production code, security checks need to become part of the workflow rather than something you remember to do at the end.
Final Thoughts
I don't think the point of Claude Code skills is to install as many as possible.
That’s probably the easiest way to make your setup worse.
The useful skills are the ones that change Claude's default behaviour in a way that matches how you actually work.
For me, the biggest wins fall into a few categories:
Planning:
Superpowers, PRD and refactoring workflows.
Code quality:
TypeScript conventions, TDD, linting, typechecking and simplification.
UI:
Frontend design and interface guidelines.
Databases:
Schema discipline, indexing and query performance.
Infrastructure:
Terraform-specific reasoning and validation.
Testing:
Browser-level verification with Playwright.
Security:
Reviewing the code before it becomes someone else's problem.
And that's probably the biggest lesson I've learned from using skills:
Don't use skills to make Claude do more. Use them to make Claude make fewer bad decisions.
That distinction matters.
A coding agent with 50 skills installed isn't necessarily better than one with 5 carefully chosen skills.
The goal isn't to give Claude more instructions.
The goal is to give it the right instructions at the right time.
What Claude Code skills are you using?
This is my current setup, but the ecosystem is changing fast.
If you have a Claude Code skill that has genuinely improved your workflow, drop it in the comments.
I'm especially interested in skills that solve problems around testing, databases, infrastructure, code review, and production workflows.
Top comments (0)