backend-pimp

Active router for ALL backend API and server framework requests — classifies by runtime, framework, and use case and routes to the correct backend skill before any response.

Model	Source
sonnet	pack: backend

Full Reference

If the request involves backend APIs, server frameworks, API design, routing, middleware, RPC, or server-side request handling in ANY way — you MUST route through this skill FIRST.

This is not optional. This is not negotiable. You cannot skip this.

Backend Pimp

The orchestration layer for all backend expertise. Not documentation — an active router. Every backend request flows through this routing table before any response.

Mandatory Announcement — FIRST OUTPUT before anything else:

┏━ ⚙️ backend-pimp ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ [one-line description of what request/routing] ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

No exceptions. Box frame first, then route.

Quick Context

The backend pack covers the full server framework spectrum — from ultra-lightweight Hono on Cloudflare Workers to Express.js middleware stacks to end-to-end typesafe tRPC APIs to REST API design patterns and resource naming conventions.

Routing Table

Classify the request. Invoke the matching skill. No response before invocation.

Request Pattern	Skill
Cloudflare Workers, edge runtime, Hono app, Hono middleware, Hono routing	`hono`
Express.js, Node.js server, Express middleware, Express routing, Express app	`express`
tRPC, end-to-end type safety, tRPC procedures, monorepo shared types, React Query + server	`trpc`
API design, REST conventions, resource naming, HTTP methods, status codes, versioning	`rest-api-patterns`
”Which framework should I use?” / “How do I structure my API?”	Decision matrix → route
OpenAPI / Swagger spec generation	Decision → `rest-api-patterns`

Decision Matrix

When the user hasn’t specified a tool, classify their use case:

Signal	Route To
Cloudflare Workers, edge runtime, low latency globally	`hono`
Node.js server, existing Express codebase, npm middleware ecosystem	`express`
Full-stack TypeScript, Next.js + shared types, no REST client/server gap	`trpc`
API design questions, naming resources, HTTP semantics, versioning	`rest-api-patterns`
”Which one should I use?”	Ask one question: edge or Node.js?

Shortcut rules:

Cloudflare Workers → Hono, no discussion
Existing Node.js/Express project → Express, no discussion
Full-stack TypeScript monorepo with React → tRPC, no discussion
REST API design/naming/conventions → rest-api-patterns, no discussion
“Best way to structure my API?” → rest-api-patterns first, then framework

State Detection

Before routing, check project context:

stack.json → read framework field (e.g., "framework": "nextjs" leans toward tRPC)
package.json → detect hono, express, @trpc/server, @trpc/client already installed
wrangler.toml → presence confirms Cloudflare Workers → route to hono
server.js / app.js → check for express() or new Hono() initialization
.env.example → PORT or HOST hints at Node.js server → lean Express

State	Action
`wrangler.toml` present	Route to `hono` directly
`hono` in deps	Route to `hono` directly
`express` in deps	Route to `express` directly
`@trpc/server` in deps	Route to `trpc` directly
Nothing detected	Apply decision matrix

Chaining Patterns

User Says	Chain
”Build an API on Cloudflare Workers”	`hono`
”Add middleware to my Express app”	`express`
”Set up tRPC with Next.js”	`trpc`
”Design REST endpoints for a product catalog”	`rest-api-patterns`
”Add auth to my Hono app”	`hono` → auth pack
”Migrate from Express to edge runtime”	`express` → `hono`
”Share types between my Next.js frontend and API”	`trpc`
”What HTTP status code should I return?”	`rest-api-patterns`
”Add rate limiting to my Express routes”	`express`

Hard Rules

Never respond about backend APIs/frameworks before invoking the target skill
No summarizing, planning to invoke, or explaining what you’re about to do
If unclear, ask ONE clarifying question, then route
The skill’s content has the verified facts — always defer to it
“How do I build an API?” is decision matrix territory — NEVER jump to implementation