claudeskills.page

36 skills · 14 categories

Claude Code skills for JavaScript

JavaScript skills for the runtime, the browser and the tooling around them: module formats, event-loop pitfalls, bundling, package hygiene and the server frameworks most teams run. Use them alongside the TypeScript hub if your codebase is typed.

Install all 36 Browse the list

Start with these

  1. 1

    Async Concurrency

    Parallel I/O with limits, timeouts, and backpressure

    Claude turns sequential awaits into concurrent work without overloading anything: it finds the binding limit (rate limit, DB pool, memory), derives a cap from throughput times latency, and implements bounded fan-out in TypeScript, Python or Go with timeouts, cancellation and per-item error handling. Retries use jittered backoff and producers get real backpressure.

  2. 2

    Express on Node

    Express 5 services that fail loudly and shut down cleanly

    Claude structures Express apps around a testable app factory, orders middleware deliberately, validates bodies with Zod, and sends every failure through one problem+json error handler. It knows the Express 4 to 5 routing and async changes, tunes keep-alive against load balancer timeouts, and wires SIGTERM handling so deploys stop dropping in-flight requests.

  3. 3

    Bundle Analysis

    Cut the initial JS users actually download

    Claude measures before cutting: compressed size of the initial route, a treemap of what is in it, and a classification of every big module as needed now, needed later, duplicated or dead. It then removes, lazy-loads, replaces or tree-shakes in that order, proves the gain with the same build command, and adds a dependency-free budget script to CI so size cannot creep back.

All 36 JavaScript skills

Grouped by category. Each card opens the full playbook, example prompts and install commands.

Engineering Workflow 4

No. 032

Dependency Upgrades

Major version bumps without the Friday surprise

Claude upgrades in risk groups instead of bumping everything at once: a green baseline first, patch and minor updates batched, each major handled alone with its migration guide turned into a checklist, official codemods committed separately, and the lockfile changed only where intended. It also sets Renovate or Dependabot policies so routine updates merge themselves and majors wait for a plan.

dependency-upgrades 202 lines
No. 031

Dead Code Removal

Delete unused code with two kinds of proof

Claude configures the right analyzer for the stack with real entry points, triages candidates against known false-positive patterns such as dynamic imports, framework conventions and external callers, and requires a second signal like search, coverage or runtime logs before deleting. Removals land in small batches by kind with the full build and test gate after each, and confirmed false positives go into analyzer config.

dead-code-removal 142 lines
No. 037

Monorepo Navigation

Run the affected tasks, not the whole repo

Claude identifies the workspace tooling first, then runs only the affected tasks through Turborepo, Nx, or pnpm filters instead of testing everything from the root. It adds dependencies to the package that imports them, uses the workspace protocol for internal packages, respects module boundaries, and debugs cache misses by inspecting task hashes, inputs and declared outputs.

monorepo-navigation 156 lines
No. 039

Release Management

Version numbers that tell consumers the truth

Claude derives the next version from the actual changes rather than gut feel, cuts annotated tags that CI builds and publishes from, and picks fitting automation such as release-please, semantic-release, Changesets or git-cliff. Release branches and hotfixes follow a fix-on-main-then-cherry-pick flow, and every push or publish waits for your confirmation behind a pre- and post-release checklist.

release-management 202 lines

Frontend 2

No. 049

Astro Sites

Static HTML first, hydrate only what users touch

Claude builds Astro sites that stay static by default and ship framework JavaScript only for real widgets, choosing client:visible or client:idle before client:load. Content lives in typed Content Layer collections validated at build time, images go through astro:assets, and SSR is enabled per route with an adapter rather than flipping the whole site to server output.

astro-sites 216 lines
No. 053

Forms and Validation

One schema, server-checked, errors a screen reader hears

Claude starts each form from a field spec with input types, autocomplete tokens and actionable error copy, then writes one Zod schema used by both browser and server. Forms submit without JavaScript, keep values on error, map API failures such as a taken email onto the right field, and follow WCAG 2.2 rules on labels, focus after submit, paste and password managers.

forms-validation 198 lines

Backend & APIs 5

No. 082

Express on Node

Express 5 services that fail loudly and shut down cleanly

Claude structures Express apps around a testable app factory, orders middleware deliberately, validates bodies with Zod, and sends every failure through one problem+json error handler. It knows the Express 4 to 5 routing and async changes, tunes keep-alive against load balancer timeouts, and wires SIGTERM handling so deploys stop dropping in-flight requests.

express-node 196 lines
No. 079

Bun Runtime

Adopt Bun one role at a time, with proof

