37 skills · 14 categories
Claude Code skills for TypeScript
TypeScript skills that make Claude reach for precise types instead of any: discriminated unions, schema validation at the boundaries, strict compiler settings and end-to-end typed APIs. They cover the language itself and the frameworks, ORMs and SDKs where type mistakes usually slip through.
Start with these
- 1
TypeScript Strict
Make impossible states fail to compile
Claude migrates and writes TypeScript with the strict family plus noUncheckedIndexedAccess and exactOptionalPropertyTypes, one flag at a time with an error count that only goes down. It narrows instead of casting, validates external data from unknown, models state as tagged unions with never checks, and backs public types with compile-time tests.
- 2
tRPC APIs
Typesafe procedures with auth that narrows context
Claude builds tRPC routers with a cheap typed context, protected and role-based base procedures that narrow ctx.user, Zod validation on input and output, and per-object ownership checks inside each procedure. The client imports only the router type, uses the v11 TanStack Query integration for queries and invalidation, and createCaller tests prove that the unauthorized and not-found paths hold.
- 3
Temporal Workflows
Durable processes that survive deploys and replays
Claude keeps Temporal workflow code deterministic and pushes every side effect into idempotent activities with explicit timeouts, heartbeats and non-retryable business errors. It models sagas with compensations, uses signals, queries and updates correctly, continues long loops as new, and treats every workflow code change as a versioning decision proven by replaying stored production histories in CI.
All 37 TypeScript skills
Grouped by category. Each card opens the full playbook, example prompts and install commands.
Claude Code Mastery 2
Agent SDK Builder
Ship a custom agent on Claude Code's own loop
Builds agents on the Claude Agent SDK that are safe to run inside a product. Claude starts with a read-only loop that logs every message type, adds domain tools as in-process MCP servers, gates risky calls with canUseTool or hooks, chooses the system prompt preset and settingSources on purpose so CLAUDE.md and skills load only when intended, and bounds every run by turns, time and logged cost.
MCP Server Builder
Connect Claude to your systems with tools it picks right
Builds Model Context Protocol servers that Claude can actually use well. Instead of mirroring every REST endpoint, Claude designs a few task-level tools with bounded schemas, compact outputs and fixable error messages, wires stdio or Streamable HTTP with the official SDKs, tests each tool in the Inspector and a scripted client, and registers the server for you or your team without leaking secrets.
Engineering Workflow 2
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.
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.
Frontend 7
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.
Next.js App Router
Layouts, caching and invalidation that behave in prod
Before writing data code, Claude checks the installed Next.js version and whether Cache Components is enabled, because caching defaults differ across 14, 15 and 16. It then keeps pages server-first, tags every cached source, invalidates after each Server Action, and verifies the result in the next build route table and a production server, not in dev mode where caching is hidden.
Modern Angular
Signals, control flow and zoneless, version-aware
Claude checks the installed Angular major first, then writes code that fits it: signal inputs and computed state instead of decorators and manual syncing, built-in control flow with real track keys, deferred heavy components, inject() and functional guards. It migrates NgModule and zone.js apps one schematic at a time and proves zoneless and hydration work by exercising the app, not just compiling it.
Nuxt Apps
Fetch once on the server, render per route
Claude picks the right fetch for each context in a Nuxt app: useFetch or useAsyncData with explicit keys for render data, $fetch for events, direct calls on the server. It validates every Nitro route input, keeps secrets in server runtime config overridable by NUXT_ env vars, sets rendering per route with routeRules, and checks the production build for double fetches.
React Router Framework Mode
Loaders, actions and typed routes, the Remix way
Claude builds React Router framework-mode apps the way the router expects: data in loaders, mutations in actions submitted by Form or fetchers, automatic revalidation instead of manual refetching, generated Route types, middleware for shared auth, and an ErrorBoundary per failing route. It checks whether the project is on v7 or v8 first and walks Remix and v7 apps through the future flags safely.
Vue Composition API
Refs that stay reactive and composables that compose
Claude writes Vue 3 single-file components with typed macros, ref as the default state primitive and computed for everything derived. It catches the traps that silently stop updates — destructured reactive objects and stores, watched values instead of getters, hooks after await — and keeps server data out of Pinia, with Nuxt 4 specifics for useFetch keys and SSR-safe state.
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.
Backend & APIs 8
tRPC APIs
Typesafe procedures with auth that narrows context
Claude builds tRPC routers with a cheap typed context, protected and role-based base procedures that narrow ctx.user, Zod validation on input and output, and per-object ownership checks inside each procedure. The client imports only the router type, uses the v11 TanStack Query integration for queries and invalidation, and createCaller tests prove that the unauthorized and not-found paths hold.
Temporal Workflows
Durable processes that survive deploys and replays
Claude keeps Temporal workflow code deterministic and pushes every side effect into idempotent activities with explicit timeouts, heartbeats and non-retryable business errors. It models sagas with compensations, uses signals, queries and updates correctly, continues long loops as new, and treats every workflow code change as a versioning decision proven by replaying stored production histories in CI.
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.
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.
OpenAPI Codegen
Generated clients that stay in sync with the spec
Claude picks one generator per language from a decision table, fixes the spec first so names and types come out clean (operationIds, named schemas, discriminators, accurate required lists), pins tool versions behind a single gen script, and adds CI gates for lint, oasdiff breaking changes, regeneration drift and consumer typechecks. A bundled checker flags spec problems before any code is generated.
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.
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.
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.
Testing 5
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.
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.
Vitest Testing
Vitest suites with no leaking mocks or hung timers
Claude configures Vitest so mocks restore themselves, each file runs in the right environment, and coverage counts every source file instead of only the ones a test touched. It knows the hoisting rules behind vi.mock, uses the async timer helpers when promises are involved, and maps Jest APIs one to one when migrating a suite.
Playwright E2E
End-to-end tests that never need a sleep
Claude writes Playwright tests the way the Playwright team recommends: role and label locators, auto-retrying assertions, API-seeded fixtures with teardown, and one login reused through storageState. When a test fails it reads the trace before touching code, and it ships CI config that shards runs, merges blob reports, and keeps traces for every failure.
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.
Cloud Platforms 2
AWS CDK
CDK diffs you can trust before you hit deploy
Claude structures CDK apps into explicit-environment stateful and stateless stacks, uses L2 grant methods instead of hand-written policies, and reads every cdk diff for replacements before deploy. It keeps logical IDs stable through refactors, untangles cross-stack export deadlocks, and adds assertion tests and cdk-nag so encryption and retention regressions fail CI.
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.
Databases 2
Drizzle ORM
Typed SQL, reviewed migrations, zero drift
Claude writes Drizzle schemas as the single source of truth: timezone-aware timestamps, named indexes on every foreign key, types inferred with $inferSelect instead of duplicated interfaces. It keeps push for local prototyping only, reads each generated SQL file for accidental drop-and-add renames, and picks between the core builder and relational queries based on what the result needs.
Prisma ORM
Read the SQL Prisma writes before it hits prod
Claude treats Prisma as a SQL generator it must supervise. Models get timestamptz and indexed relation fields, every generated migration.sql is read for silent drops and table rewrites, and production only ever sees migrate deploy. Queries select only needed fields with cursor pagination, transactions stay short, and the setup matches your installed Prisma major, including the Prisma 7 driver-adapter client.
AI Engineering 2
LLM App Builder
Ship LLM features with timeouts, streams, and budgets
Claude builds LLM features the way a production team would: one client module with timeouts and typed retries, streaming for anything a user waits on, a model picked by a small eval instead of reputation, and per-request cost logged from the first deploy. Every stop reason, including truncation and refusal, gets explicit handling and a test.
Structured Outputs
Schema-valid JSON, then checks on what it says
Claude replaces prompt-and-regex JSON with native constrained decoding: a JSON schema output format or strict tool generated from Pydantic or Zod models. It designs schemas with nullable fields and escape-value enums so the model never invents data, checks stop reasons before parsing, validates meaning as well as shape, and caps repair retries before routing to a human.
Security 2
Input Validation
Safe sinks first, schemas second, payload tests always
Claude stops relying on character stripping and fixes injection where it happens: bound parameters for SQL and allowlists for identifiers, context-specific encoding and sanitizers for HTML, resolved-IP checks for user-supplied URLs, resolved-path checks for file access, and argument arrays for commands. Boundary schemas in Zod or Pydantic add a second layer, and every fix ships with a payload test.
Passkeys and WebAuthn
Phishing-resistant sign-in with a recovery path to match
Claude builds passkey sign-in the way identity teams ship it: an RP ID chosen for the long term, single-use server-side challenges, verified origins, a credential table with counters, transports, and backup flags, and conditional UI so passkeys appear in autofill. It also designs fallback and account recovery so an email link does not quietly undo the phishing resistance.
Install
Every TypeScript 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 -- typescript-strict trpc-apis temporal-workflows agent-sdk-builder mcp-server-builder monorepo-navigation forms-validation express-node hono-edge openapi-codegen jest-testing property-based-testing vitest-testing pulumi-iac aws-cdk llm-app-builder structured-outputs nextjs-app-router playwright-e2e angular-modern nuxt-apps react-router-framework vue-composition bun-runtime deno-runtime nestjs-modules drizzle-orm prisma-orm input-validation notion-api passkeys-webauthn dead-code-removal astro-sites mutation-testing supabase-backend async-concurrency phaser-games TypeScript skills FAQ
What is the best Claude Code skill for TypeScript?
Start with TypeScript Strict: Make impossible states fail to compile. Then add tRPC APIs and Temporal Workflows, which cover the next most common TypeScript requests.
How do I install all 37 TypeScript skills at once?
Pass every name to the installer in one command: curl -fsSL https://claudeskills.page/install.sh | sh -s -- typescript-strict trpc-apis temporal-workflows agent-sdk-builder mcp-server-builder monorepo-navigation forms-validation express-node hono-edge openapi-codegen jest-testing property-based-testing vitest-testing pulumi-iac aws-cdk llm-app-builder structured-outputs nextjs-app-router playwright-e2e angular-modern nuxt-apps react-router-framework vue-composition bun-runtime deno-runtime nestjs-modules drizzle-orm prisma-orm input-validation notion-api passkeys-webauthn dead-code-removal astro-sites mutation-testing supabase-backend async-concurrency phaser-games. Add --project to install them into the current repository's .claude/skills/ folder so your team gets them too.
Do these TypeScript 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.