New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Backend Engineering

by magnus919 in magnus919/agent-skills

Design and implement backend services and APIs — REST, gRPC, GraphQL, event-driven handlers, transaction boundaries, outbox/inbox delivery, migration coexistence, database access, integration, error…

MITAuto-check passedBackend & APIs

Install Backend Engineering

skills CLI
$ npx skills add magnus919/agent-skills --skill backend-engineering -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install magnus919/agent-skills backend-engineering --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/magnus919/agent-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/backend-engineering .claude/skills/backend-engineering && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
backend-engineering
GitHub stars
113
Token cost
~2.6k tokens
SKILL.md length
1,037 words
Files
15 (incl. scripts, references)
Skills in repo
115
Repo updated
First seen
Licence
MIT

At a glance

Design and implement backend services and APIs — REST, gRPC, GraphQL, event-driven handlers, transaction boundaries, outbox/inbox delivery, migration coexistence, database access, integration, error…

  • Works in 6 steps: Name the bounded context,… → Put transport, broker, database, clock,… → For a command that changes durable state… → …
  • Application/domain/infrastructure implementation decisions
  • SKILL.md covers The Backend Engineer's Domain, Reference Files, Templates and Scripts, plus 4 more sections
  • Runs Python scripts from its folder

What it does

Backend Engineering is an agent skill from magnus919/agent-skills. Design and implement backend services and APIs — REST, gRPC, GraphQL, event-driven handlers, transaction boundaries, outbox/inbox delivery, migration coexistence, database access, integration, error handling, and service-level testing. Use for application/domain/infrastructure implementation decisions. Language and framework agnostic. Do not use for frontend, data engineering, platform provisioning, API contract ownership, service decomposition strategy, or cross-system migration planning.

Its SKILL.md is about 2.6k tokens, which your agent loads only when the skill is triggered. The skill folder holds 18 other files, including scripts and reference files (for example `README.md`, `evals/evals.json` and `references/api-patterns.md`).

It sits in Backend & APIs, covering API design, Event-driven systems and gRPC and Protobuf. It works with gRPC and GraphQL. The repository describes itself as: Curated collection of AI agent skills for Hermes and other agent frameworks. The licence is MIT.

When your agent uses it

  • Application/domain/infrastructure implementation decisions
  • Data engineering
  • Platform provisioning
  • API contract ownership

Example prompts

  • “/backend-engineering”

Requirements

  • Python 3

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

  1. Name the bounded context, aggregate/invariant boundary, and source of truth. Use
  2. Put transport, broker, database, clock, and vendor concerns behind ports owned by
  3. For a command that changes durable state and emits a fact, load the aggregate,
  4. For an incoming message, validate the envelope at the edge, deduplicate within the
  5. If old and new paths coexist, record which path is authoritative for each operation,
  6. Add unit tests for domain/application behavior and boundary integration tests for

What it can do on your machine

Read from SKILL.md and the folder at commit 96fbe07. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 2 files in scripts/ (Python), which the agent can run.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Backend Engineering loads about 2.6k tokens when it runs, and up to ~20k if it reads all its reference files. Until then it costs about 129 tokens; SKILL.md has 1,037 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~129
When it runs · the whole SKILL.md, loaded when a task matches
~2.6k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~20k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from magnus919/agent-skills at commit 96fbe07, republished under its MIT licence (© magnus919). 1,037 words, ~2,577 tokens.

