Agent skill

Moai Domain Backend

by modu-ai in modu-ai/moai-adk

Backend development specialist covering API design, database integration, microservices architecture, and modern backend patterns.

Apache-2.0Auto-check passedBackend & APIs

Install Moai Domain Backend

skills CLI
$ npx skills add modu-ai/moai-adk --skill moai-domain-backend -a claude-code

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

GitHub CLI
$ gh skill install modu-ai/moai-adk moai-domain-backend --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/modu-ai/moai-adk.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/moai-domain-backend .claude/skills/moai-domain-backend && 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
moai-domain-backend
GitHub stars
1.2k
Token cost
~2.1k tokens
SKILL.md length
887 words
Files
1
Skills in repo
48
Repo updated
First seen
Licence
Apache-2.0

At a glance

Backend development specialist covering API design, database integration, microservices architecture, and modern backend patterns.

  • Implementing server logic
  • SKILL.md covers Quick Reference, Implementation Guide, Advanced Patterns and Works Well With, plus 4 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
  • Tasks that involve Backend development

What it does

Moai Domain Backend is an agent skill from modu-ai/moai-adk. Backend development specialist covering API design, database integration, microservices architecture, and modern backend patterns. Use when designing APIs, implementing server logic, authentication, or authorization.

Its SKILL.md is about 2.1k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts. Compatibility notes: Designed for Claude Code

It sits in Backend & APIs, covering Backend development, Microservices and API design. It works with GraphQL. The repository describes itself as: Agentic development harness for Claude Code — SPEC-driven plan/run/sync, TRUST 5 quality gates, model+effort routing, and Claude×GLM multi-LLM cost control. Single Go binary, 16… The licence is Apache-2.0.

When your agent uses it

  • Implementing server logic
  • Tasks that involve Backend development
  • Tasks that involve Microservices

Example prompts

  • “/moai-domain-backend”

Requirements

  • Python 3
  • Node.js
  • Docker
  • Compatibility (from SKILL.md): Designed for Claude Code
  • Pre-approved tools (allowed-tools): Read, Write, Edit, Bash(npm:*), Bash(npx:*), Bash(node:*), Bash(uv:*), Bash(pip:*), Bash(pytest:*), Bash(ruff:*), Bash(docker:*), Bash(curl:*), Bash(go:*), Bash(cargo:*), Grep, Glob

What it can do on your machine

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

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Write
    • Edit
    • Bash(npm:*)
    • Bash(npx:*)
    • Bash(node:*)
    • Bash(uv:*)
    • Bash(pip:*)
    • Bash(pytest:*)
    • Bash(ruff:*)

    …and 6 more on the same allowed-tools line.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    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.

  • Compatibility

    Designed for Claude Code

    From compatibility in the SKILL.md frontmatter.

Context cost

Moai Domain Backend loads about 2.1k tokens when it runs. Until then it costs about 59 tokens; SKILL.md has 887 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~59
When it runs · the whole SKILL.md, loaded when a task matches
~2.1k

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); files beside SKILL.md are not scanned.

SKILL.md

The full file from modu-ai/moai-adk at commit 2aab5f7, republished under its Apache-2.0 licence (© modu-ai). 887 words, ~2,114 tokens.

