/backend

Own the code, not the decision

backend owns the running server — the implementation craft inside the decided shape: the endpoints behind the contract, the domain layer, the OLTP schema and migrations, the auth enforcement, the queues and workers, the caches and the security controls, plus the tests that prove it runs. It consumes architecture's decisions — boundaries, contract shape, NFR budgets, threat model — and builds inside them rather than re-deriving or overriding them, and it recommends the sibling skills by name rather than silently doing their work.

Implement inside the decision. When compatible upstream artifacts are supplied — a solution-architecture doc, contracts, an NFR budget, a threat model, a handoff.yaml — backend builds against them. When they don't exist (a standalone run), it says so explicitly rather than inventing a contract or threat model to fill the gap.

The faceted router

SKILL.md is a router, not a script. Every request selects the smallest sufficient route: one primary job — the nine below — combined with at most one base surface that reshapes how the job applies to the runtime, plus the additive agentic overlay when the caller is an LLM/agent system. Read the selected references completely; load two or three at most, never the whole pack. Nine jobs and five surfaces compose across the runtime types — from a single-endpoint two-file read to a full service pass — without ever reading all fifteen references at once.

The nine primary jobs

Each job is one reference, read fully only when its route is selected — grounded in named canon, producing a running implementation plus the decision record behind it. This is the whole surface, not a headline slice.

Full router table & invariants: SKILL.md.

Default stack, then deviate

The skill speaks the current modal default per language fluently — so the fast path is fast — but every recommendation is a concrete pick + what NOT to build + the trade-off, weighted by reversibility. Adoption numbers are engagement, not gospel; the fundamentals below are anchored regardless of what is trending. Highlighted chips are the modal defaults.

Five surface overlays

One base surface, at most, reshapes the job for the runtime type — the same persistence job is bounded differently on a long-running server than on a scale-to-zero edge function. The agentic overlay is additive — it stacks on top of whichever base you picked — and is the first-class differentiator, expanded below.

The agentic flagship

Generic server-building is well covered; the agent-native backend is the 2026 throughline. Every major backend tool now ships an agent interface, and the argument that backends should be agent-legible — typed contracts, legible errors, markdown, token-efficient responses — is the differentiator versus every single-purpose backend skill. When the caller is an agent, the surface stacks additively: it changes the control plane, not just a component.

# the base surface stays; agentic stacks on top
base_surface:   serverless-edge   # rest-crud | serverless | realtime | event-driven
control_plane:  durable execution # Temporal / Hatchet — resume, don't retry-from-zero
tool_surface:   MCP + typed tool endpoints
contract:       agent-legible      # typed I/O, legible errors, token-efficient
retrieval:      RAG plumbing       # backend serves it; ai owns the core
tokens:         agent-scoped, short-lived
idempotency:    every tool call keyed  # retries are a given, not an edge case

The universal invariants

Six rules govern every route, whichever references it loads — the behavioral spine, condensed.

• Implement inside the decisionOwn the running server, not the boundary / contract-shape / NFR-budget / threat-model decision (→ architecture), OLAP / pipelines (→ data), the LLM/agent core (→ ai), deploy / CI / monitoring (→ operate), or the independent gate (→ quality). Consume upstream artifacts; when they don't exist, say so rather than inventing one.
• Retrieval-first / anti-stalenessBackend frameworks, ORMs, and DBs ship breaking changes fast (Prisma 7, Drizzle 1.0, Go 1.22 routing, Kafka 4.0, Redis licensing). Before generating any framework/ORM/DB-specific code, fetch the current official docs and types and version-gate the idioms — never rely on memorized APIs for a fast-moving target.
• Default-stack, then deviateName the current modal default per stack, but every recommendation is a concrete pick + what NOT to build + the trade-off, weighted by reversibility. Anchor the fundamentals (SQL-before-ORM, modular-monolith-first, at-least-once + idempotent). Cap each pass at 3–5 decisions.
• Exhaustive checklists are tablesAny "cover N items" task — OWASP controls, the API-contract review, a 12-factor audit, ASVS mapping — is a uniform table with a self-audit count, never a narrative. A narrative pass reliably drops rows and stops before full coverage.
• Prove it works before doneShip the verification loop (lint → migrate → test → hit the endpoint → diff-review) as the completion gate, reporting ✓/✗ per phase — distinct from quality's independent gate. Never assert it from memory.
• Distinguish facts, decisions, assumptions & proposalsPreserve upstream decisions and user constraints, or flag the conflict explicitly; prefer repository and artifact evidence over generic defaults; single-home every canonical fact (idempotency mechanics, OAuth flows, isolation levels) and state unknowns as TBD rather than inventing a value.

What a pass produces

backend's deliverable is a running implementation plus the decision record behind it. A full pass emits up to five kinds of artifact — plus the fillable checklists that ship in the pack. Each records the decision and options considered, the trade-off accepted, facts/decisions/assumptions distinguished, and — for any framework/ORM/DB code — that current docs were checked for the target version. It closes on the prove-it-works loop, not an assertion.

The handoff seam

backend consumes architecture's artifacts upstream — contracts, NFR budgets, threat model, ADRs — and, when downstream build/verify work is expected, emits a compact handoff.yaml beside the running code: a routing index into the services, contracts-as-built, tests, and telemetry hooks, never a copy of them. Standalone by default; the companion appears only when a consumer will actually read it.

skill: backend
status: complete
objective: ""   # only required field
artifacts_created: [service, contract,
  migrations, tests, telemetry-hooks]
decisions: · assumptions: · constraints:
verification: lint/migrate/test/hit ✓
security_border: controls impl'd vs
  quality-verified
recommended_next: operate · quality
  · frontend · data · ai

Seam discipline. The running code and its tests are the real deliverables; if a consumer needs more than the index gives, the artifact itself is incomplete — the yaml never grows to compensate. When a threat model was consumed, the border between backend-implemented controls and quality-verified controls is stated explicitly. Never silently invoke a build skill; name it in recommended_next.

Start here

Install once. It's a plain SKILL.md router — no flags, no config, no scripts — so it activates on natural-language phrasing ("build the endpoint", "add auth", "write a migration", "set up a job queue", "harden the API", "expose an MCP endpoint") rather than a fixed command.

The same install runs on any Agent Skills host. Codex installs to ${CODEX_HOME:-$HOME/.codex}/skills and triggers with $backend; agents remains a separate cross-agent installation target.