Download SKILL.mdSave it as .claude/skills/backend-engineering/SKILL.md (or your agent's skills folder). This skill also uses 14 other files; get the full folder from GitHub.
name
backend-engineering
description
Design and implement backend services and APIs — REST, gRPC, GraphQL, event-driven handlers, transaction boundaries, outbox/inbox delivery, migration coexistence, database access, integration, error handling, and service-level testing. Use for application/domain/infrastructure implementation decisions. Language and framework agnostic. Do not use for frontend, data engineering, platform provisioning, API contract ownership, service decomposition strategy, or cross-system migration planning.
license
MIT
metadata.tags
backend, api, services, server, database, integration, middleware, events, outbox, inbox, idempotency, coexistence, query-optimization, testing
metadata.source_repo
https://github.com/magnus919/hermes-profiles

Backend Engineering Methodology

Backend engineering is the craft of building the server-side systems that power applications — APIs, services, data access, integrations, and the runtime behavior that makes the architecture real. This methodology covers implementation after target design in software-architecture and before quality validation in qa-methodology; use software-architecture-analysis when the current system must first be reverse-engineered. It makes runtime boundaries, transaction behavior, message handling, and coexistence seams executable without taking ownership of the surrounding architecture or migration decision.

The Backend Engineer's Domain

You ownYou don't own
API implementation — REST/gRPC/GraphQL endpoints, request validation, response formatting, error handling, middleware chainsAPI contracts belong to api-design-and-evolution; service decomposition and target boundaries belong to software-architecture
Service logic — business rules, workflow orchestration, state management, background job processingDeployment pipeline and infrastructure — that's platform-engineering
Event-driven implementation — domain-event publication, outbox/inbox coordination, handler idempotency, replay and failure pathsEvent contract ownership and delivery semantics — that's the api-design-and-evolution
Migration seams inside a service — adapters, selectable paths, authority checks, and implementation handoffsCross-system migration lifecycle and cutover authority — that's the migration-engineering
Database access patterns — query design, connection management, transaction boundaries, N+1 detection, paginationData-platform and model strategy belong to data-architect; schema and pipeline operations belong to data-engineering
Integration code — third-party API clients, webhook handlers, message queue consumers/producersCode review and quality gates — that's qa-methodology
Observability instrumentation at the service level — structured logging, metrics, tracing hooksObservability infrastructure and reliability policy belong to platform-engineering and site-reliability-engineering
Service-level tests — unit tests for business logic, integration tests for API contractsTest strategy and automation — that's qa-methodology

Reference Files

ReferenceWhen to load
references/api-patterns.mdDesigning or implementing API endpoints — resource modeling, versioning, pagination, error response formats, request validation
references/service-patterns.mdStructuring service logic — clean/hexagonal/layered architecture, dependency injection, middleware composition, request lifecycle, background jobs
references/event-driven-service-implementation.mdImplementing event-driven application flows — domain events, unit of work, transactional outbox/inbox, idempotent handlers, retry/replay, observability, and failure handling
references/migration-coexistence-patterns.mdKeeping old and new implementations safe to run together — adapters, strangler handoffs, anti-corruption boundaries, dual paths, authority, and removal conditions
references/database-testing.mdDatabase access patterns (connection pooling, query optimization, N+1 detection, pagination strategies, transaction boundaries, read/write splitting, replication lag) and service-level testing (unit testing business logic, integration testing API contracts with test containers/WireMock, contract testing with Pact, test fixtures, CI integration)
references/integration-patterns.mdIntegrating with external systems — retry with backoff, circuit breakers, idempotency keys, webhook verification, message queue consumers
references/error-handling.mdHandling errors systematically — classification (client vs server), structured responses, exception handling patterns, observability correlation
references/source-index.mdProvenance and ownership notes for this original synthesis; load when reviewing scope or source boundaries

Templates

TemplateWhen to Use
templates/service-design-record.mdDesigning or restructuring a service — structure, API surface, data access, error handling, and testing plan in one reviewable record
templates/error-handling-taxonomy.mdDefining or auditing a service's error contract — classification, response format, retry/idempotency policy, and error-path tests

Scripts

ScriptWhen to Use
scripts/n1-query-spotter.pyScanning Python source for potential N+1 query patterns (query-like calls inside loops); --json for CI-friendly output, exit 1 on findings
  • programming-principles — DDD owns bounded contexts, aggregates, domain language, repositories, and domain-modeling guidance. This skill applies those decisions at implementation seams rather than duplicating that catalog.
  • api-design-and-evolution — owns event/message contracts, delivery semantics, compatibility, and consumer-facing API decisions.
  • migration-engineering — owns cross-system migration classification, compatibility windows, reconciliation, cutover, recovery, deprecation, and cleanup. This skill only implements service-local coexistence seams.
  • software-architecture — owns service decomposition and target-boundary strategy; backend engineering implements an approved boundary.
  • data-engineering — owns schema migration and pipeline operations; application code may expose the repository or transaction interfaces those operations use.
  • secure-software-engineering — owns threat modeling, authorization, secrets, untrusted inputs, and security acceptance evidence.
  • release-engineering — owns progressive delivery, artifact promotion, release gates, and rollback mechanics.
  • postgres — diagnosing the PostgreSQL side of a database problem: configuration review, index and query-plan issues, vacuum/bloat, backups/PITR, replication and failover. Application-level data access patterns stay here; engine-level operations route there.
  • supabase — building on Supabase: migrations, RLS, Auth, Storage, and Edge Functions. To measure an agent's Supabase task competence, use its agent evals harness reference.
Show full SKILL.md (387 more words)Show less

Core Principles

The interface is the contract — API boundaries are service-level contracts. Every endpoint signature, request schema, response format, and error code is a promise to consumers. Breaking changes are coordination problems, not version bumps.

Business logic is the center of gravity — Keep business rules isolated from framework concerns, transport protocols, and infrastructure details. A well-structured service can survive changes to its HTTP library, database driver, and deployment platform.

Handle errors where they make sense — Catch errors at the boundary where you have enough context to handle them meaningfully. Catch too early and you lose context. Catch too late and you can't recover.

Design for failure, not just success — Every external call can fail. Every database connection can drop. Every message can be duplicated. Idempotency, retry, and graceful degradation are not optimizations — they're requirements.

Test at the right level — Business logic gets unit tests. API contracts get integration tests. Service boundaries get contract tests. Each level catches a different class of failure.

Implementation Decision Path

  1. Name the bounded context, aggregate/invariant boundary, and source of truth. Use programming-principles for DDD choices rather than rebuilding its catalog here.
  2. Put transport, broker, database, clock, and vendor concerns behind ports owned by the application or domain-facing code. Let infrastructure implement those ports.
  3. For a command that changes durable state and emits a fact, load the aggregate, invoke domain behavior, and commit state plus outbox records in one unit of work. Do not hold that transaction open across network calls.
  4. For an incoming message, validate the envelope at the edge, deduplicate within the consumer's authority, apply the handler, and acknowledge only after its durable effects commit. Load the event reference for replay and poison-message decisions.
  5. If old and new paths coexist, record which path is authoritative for each operation, how outputs are compared, and what evidence permits handoff or removal. Load the migration reference for the implementation seam; route the migration lifecycle out.
  6. Add unit tests for domain/application behavior and boundary integration tests for transaction, outbox, inbox, duplicate, retry, replay, and recovery behavior.

Exit Criteria

This skill is complete when the implementation has explicit dependency direction, transaction and authority boundaries, classified failure/retry behavior, observable message or coexistence paths, focused tests for duplicate and failure cases, and clear links to the neighboring owner for every out-of-scope decision.

© magnus919, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 14 other files (scripts, references) in backend-engineering of magnus919/agent-skills.

  • SKILL.md
  • README.md
  • evals/evals.json
  • references/api-patterns.md
  • references/database-testing.md
  • references/error-handling.md
  • references/event-driven-service-implementation.md
  • references/integration-patterns.md
  • references/migration-coexistence-patterns.md
  • references/service-patterns.md
  • references/source-index.md
  • scripts/n1-query-spotter.py
  • scripts/test_n1_query_spotter.py
  • templates/error-handling-taxonomy.md
  • templates/service-design-record.md

Open the folder on GitHubat commit 96fbe07

Compare with similar skills

Backend Engineering next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Backend Engineering compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Backend Engineering this skillmagnus919/agent-skills113—~2.6kAutomated safety check: PassMIT
API Architectcuriositech/some_claude_skills2431 repos~1.4kAutomated safety check: PassMIT
API Design InterviewerPrepLabsAI/InterviewMentor112—~2.6kAutomated safety check: PassMIT
API Contract Detectionprime-radiant-inc/greenfield292—~4.2kAutomated safety check: PassApache-2.0
API Design Patternsbobmatnyc/claude-mpm1552 repos~5.6kAutomated safety check: PassApache-2.0
API Designmajiayu000/spellbook286—~2.1kAutomated safety check: PassMIT

Similar skills

  • API Architect

    curiositech/some_claude_skills

    Expert API designer for REST, GraphQL, gRPC architectures. An agent skill from curiositech/some_claude_skills.

    243 GitHub starsUsed in 1 repo~1.4k tokens
    Backend & APIsAuto-check passed

  • API Design Interviewer

    PrepLabsAI/InterviewMentor

    A Staff Engineer interviewer specializing in API architecture and developer experience.

    112 GitHub stars~2.6k tokensUpdated 2 days ago
    Backend & APIsAuto-check passed

  • API Contract Detection

    prime-radiant-inc/greenfield

    Finds OpenAPI, GraphQL, Protobuf and JSON Schema files in a codebase and extracts behavioral claims from them as part of a reverse-engineering workflow.

    292 GitHub stars~4.2k tokensUpdated 2 mo ago
    Backend & APIsAuto-check passed

  • API Design Patterns

    bobmatnyc/claude-mpm

    Comprehensive API design patterns covering REST, GraphQL, gRPC, versioning, authentication, and modern API best practices

    155 GitHub starsUsed in 2 repos~5.6k tokens
    Backend & APIsAuto-check passed

  • API Design

    majiayu000/spellbook

    REST/GraphQL/gRPC API design best practices. An agent skill from majiayu000/spellbook.

    286 GitHub stars~2.1k tokensUpdated yesterday
    Backend & APIsAuto-check passed

  • API Forge

    EliasOulkadi/shokunin

    Design REST/GraphQL APIs with OpenAPI 3.1, error handling, pagination, rate limiting, webhooks, and idempotency.

    114 GitHub stars~2.9k tokensUpdated 4 days ago
    Backend & APIsAuto-check passed

More from magnus919/agent-skills

All 115 skills in this repo

  • Artifact Pyramids

    magnus919/agent-skills

    Organize durable agent research outputs as summaries, analysis, and evidence dossiers.

    113 GitHub stars~2.7k tokensUpdated 2 days ago
    Auto-check passed

  • Ascii City Engine

    magnus919/agent-skills

    Build portable, first-person colored ASCII city engines and small GIS-derived city packs.

    113 GitHub stars~1.1k tokensUpdated 2 days ago
    Auto-check passed

  • Color Management

    magnus919/agent-skills

    Manage color workflows with ICC profiles, working spaces, gamut mapping, and color science.

    113 GitHub stars~2.6k tokensUpdated 2 days ago
    Auto-check: notes

  • Data Scientist

    magnus919/agent-skills

    A skill your agent uses for PhD-level expertise in data science, statistics, and machine learning: rigorous statistical analysis, experimental design, causal inference, advanced modeling, research…

    113 GitHub stars~4.1k tokensUpdated 2 days ago
    Auto-check passed

  • Docker Compose

    magnus919/agent-skills

    Use Docker Compose to define, run, debug, and harden multi-container applications.

    113 GitHub stars~2k tokensUpdated 2 days ago
    Auto-check: notes

  • Fpga Development

    magnus919/agent-skills

    Design, review, simulate, and verify FPGA logic using explicit RTL contracts, clock and reset models, CDC analysis, timing constraints, and reproducible implementation evidence.

    113 GitHub stars~2.7k tokensUpdated 2 days ago
    Auto-check passed

Works with

Categories

Questions about Backend Engineering

What does Backend Engineering do?

Design and implement backend services and APIs — REST, gRPC, GraphQL, event-driven handlers, transaction boundaries, outbox/inbox delivery, migration coexistence, database access, integration, error…. Backend Engineering is an agent skill from magnus919/agent-skills. Design and implement backend services and APIs — REST, gRPC, GraphQL, event-driven handlers, transaction boundaries, outbox/inbox delivery, migration coexistence, database access, integration, error handling, and service-level testing.

When should I use Backend Engineering?

Backend Engineering fits situations like: application/domain/infrastructure implementation decisions; data engineering; platform provisioning; API contract ownership.

How do I install Backend Engineering in Claude Code?

Run `npx skills add magnus919/agent-skills --skill backend-engineering -a claude-code`. Or copy the skill folder (backend-engineering in magnus919/agent-skills) into .claude/skills/backend-engineering in your project. Claude Code loads it when a task matches its description.

How do I install Backend Engineering in Codex?

Run `npx skills add magnus919/agent-skills --skill backend-engineering -a codex`. Or copy the skill folder (backend-engineering in magnus919/agent-skills) into .agents/skills/backend-engineering in your project. Codex loads it when a task matches its description.

Can I use Backend Engineering in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add magnus919/agent-skills --skill backend-engineering -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/backend-engineering, .gemini/skills/backend-engineering, .github/skills/backend-engineering and .opencode/skills/backend-engineering in your project.

What does Backend Engineering need to run?

Going by SKILL.md and its folder, Backend Engineering needs Python for the scripts in its folder. Our summary lists: Python 3.

Does Backend Engineering access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Backend Engineering safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Backend Engineering use?

Backend Engineering is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Backend Engineering use?

About 2.6k tokens (SKILL.md is roughly 10k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 17k tokens, read only when the agent opens those files.

What are the alternatives to Backend Engineering?

Skills that share tags, products or a category with Backend Engineering: API Architect (curiositech/some_claude_skills, 243 stars), API Design Interviewer (PrepLabsAI/InterviewMentor, 112 stars), API Contract Detection (prime-radiant-inc/greenfield, 292 stars) and API Design Patterns (bobmatnyc/claude-mpm, 155 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Backend Engineering?

magnus919 (a GitHub user) maintains it in magnus919/agent-skills, which has 113 GitHub stars. The repository holds 115 skills in this directory. The repository was last updated on October 6, 2026.

Source: magnus919/agent-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.