Download SKILL.mdSave it as .claude/skills/moai-domain-backend/SKILL.md (or your agent's skills folder).
name
moai-domain-backend
description
Backend development specialist covering API design, database integration, microservices architecture, and modern backend patterns. Use when designing APIs, implementing server logic, authentication, or authorization.
allowed-tools
Read, Write, Edit, Bash(npm:*), Bash(npx:*), Bash(node:*), Bash(uv:*), Bash(pip:*), Bash(pytest:*), Bash(ruff:*), Bash(docker:*), Bash(curl:*), Bash(go:*), Bash(cargo:*), Grep, Glob
compatibility
Designed for Claude Code
when_to_use
Use for backend work: API design (REST, GraphQL, gRPC), server logic, authentication and authorization, microservices, middleware, caching, and frameworks…
license
Apache-2.0
user-invocable
false
metadata.version
1.0.0
metadata.category
domain
metadata.status
active
metadata.updated
2026-01-11
metadata.modularized
false
metadata.tags
backend, api, database, microservices, architecture
metadata.author
MoAI-ADK Team

Backend Development Specialist

Quick Reference

Backend Development Mastery - Comprehensive backend development patterns covering API design, database integration, microservices, and modern architecture patterns.

Core Capabilities:

  • API Design: REST, GraphQL, gRPC with OpenAPI 3.1
  • Database Integration: PostgreSQL, MongoDB, Redis, caching strategies
  • Microservices: Service mesh, distributed patterns, event-driven architecture
  • Security: Authentication, authorization, OWASP compliance
  • Performance: Caching, optimization, monitoring, scaling

When to Use:

  • Backend API development and architecture
  • Database design and optimization
  • Microservices implementation
  • Performance optimization and scaling
  • Security integration for backend systems

Implementation Guide

API Design Patterns

RESTful API Architecture:

Create a FastAPI application with authentication and response models. Define a Pydantic UserResponse model with id, email, and name fields. Implement list_users and create_user endpoints with HTTPBearer security dependency. The list endpoint returns a list of UserResponse objects, while the create endpoint accepts a UserCreate model and returns a single UserResponse.

GraphQL Implementation:

Use Strawberry to define GraphQL types. Create a User type with id, email, and name fields. Define a Query type with a users resolver that returns a list of User objects asynchronously. Generate the schema by passing the Query type to strawberry.Schema.

Database Integration Patterns

PostgreSQL with SQLAlchemy:

Define SQLAlchemy models using declarative_base. Create a User model with id as primary key, email as unique string, and name as string column. Configure the engine with connection pooling parameters including pool_size of 20, max_overflow of 30, and pool_pre_ping enabled for connection health checks.

MongoDB with Motor:

Create a UserService class that initializes with an AsyncIOMotorClient. Set up the database and users collection in the constructor. Create indexes for email (unique) and created_at fields. Implement create_user method that inserts a document and returns the inserted_id as string.

Microservices Architecture

Service Discovery with Consul:

Create a ServiceRegistry class that connects to Consul. Implement register_service method that registers a service with name, id, port, and health check endpoint. Implement discover_service method that queries healthy services and returns list of address:port strings.

Event-Driven Architecture:

Create an EventBus class using aio_pika for AMQP messaging. Implement connect method to establish connection and channel. Implement publish_event method that serializes event type and data as JSON and publishes to the default exchange with routing_key matching the event type.


Advanced Patterns

Caching Strategies

Redis Integration:

Create a CacheManager class with Redis connection. Implement a cache_result decorator that accepts ttl parameter. The decorator generates cache keys from function name and arguments, checks Redis for cached results, executes the function on cache miss, and stores results with expiration. Use json.loads and json.dumps for serialization.

Security Implementation

JWT Authentication:

Create a SecurityManager class with CryptContext for bcrypt password hashing. Implement hash_password and verify_password methods using the context. Implement create_access_token that encodes a JWT with expiration time using HS256 algorithm. Default expiration is 15 minutes if not specified.

Performance Optimization

Database Connection Pooling:

Create an optimized SQLAlchemy engine with QueuePool, pool_size 20, max_overflow 30, pool_pre_ping enabled, and pool_recycle of 3600 seconds. Add event listeners for before_cursor_execute and after_cursor_execute to track query timing. Log warnings for queries exceeding 100ms threshold.


Works Well With

  • moai-domain-frontend - Full-stack development integration
  • moai-domain-database - Advanced database patterns
  • moai-foundation-core - MCP server development patterns for backend services
  • moai-foundation-quality + moai-ref-owasp-checklist - Security validation and compliance
  • moai-foundation-core - Core architectural principles

Show full SKILL.md (372 more words)Show less

Technology Stack

Primary Technologies:

  • Languages: Python 3.13+, Node.js 20+, Go 1.23
  • Frameworks: FastAPI, Django, Express.js, Gin
  • Databases: PostgreSQL 16+, MongoDB 7+, Redis 7+
  • Message Queues: RabbitMQ, Apache Kafka, Redis Pub/Sub
  • Containerization: Docker, Kubernetes
  • Monitoring: Prometheus, Grafana, OpenTelemetry

Integration Patterns:

  • RESTful APIs with OpenAPI 3.1
  • GraphQL with Apollo Federation
  • gRPC for high-performance services
  • Event-driven architecture with CQRS
  • API Gateway patterns
  • Circuit breakers and resilience patterns

Status: Production Ready Maintained by: MoAI-ADK Backend Team

<!-- moai:evolvable-start id="rationalizations" -->

Common Rationalizations

RationalizationReality
"Input validation can happen on the frontend"Frontend validation is UX. Backend validation is security. They serve different purposes and both are required.
"This endpoint is internal, it does not need authentication"Internal endpoints are reachable from compromised services. Zero-trust means every endpoint validates identity.
"I will add error handling later"Unhandled errors leak stack traces, connection strings, and internal state. Error handling is day-one work.
"The ORM handles SQL injection"ORMs protect parameterized queries. Raw queries, dynamic filters, and ORDER BY clauses still need escaping.
"This API is backward-compatible, no version bump needed"Removing optional fields, changing defaults, or altering error formats are breaking changes to existing callers.
"Microservices are overkill, I will just add another endpoint"Unbounded endpoint growth creates a monolith-in-disguise. Evaluate service boundaries before adding.

Hyrum's Law: With a sufficient number of users, every observable behavior of your API will be depended on by somebody. Changing anything, no matter how trivial, can break someone.

<!-- moai:evolvable-end -->
<!-- moai:evolvable-start id="red-flags" -->

Red Flags

  • API endpoint accepts user input without validation or sanitization
  • Error response includes stack trace or internal path information
  • Database credentials hardcoded in source code instead of environment variables
  • No rate limiting configured on public-facing endpoints
  • API returns 200 OK for every failure case with error in the response body
  • Raw SQL queries built with string concatenation
<!-- moai:evolvable-end -->
<!-- moai:evolvable-start id="verification" -->

Verification

  • Every endpoint validates input before processing (show validation middleware or checks)
  • Error responses use standard format without internal details (show sample error response)
  • Credentials sourced from environment variables, not config files (grep for hardcoded secrets)
  • Rate limiting configured on public endpoints (show middleware registration)
  • API versioning strategy documented and enforced
  • Database queries use parameterized statements (no string concatenation with user input)
  • Authentication required on all non-public endpoints (show auth middleware)
<!-- moai:evolvable-end -->

© modu-ai, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/moai-domain-backend of modu-ai/moai-adk.

Open the folder on GitHubat commit 2aab5f7

Compare with similar skills

Moai Domain Backend 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.

Moai Domain Backend compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Moai Domain Backend this skillmodu-ai/moai-adk1.2k—~2.1kAutomated safety check: PassApache-2.0
Nodejs Backend Patternsever-works/ever-works16218 repos~4kAutomated safety check: PassAGPL-3.0
Backend DevelopmentMoizIbnYousaf/ai-agent-skills1.1k—~853Automated safety check: PassMIT
API Design InterviewerPrepLabsAI/InterviewMentor112—~2.6kAutomated safety check: PassMIT
Senior Backendalirezarezvani/claude-skills28k1 repos~3.8kAutomated safety check: PassMIT
API Designericrisco/rsc-harness180—~3.1kAutomated safety check: PassMIT

Similar skills

  • Nodejs Backend Patterns

    ever-works/ever-works

    Build production-ready Node.js backend services with Express/Fastify, implementing middleware patterns, error handling, authentication, database integration, and API design best practices.

    162 GitHub starsUsed in 18 repos~4k tokens
    Backend & APIsAuto-check passed
  • Backend Development

    MoizIbnYousaf/ai-agent-skills

    Backend API design, database architecture, microservices patterns, and test-driven development.

    1.1k GitHub stars~853 tokensUpdated 19 days ago
    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 4 days ago
    Backend & APIsAuto-check passed
  • Senior Backend

    alirezarezvani/claude-skills

    Designs and implements backend systems including REST APIs, microservices, database architectures, authentication flows, and security hardening.

    28k GitHub starsUsed in 1 repo~3.8k tokens
    Backend & APIsAuto-check passed
  • API Design

    ericrisco/rsc-harness

    A skill your agent uses when settling the contract of an API you expose, before implementation: resources/URLs, REST vs GraphQL, versioning, one RFC 9457 error envelope, pagination, idempotency —…

    180 GitHub stars~3.1k tokensUpdated yesterday
    Backend & APIsAuto-check passed
  • Backend Design

    itseffi/agentic-os

    Design backend architecture for implementation with API contracts, data model changes, service boundaries, security, and observability.

    114 GitHub stars~474 tokensUpdated 3 days ago
    Backend & APIsAuto-check passed

More from modu-ai/moai-adk

All 48 skills in this repo
  • Builds hand-editable SVG diagrams from computed layout coordinates, lints the source and renders a 2x PNG, with rules for when mermaid is the better choice.

    1.2k GitHub stars~5.2k tokensUpdated yesterday
    Auto-check: notes
  • MoAI Foundation Core

    modu-ai/moai-adk

    Reference for MoAI-ADK's core development principles: TRUST 5 quality gates, SPEC-first domain-driven workflow, agent delegation and token budgeting.

    1.2k GitHub stars~5k tokensUpdated yesterday
    Auto-check passed
  • MoAI SPEC Workflow

    modu-ai/moai-adk

    Manages SPEC documents for MoAI-ADK development, with GEARS or EARS requirement notation, acceptance criteria and a link into the Plan-Run-Sync workflow.

    1.2k GitHub stars~5.1k tokensUpdated yesterday
    Auto-check passed
  • MoAI TDD Workflow

    modu-ai/moai-adk

    Drives test-first development through the RED, GREEN, REFACTOR cycle, with a config switch that selects between TDD and a DDD workflow for existing code.

    1.2k GitHub stars~3.1k tokensUpdated yesterday
    Auto-check passed
  • MoAI Worktree Management

    modu-ai/moai-adk

    Gives each SPEC its own Git worktree with a registry of active workspaces, base-branch sync and cleanup of merged ones, inside the MoAI-ADK workflow.

    1.2k GitHub stars~3.9k tokensUpdated yesterday
    Auto-check passed
  • Watches a pull request's CI checks after creation, separates required from auxiliary failures, applies limited safe fixes and escalates anything semantic to you.

    1.2k GitHub stars~2.4k tokensUpdated yesterday
    Auto-check: notes

Works with

Categories

Questions about Moai Domain Backend

What does Moai Domain Backend do?

Backend development specialist covering API design, database integration, microservices architecture, and modern backend patterns. Moai Domain Backend is an agent skill from modu-ai/moai-adk. Backend development specialist covering API design, database integration, microservices architecture, and modern backend patterns.

When should I use Moai Domain Backend?

Moai Domain Backend fits situations like: implementing server logic; tasks that involve Backend development; tasks that involve Microservices.

How do I install Moai Domain Backend in Claude Code?

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

How do I install Moai Domain Backend in Codex?

Run `npx skills add modu-ai/moai-adk --skill moai-domain-backend -a codex`. Or copy the skill folder (.claude/skills/moai-domain-backend in modu-ai/moai-adk) into .agents/skills/moai-domain-backend in your project. Codex loads it when a task matches its description.

Can I use Moai Domain Backend 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 modu-ai/moai-adk --skill moai-domain-backend -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/moai-domain-backend, .gemini/skills/moai-domain-backend, .github/skills/moai-domain-backend and .opencode/skills/moai-domain-backend in your project.

What does Moai Domain Backend need to run?

SKILL.md names no scripts, command-line tools or credentials: Moai Domain Backend is instructions for the agent only. Our summary lists: Python 3; Node.js; Docker. Its frontmatter pre-approves these tools: Read, Write, Edit, Bash(npm:*), Bash(npx:*), Bash(node:*), Bash(uv:*), Bash(pip:*), Bash(pytest:*), Bash(ruff:*), Bash(docker:*), Bash(curl:*), Bash(go:*), Bash(cargo:*), Grep, Glob. Compatibility (from SKILL.md): Designed for Claude Code.

Does Moai Domain Backend 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 Moai Domain Backend 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. Review the folder before installing.

What licence does Moai Domain Backend use?

Moai Domain Backend is published under the Apache-2.0 licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Moai Domain Backend use?

About 2.1k tokens (SKILL.md is roughly 8.5k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Moai Domain Backend?

Skills that share tags, products or a category with Moai Domain Backend: Nodejs Backend Patterns (ever-works/ever-works, 162 stars), Backend Development (MoizIbnYousaf/ai-agent-skills, 1.1k stars), API Design Interviewer (PrepLabsAI/InterviewMentor, 112 stars) and Senior Backend (alirezarezvani/claude-skills, 28k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Moai Domain Backend?

modu-ai (a GitHub organization) maintains it in modu-ai/moai-adk, which has 1,230 GitHub stars. The repository holds 48 skills in this directory. The repository was last updated on October 9, 2026.

Source: modu-ai/moai-adk on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.