26 skills · category

Backend & APIs skills for Claude Code

Skills for building services that behave under load: REST and GraphQL design, gRPC, Express, FastAPI, Django, Rails, Go, Spring Boot, NestJS and Hono, plus background jobs, webhooks, and realtime connections with the idempotency and failure handling they need.

Download all 26 (.zip) Browse the list

Every backend & apis skill

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

API Versioning and Deprecation

Change public APIs without surprising a single client

Claude classifies every API change as additive or breaking before it ships, turns most breaks into expand-and-contract steps, and picks URL or date-based versioning only when needed. Deprecations get RFC 9745 and RFC 8594 headers, OpenAPI markers, per-client usage telemetry, a migration guide, brownouts, and a 410 Gone after sunset, with removal gated on data and your confirmation.

api-versioning-deprecation 216 lines · 2 files

ASP.NET Core APIs

Problem details, fail-closed auth, real integration tests

Claude wires ASP.NET Core APIs so failures are consistent and safe: IExceptionHandler and status code pages produce problem details, a fallback policy requires auth everywhere, options validate on start, and DI scopes are checked at build. Endpoints return TypedResults with owner-filtered EF Core projections, and integration tests run the real pipeline against Postgres in Testcontainers.

aspnet-core-apis 257 lines

Axum Rust Services

Thin handlers, typed state, errors that map to HTTP

Claude writes Axum 0.8 services with a typed AppState, one AppError enum that maps sqlx failures to 404 and 409, extractors in the order the compiler demands, and a tower-http stack with request IDs, tracing, timeouts and body limits in a deliberate order. Queries are checked at compile time with committed offline metadata, shutdown drains in-flight requests, and tests use oneshot with a fresh database.

axum-rust-services 287 lines

Background Jobs

Jobs that survive duplicates, crashes and retries

Claude treats every queue as at-least-once delivery. It makes handlers idempotent with natural guards or unique records, enqueues only after the transaction commits, separates transient from permanent failures, and configures backoff, timeouts shorter than visibility windows, and dead-letter alerts so a crashed worker or flaky API never silently loses or doubles work.

background-jobs 132 lines · 2 files

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

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

Django Apps

Constant query counts and migrations safe on live data

Claude measures queries before touching a Django view, then fixes N+1 with select_related, prefetch_related and annotations, and locks the result in with assertNumQueries. Migrations are read as SQL and planned for live tables, tasks are enqueued in on_commit, and DRF viewsets are scoped per user so list endpoints never leak other customers' rows.

django-apps 178 lines

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

FastAPI Services

Async APIs that never block the event loop

Claude builds FastAPI apps that keep blocking calls off the event loop, separate Pydantic v2 schemas from ORM models, and manage clients and engines in a lifespan rather than deprecated startup hooks. Sessions and auth come from Annotated dependencies that tests override, so route tests run fast against httpx without touching production resources.

fastapi-service 200 lines

Flask Apps

App factory, 2.0-style models, gunicorn in prod

Claude structures Flask projects around create_app with lazily bound extensions, environment config that fails fast on missing secrets, blueprints with JSON error handlers, and SQLAlchemy 2.0 typed models queried with select instead of legacy Model.query. It explains context errors instead of papering over them, tests with a fresh app per test, and serves production through tuned gunicorn workers behind a correctly counted ProxyFix.

flask-apps 303 lines

Go HTTP Services

Stdlib Go servers with timeouts, slog and clean drains

Claude builds Go APIs on net/http with method and wildcard routes, an http.Server that sets every timeout, and contexts that flow from the request into each database and HTTP call. Errors are wrapped with %w and mapped to status codes in one function, logs are slog JSON with request IDs, and SIGTERM drains in-flight requests before exit.

go-services 214 lines

GraphQL Schema Design

Client-shaped schemas that resolve in bounded queries

Claude designs GraphQL types from the queries clients actually send, chooses nullability that will not wipe a whole response on one failed field, and routes every relation through per-request DataLoaders so list queries stop fanning out into hundreds of SQL calls. It adds depth and cost limits, trusted documents, and schema diffs before anything is removed.

graphql-schema 188 lines

gRPC Services

Safe proto evolution and calls that always have deadlines

Claude designs protobuf APIs with per-RPC request and response messages, reserved field numbers and versioned packages, then gates every change with buf lint and buf breaking. Server code propagates deadlines, returns precise status codes with google.rpc error details, retries only idempotent calls, and fixes the classic HTTP/2 problem of one client pinning all traffic to one pod.

grpc-services 209 lines · 2 files

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

Laravel Apps

Eloquent without N+1, jobs that survive retries

Claude builds Laravel features the way a senior Laravel developer would: strict mode on so lazy loading fails in tests, validation in Form Requests, per-object policy checks, API Resources instead of raw models, and queued jobs with timeouts, backoff and idempotent handlers. Each feature ships with Pest tests that cover the success, 422 and 403 paths while external calls stay faked.