Claude treats Bun as four separate tools and adopts the low-risk ones first: package manager, then test runner, then bundler, then runtime. It commits the text lockfile, freezes it in CI, audits blocked install scripts, writes Bun.serve handlers with graceful shutdown and raised idle timeouts, and proves Node compatibility with the real suite and a staging image before anything ships.

bun-runtime 223 lines
No. 080

Deno Runtime

Scoped permissions instead of -A everywhere

Claude sets up Deno projects so every task runs with the narrowest permissions that work: scoped hosts, paths, env vars and binaries recorded as permission sets in deno.json, plus deny rules for metadata endpoints. Dependencies come from JSR and npm with a committed lockfile, tests keep sanitizers on, and shipping goes through deno compile, a pinned container, or Deno Deploy.

deno-runtime 215 lines
No. 088

Hono on the Edge

One typed API for Workers, Bun, Deno and Node

Claude writes Hono apps against Web standard APIs so they run on Workers, Bun, Deno or Node, with Bindings and Variables typed from the start. Inputs pass through Zod or Standard Schema validators, errors flow through one onError handler, and routes are chained so the exported AppType gives the frontend a fully typed hc client without hand-written fetch wrappers.

hono-edge 201 lines
No. 090

NestJS Modules

Clear module boundaries and enhancers in the right place

Claude organizes NestJS code into feature modules with small export lists, uses injection tokens instead of interfaces that vanish at runtime, and avoids request scope unless it is truly needed. Auth goes in guards, validation in a global ValidationPipe, mapping in interceptors, and tests override providers through the testing module so e2e runs use the same global config as production.

nestjs-modules 172 lines

Languages 1

No. 117

Regex Crafting

Patterns with test cases and no ReDoS surprises

Claude writes regexes test-first: a cases file of must-match, must-not-match and expected captures, then the simplest anchored pattern that passes. It knows where PCRE, JavaScript, Python, Java, Go and grep disagree, rewrites nested quantifiers and overlapping alternations, and runs a bundled script that pumps inputs to expose catastrophic backtracking before it ships.

regex-crafting 184 lines · 2 files

Testing 5

No. 132

Jest Testing

Jest suites with hoisting-safe mocks and honest snapshots

Claude sets a single Jest config with per-project environments, a fast TypeScript transform and restoreMocks so state never leaks between tests. It writes module mocks that respect hoisting rules, uses async timer advancers when promises are involved, keeps snapshots small and reviewed, and walks a suite through the Jest 30 breaking changes such as removed matcher aliases and the renamed path flag.

jest-testing 242 lines
No. 126

Benchmark Testing

Faster means significant, not one lucky run

Claude stops quoting single-run timings. It uses the right harness per language, guards against dead-code elimination, quiets the machine, measures noise with an A/A run, and compares 10 or more samples per side with a significance test and confidence interval. CI gates get thresholds derived from measured noise, or instruction counts when shared runners are too jittery.

benchmark-testing 259 lines · 2 files
No. 136

Mutation Testing

Find out if your tests would notice a real bug

Claude runs mutation testing where it pays off, on critical modules or changed files, and triages every surviving mutant: missing boundary case, weak assertion, untested error path, equivalent mutant, or dead code. Survivors turn into small behavior-named tests, ignores carry a written reason, and CI gates only the modules that matter.

mutation-testing 167 lines
No. 138

Property-Based Testing

Let the generator find the edge case you missed

Claude writes properties that state true facts about your domain, such as round-trips, invariants, and comparisons to a simple oracle, instead of restating the code. Generators build valid inputs directly rather than filtering, every shrunk counterexample becomes a pinned example test, and stateful components get model-based command sequences.

property-based-testing 213 lines · 2 files
No. 141

Testcontainers

Real databases in tests, started once and reset fast

Claude replaces database mocks and H2 stand-ins with the production engine in a container, started once per run rather than per test. It runs the real migrations, picks rollback, truncation, template databases or snapshots for isolation, gives each parallel worker its own database, and sets up GitHub Actions or GitLab Docker-in-Docker so the suite passes cold, shuffled and in parallel.

testcontainers 202 lines · 2 files

Cloud Platforms 4

No. 179

Azure Functions

Current models, managed identity and handled poison queues

Claude builds function apps on the current programming model for each language, migrating off in-process .NET and function.json-era code before the support cutoff. It picks a hosting plan from latency and networking needs, connects triggers through managed identity and Key Vault references, tunes host.json per trigger, and makes sure failing messages land in a monitored poison or dead-letter queue.

azure-functions 204 lines
No. 182

Cloudflare Workers

Right storage per binding, typed env, one-command rollback

