backend-agent

Category: Development & Coding | Uploader: first-fluke | Downloads: 0 | Version: v1.0（Latest）

Backend specialist for APIs, databases, and authentication. Stack-agnostic: Python, TypeScript, or Go. Use for API, endpoint, REST, database, server, migration, and auth work.

Changelog: Source: GitHub https://github.com/first-fluke/composer

Directory Structure

Current level: .agents/skills/backend-agent/

📁 resources/
- 📁 snippets/
  - 📄 go.md 10.0 KB
  - 📄 python.md 10.5 KB
  - 📄 README.md 539 B
  - 📄 typescript.md 8.6 KB
- 📁 templates/
  - 📄 go.md 12.9 KB
  - 📄 python.md 8.7 KB
  - 📄 README.md 458 B
  - 📄 typescript.md 9.9 KB
- 📄 checklist.md 1.8 KB
- 📄 error-playbook.md 4.1 KB
- 📄 examples.md 2.0 KB
- 📄 execution-protocol.md 2.2 KB
- 📄 orm-reference.md 3.9 KB
- 📄 tech-stack.md 1.9 KB
📄 SKILL.md 4.5 KB

SKILL.md

---
name: backend-agent
description: "Backend specialist for APIs, databases, and authentication. Stack-agnostic: Python, TypeScript, or Go. Use for API, endpoint, REST, database, server, migration, and auth work."
---

# Backend Agent - API & Server Specialist

## When to use
- Building REST APIs or GraphQL endpoints
- Database design and migrations
- Authentication and authorization
- Server-side business logic
- Background jobs and queues

## When NOT to use
- Frontend UI -> use Frontend Agent
- Mobile-specific code -> use Mobile Agent

## Core Rules

1. **DRY (Don't Repeat Yourself)**: Business logic in `Service`, data access logic in `Repository`
2. **SOLID**:
   - **Single Responsibility**: Classes and functions should have one responsibility
   - **Dependency Inversion**: Use the framework's DI mechanism to inject dependencies
3. **KISS**: Keep it simple and clear

## Architecture Pattern

```
Router (HTTP) → Service (Business Logic) → Repository (Data Access) → Models
```

### Repository Layer
- **File**: `src/[domain]/repository.[ext]`
- **Role**: Encapsulate DB CRUD and query logic
- **Principle**: No business logic, return data models

### Service Layer
- **File**: `src/[domain]/service.[ext]`
- **Role**: Business logic, Repository composition, external API calls
- **Principle**: Business decisions only here

### Router Layer
- **File**: `src/[domain]/router.[ext]`
- **Role**: Receive HTTP requests, input validation, call Service, return response
- **Principle**: No business logic, inject Service via DI

## Core Rules

1. **Clean architecture**: router → service → repository → models
2. **No business logic in route handlers**
3. **All inputs validated with the stack's schema library**
4. **Parameterized queries only** (never string interpolation)
5. **JWT + bcrypt for auth**; rate limit auth endpoints
6. **Async/await (or idiomatic concurrency) consistently**; type hints/annotations on all signatures
7. **Custom exceptions** in a shared lib module (not raw HTTP errors in business logic)
8. **Explicit ORM loading strategy**: do not rely on default relation loading when query shape matters
9. **Explicit transaction boundaries**: group one business operation into one request/service-scoped unit of work
10. **Safe ORM lifecycle**: do not share mutable ORM session/entity manager/client objects across concurrent work unless the ORM explicitly supports it

## Dependency Injection (pseudocode — adapt to stack)

```
# dependencies module
function get_resource_service(db = inject(get_db)) -> ResourceService:
    repository = ResourceRepository(db)
    return ResourceService(repository)

# router module
@GET("/{resource_id}")
async function get_resource(resource_id, service = inject(get_resource_service)):
    return await service.get_resource(resource_id)
```

See `resources/snippets/` for stack-specific DI patterns (Python, TypeScript, Go).

## Stack Selection

Check the project's `AGENTS.md` or `README` for the chosen stack.
If not specified, use `resources/tech-stack.md` to select the most appropriate stack.

## Code Quality

- **Type safety**: Strict type hints / TypeScript strict mode / Go static types
- **Async I/O**: Required for I/O-bound operations (language-idiomatic)
- **Linting/Formatting**: Follow project's configured linter (Ruff / ESLint / golangci-lint)

## How to Execute

Follow `resources/execution-protocol.md` step by step.
See `resources/examples.md` for input/output examples.
Use `resources/orm-reference.md` when the task involves ORM query performance, relationship loading, transactions, session/client lifecycle, or N+1 analysis.
Before submitting, run `resources/checklist.md`.

## Execution Protocol (CLI Mode)

See `../_shared/execution-protocols/` for vendor-specific protocols.
When spawned via `oh-my-ag agent:spawn`, the protocol is injected automatically.

## References

- Execution steps: `resources/execution-protocol.md`
- Code examples: `resources/examples.md`
- Code snippets (stack-specific): `resources/snippets/`
- Checklist: `resources/checklist.md`
- ORM reference: `resources/orm-reference.md`
- Error recovery: `resources/error-playbook.md`
- Tech stack: `resources/tech-stack.md`
- API templates (stack-specific): `resources/templates/`
- Context loading: `../_shared/context-loading.md`
- Reasoning templates: `../_shared/reasoning-templates.md`
- Clarification: `../_shared/clarification-protocol.md`
- Context budget: `../_shared/context-budget.md`
- Lessons learned: `../_shared/lessons-learned.md`

> [!IMPORTANT]
> When adding new modules, always include package init files or module declarations to maintain package structure

Comments 0

Latest | Hot

Please login before commenting.

No comments yet. Be the first one!

backend-agent

Directory Structure

SKILL.md

Report

Notice