laravel-apps 282 lines

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

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.

openapi-codegen 211 lines · 2 files

Pagination and Filtering

Page one and page ten thousand cost the same

Claude builds list endpoints on keyset pagination with a unique tiebreaker instead of OFFSET, so deep pages stay fast and concurrent inserts never duplicate rows. It signs opaque cursors bound to the sort and filters, whitelists filter and sort syntax, creates an index for each allowed shape, replaces exact counts with estimates or capped counts, and proves it with EXPLAIN and a paging-under-writes test.

pagination-filtering 226 lines · 2 files

Phoenix Framework

Scoped contexts and LiveViews that never leak rows

Claude keeps Phoenix apps layered: LiveViews and controllers call scoped context functions, ownership comes from the scope instead of params, and PubSub topics carry the tenant. It respects the double mount, uses streams for growing lists, writes concurrent index migrations correctly, and tests every LiveView with Phoenix.LiveViewTest including the cross-user case.

phoenix-framework 255 lines

Rails Conventions

Code that follows the Rails grain instead of fighting it

Claude writes Rails features with generators, resourceful routes and controllers that only find records through the current user. Models carry validations backed by database constraints, views are eager-loaded and guarded by strict_loading, migrations are reversible and safe on big tables, and Turbo and Active Job are used the way Rails 8 defaults expect.

rails-conventions 169 lines

Realtime WebSockets and SSE

Live connections that scale out and recover on their own

Claude picks SSE or WebSockets from the actual traffic pattern, authenticates the handshake with cookies plus origin checks or short-lived tickets, and adds heartbeats tuned below every proxy idle timeout. Slow clients get disconnected before they exhaust memory, events fan out through a broker so any instance can deliver them, and clients reconnect with jitter and resume from a sequence number.

realtime-websockets 168 lines · 2 files

★ Editor's pick

REST API Design

Predictable endpoints, machine-readable errors, safe retries

Claude designs endpoints spec-first instead of improvising handlers. It matches your existing conventions, picks exact status codes, returns RFC 9457 problem documents, paginates with stable cursors, adds Idempotency-Key and ETag support where retries or concurrent edits happen, and runs oasdiff so a renamed field never ships as a silent breaking change.

rest-api-design 194 lines · 2 files

Spring Boot

Typed config, honest JPA and fast test slices

Claude writes Spring Boot code with constructor injection, validated configuration records, and explicit JPA fetch plans instead of relying on open-session-in-view. Errors come back as ProblemDetail, tests use the narrowest slice with Testcontainers rather than H2, and Actuator exposes health probes and metrics without leaking env or heap dumps.

spring-boot 178 lines

★ Editor's pick

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.

temporal-workflows 261 lines · 2 files

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.

trpc-apis 280 lines

Webhook Handling

Verified, deduplicated webhooks that never get lost

Claude verifies webhook signatures over the exact raw bytes with constant-time comparison and timestamp checks, stores each event under a unique provider ID, and acknowledges quickly while a worker does the real processing idempotently and order-safely. For outbound webhooks it applies Standard Webhooks signing, backoff retries and SSRF guards, and ships a stdlib script to sign and replay test payloads.

webhook-handling 174 lines · 2 files

Choosing Backend & APIs skills

Install the skills that match requests you make every week; each costs about 100 tokens of standing context until it loads. If you are not sure where to begin, start with REST API Design and Temporal Workflows. For background, read The Best Claude Code Skills in 2026, by Use Case, How to Install Claude Code Skills (5 Ways) and Personal vs Project Skills.

By technology: TypeScript skills JavaScript skills Node.js skills OpenAPI and REST skills Python skills

Install several

Install several at once

The installer accepts any number of skill names. This command installs all 26; add --project after -- to install into the current repository.

The installer is a 101-line POSIX shell script. It downloads each skill you name from claudeskills.page and unpacks it into your skills folder, nothing else: no sudo, no telemetry. Every skill page shows the full SKILL.md, so you can read what you install first. Read install.sh

curl -fsSL https://claudeskills.page/install.sh | sh -s -- …26 names

Backend & APIs skills FAQ

How do I install every Backend & APIs skill at once?

Download the bundle at https://claudeskills.page/downloads/category/backend.zip and unzip it into ~/.claude/skills/ (or .claude/skills/ inside a repository). To pick a few, pass several names to the installer: curl -fsSL https://claudeskills.page/install.sh | sh -s -- api-versioning-deprecation aspnet-core-apis axum-rust-services.

Will installing 26 skills slow Claude Code down?

No. Claude Code keeps only each skill's short description in context — roughly 100 tokens per skill — and loads the full instructions only when a request matches. Install the whole category if it fits your work; unused skills cost almost nothing.

Which Backend & APIs skill should I start with?

Start with REST API Design, Temporal Workflows. They cover the most common requests in this category; add the rest as your work calls for them.