Claude configures Workers with explicit compatibility dates, generated binding types and per-environment bindings, then picks KV, D1, R2, Durable Objects or Queues from the access pattern rather than habit. Code stays inside CPU and memory limits, tests run in the real Workers runtime via Vitest, and releases go out as versions with traffic splitting and a known rollback.

cloudflare-workers 203 lines
No. 189

Supabase Backend

Treat the database as the security boundary it is

Claude builds Supabase projects with the CLI and versioned migrations, enables RLS on every exposed table with per-operation policies that are indexed and tested as two different users, and keeps the secret key off clients. Server auth uses @supabase/ssr with verified users, storage paths are scoped by user folder, and types are regenerated after each schema change.

supabase-backend 204 lines
No. 190

Vercel Deploys

Reproducible builds, scoped env vars, instant rollback

Claude reproduces Vercel builds locally with vercel pull and vercel build before guessing, scopes env vars per Production, Preview and branch, and remembers that changes need a redeploy. Functions run on the Node.js runtime near the database with sensible maxDuration, previews stay protected, monorepo builds skip unaffected apps, and production moves by promotion with a known rollback.

vercel-deploys 158 lines

Data Engineering 2

No. 222

Data Visualization

Charts that make one point, honestly

Claude starts from the takeaway sentence and picks the chart form for that question, then builds it with zero-based bar axes, small multiples instead of dual axes, a highlighted series against gray, direct labels and a title that states the finding. Before export it checks values against the data, grayscale and colorblind readability, and writes alt text.

data-visualization 179 lines
No. 236

Web Scraping

Polite scrapers that notice when sites change

Claude checks robots.txt with a bundled script and reviews terms before writing any code, then looks for an API, sitemap, or embedded JSON before parsing HTML, reaching for Playwright only when content is client-rendered. Fetchers honor crawl delays and Retry-After, cache raw responses, resume from checkpoints, and fail the run when field null rates show the layout changed.

web-scraping 183 lines · 2 files

Security 1

No. 290

Supply Chain Audit

Triage every CVE instead of just counting them

Instead of running npm audit fix --force and hoping, Claude scans each ecosystem, checks whether each vulnerable package is actually in the runtime and reachable, and sorts findings into fix now, planned, or accepted with reasons. It also catches the quieter risks: missing lockfiles, install scripts, dependency confusion, typosquats, and GitHub Actions pinned to mutable tags.

supply-chain-audit 182 lines

Performance 4

No. 293

Async Concurrency

Parallel I/O with limits, timeouts, and backpressure

Claude turns sequential awaits into concurrent work without overloading anything: it finds the binding limit (rate limit, DB pool, memory), derives a cap from throughput times latency, and implements bounded fan-out in TypeScript, Python or Go with timeouts, cancellation and per-item error handling. Retries use jittered backoff and producers get real backpressure.

async-concurrency 209 lines
No. 294

Bundle Analysis

Cut the initial JS users actually download

Claude measures before cutting: compressed size of the initial route, a treemap of what is in it, and a classification of every big module as needed now, needed later, duplicated or dead. It then removes, lazy-loads, replaces or tree-shakes in that order, proves the gain with the same build command, and adds a dependency-free budget script to CI so size cannot creep back.

bundle-analysis 184 lines · 2 files
No. 303

Node.js Profiling

Flamegraphs and event loop lag, not guesses

Claude reproduces the slowdown with a load test, classifies it as CPU-bound, event-loop blocking, I/O wait or GC pressure using event loop utilization and lag percentiles, then captures the matching profile with Node's built-in flags. It reads flamegraphs by self time, fixes the specific hot path, and reports before and after p99 latency from the identical load run.

node-profiling 183 lines
No. 301

Memory Leak Hunting

From growing heap to the exact retaining reference

Claude separates real leaks from warming caches by repeating one action with forced GC, then uses the three-snapshot comparison to find object types that grow per round. It follows the retainer chain to the first reference your code owns, such as a listener, timer, unbounded Map or uncleaned effect, fixes it, and reruns the same loop to show flat memory.

memory-leak-hunting 159 lines · 2 files

Documents & Files 1

No. 368

Word Documents (.docx)

Styled, editable Word files that survive review

Claude builds Word files the way a careful editor would: named styles and real headings instead of bold Normal text, tables and images sized for the page, and templates that keep branding intact. Before editing, a bundled inspector reports tracked changes, comments and fields, so revisions are never silently mangled, and replacements that span split runs keep their formatting.

docx-documents 216 lines · 2 files

Integrations 2

No. 404

Discord Bots

Slash-command bots that never miss the 3-second window

Claude builds discord.js v14 bots with only the intents they use, a separate deploy script for slash commands, and handlers that defer before slow work so Unknown interaction errors stop. Buttons and selects encode record IDs in customId so they survive restarts and shards, and serverless endpoints verify Ed25519 signatures before answering PING.

