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
# full list at the repo

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.

What I’d install first if I was starting over

If I had to pick four and nothing else for the first week:

1. superpowers — the workflow foundation, everything else builds on top of this
2. spartan-ai-toolkit — quality gates between every step, won’t let Claude skip ahead
3. planetscale — if you touch a database at all, install this before you write another query
4. TerraShark — same logic, but for infrastructure

code-simplifier comes in week two — once you have a pattern for writing code, you want something that keeps it clean without second-guessing the logic. frontend-design and web-design-guidelines follow naturally if UI is part of your work. mattpocock/skills if TypeScript is your daily language.

Conclusion

The point isn’t to install everything. It’s to start with what matches the work you actually do and let the gaps tell you what to add next.

Stay focused, Developer!