discord-bots 238 lines
No. 420

Slack Apps

Bolt apps that ack in time and ask for few scopes

Claude builds Slack integrations from a committed app manifest, acknowledges every command, action and modal submission inside the 3-second window before doing real work, and keeps scopes minimal. It knows Block Kit limits, trigger_id expiry, event retry headers and rate-limit tiers, and wires OAuth installation stores keyed by team for apps installed beyond one workspace.

slack-apps 246 lines

SEO & Growth 1

★ No. 444

Technical SEO

Every page you want indexed, provably indexable

Turns Claude into a methodical technical SEO auditor. It maps every URL template to an intended index state, probes live responses with a bundled script, reads Search Console indexing reasons correctly, and fixes conflicting signals in impact order, from accidental noindex to redirect chains. It also sets AI-crawler rules deliberately instead of blocking bots by accident.

technical-seo 222 lines · 2 files

Game Development 1

No. 451

Phaser Games

HTML5 games that load clean and play on phones

Claude structures Phaser games into Boot, Preload, Game and UI scenes, loads every asset once with a progress bar, and wires Arcade Physics colliders and overlaps for exactly the pairs that need them. It pools projectiles, scales the canvas for any screen, handles touch input and mobile audio that stays locked until the first tap, and cleans up listeners so scene restarts do not leak.

phaser-games 223 lines

Automation & Tooling 3

No. 502

Task Runners

One command menu for every repo, same in CI

Claude inventories the commands scattered across README, CI and scripts, picks one runner (npm scripts, just, Taskfile or Make), and maps them to standard names like setup, dev, test and check. Tasks fail fast under strict shell settings, list themselves with descriptions, confirm before deploying, and CI calls the very same check task developers run locally.

task-runners 224 lines
No. 493

CLI Tool Building

CLIs that work for humans and in pipes

Claude writes the help text before the code, keeps data on stdout and everything else on stderr, uses meaningful exit codes, and adds --json, --dry-run and --yes so the tool works in scripts as well as terminals. It scaffolds in Typer, Click, commander or cobra, tests with CLI runners, and ships via uv tool, npm or GoReleaser.

cli-tool-building 210 lines
No. 498

macOS Automation

Shortcuts, AppleScript and launchd that just keep running

Claude picks the least fragile macOS mechanism for the job: a Shortcut or Tahoe automation, AppleScript or JXA against the app's dictionary, or a launchd agent with StartCalendarInterval or WatchPaths. Paths are absolute, secrets come from the Keychain, logs go to ~/Library/Logs, and privacy errors like -1743 are traced to the exact binary that needs permission.

macos-automation 190 lines

Install

Every JavaScript skill in one command

Installs into ~/.claude/skills/. Add --project after -- to install into the current repository.

curl -fsSL https://claudeskills.page/install.sh | sh -s -- async-concurrency express-node bundle-analysis bun-runtime deno-runtime node-profiling hono-edge dependency-upgrades jest-testing supply-chain-audit phaser-games task-runners nestjs-modules memory-leak-hunting discord-bots technical-seo dead-code-removal monorepo-navigation release-management astro-sites forms-validation regex-crafting benchmark-testing mutation-testing property-based-testing testcontainers azure-functions cloudflare-workers supabase-backend vercel-deploys data-visualization web-scraping docx-documents slack-apps cli-tool-building macos-automation

JavaScript skills FAQ

What is the best Claude Code skill for JavaScript?

Start with Async Concurrency: Parallel I/O with limits, timeouts, and backpressure. Then add Express on Node and Bundle Analysis, which cover the next most common JavaScript requests.

How do I install all 36 JavaScript skills at once?

Pass every name to the installer in one command: curl -fsSL https://claudeskills.page/install.sh | sh -s -- async-concurrency express-node bundle-analysis bun-runtime deno-runtime node-profiling hono-edge dependency-upgrades jest-testing supply-chain-audit phaser-games task-runners nestjs-modules memory-leak-hunting discord-bots technical-seo dead-code-removal monorepo-navigation release-management astro-sites forms-validation regex-crafting benchmark-testing mutation-testing property-based-testing testcontainers azure-functions cloudflare-workers supabase-backend vercel-deploys data-visualization web-scraping docx-documents slack-apps cli-tool-building macos-automation. Add --project to install them into the current repository's .claude/skills/ folder so your team gets them too.

Do these JavaScript skills work outside Claude Code?

Yes. Each skill uses only the portable Agent Skills frontmatter, so the same folder works on claude.ai, through the Claude API and in the Agent SDK. Skills that run bundled scripts need an environment with code execution.

Related technologies

esc