traya-backend-engineering

Create a new slash command in `.claude/commands/` for backend development tasks.

Transform backend feature descriptions, bug reports, API design ideas, or infrastructure improvements into well-structured markdown files that follow project conventions and best practices. This command provides flexible detail levels to match your backend development needs.

Resolve all TODO comments using parallel processing for backend development tasks.

<command_purpose> Perform exhaustive backend code reviews using multi-agent analysis, ultra-thinking, and Git worktrees for deep local inspection of APIs, databases, and services. </command_purpose>

Present all findings, decisions, or issues here one by one for triage. The goal is to go through each item and decide whether to add it to the CLI todo system.

This command helps you analyze a backend work document (plan, Markdown file, API specification, database design, or any structured document), create a comprehensive todo list using the TodoWrite tool, and then systematically execute each task until the entire plan is completed. It combines deep analysis with practical execution to transform backend plans into production-ready APIs and services.

Use this agent when you need to design REST or GraphQL APIs, create OpenAPI specifications, or architect scalable API endpoints. This agent specializes in API design patterns, RESTful principles, GraphQL schema design, and generating industry-standard documentation. Examples include designing endpoint structures, creating OpenAPI/Swagger specs, architecting GraphQL schemas, or refactoring existing APIs to follow best practices.

Use this agent when you need to create comprehensive API documentation including OpenAPI 3.0/3.1 specs, Swagger UI integration, AsyncAPI for event-driven APIs, GraphQL schemas, and Postman collections. This agent specializes in all API documentation formats and standards. Examples include generating OpenAPI specs from code, creating Swagger documentation, documenting WebSocket APIs with AsyncAPI, generating GraphQL SDL, or exporting Postman collections.

Use this agent when you need to design backend architecture, make architectural decisions, or plan system scalability. This agent specializes in microservices, monolithic architectures, design patterns, system design, scalability planning, and architectural best practices. Examples include designing new services, refactoring architecture, planning for scale, or making technology choices.

Use this agent when you need to design database schemas, model relationships, or architect data structures for PostgreSQL and MongoDB. This agent specializes in relational and document database design, normalization, indexing strategies, and query optimization. Examples include designing database schemas, planning migrations, modeling complex relationships, or optimizing database performance.

Use this agent when you need to build Express.js applications, implement middleware patterns, create route handlers, or work with Express-specific features. This agent specializes in Express architecture, middleware chains, error handling, and building scalable server applications with TypeScript. Examples include creating API routes, implementing custom middleware, handling file uploads, or refactoring code to follow Express best practices.

Use this agent when you need to build NestJS applications, implement dependency injection patterns, create modules and providers, or work with NestJS-specific features like guards, interceptors, and decorators. This agent specializes in NestJS architecture, TypeScript best practices, and building scalable server-side applications. Examples include creating REST controllers, implementing GraphQL resolvers, building custom decorators, or refactoring code to follow NestJS patterns.

Use this agent when you need to analyze and optimize backend performance, identify bottlenecks, or improve application scalability. This agent specializes in profiling, query optimization, caching strategies, load testing, and performance monitoring. Examples include analyzing slow endpoints, optimizing database queries, implementing caching, or load testing APIs.

Use this agent when you need to implement caching, session management, rate limiting, or real-time features with Redis. This agent specializes in Redis data structures, caching strategies, pub/sub patterns, and performance optimization. Examples include implementing cache layers, managing user sessions, building rate limiters, or designing real-time notification systems.

Use this agent when you need to audit backend security, implement authentication/authorization, or follow security best practices. This agent specializes in JWT authentication, role-based access control (RBAC), input validation, SQL injection prevention, XSS protection, and security auditing. Examples include implementing authentication flows, securing API endpoints, preventing common vulnerabilities, or conducting security reviews.

Use this agent when you need to write comprehensive tests for backend applications using Jest, Supertest, and other testing frameworks. This agent specializes in unit tests, integration tests, E2E tests, test-driven development, and test coverage optimization. Examples include writing test suites, implementing integration tests, creating E2E test scenarios, or improving test coverage.

Use this agent when you need to work with TypeORM entities, repositories, migrations, or query builders. This agent specializes in TypeORM best practices, entity relationships, advanced querying, transaction management, and migration strategies. Examples include creating entities, implementing repositories, writing migrations, optimizing queries with QueryBuilder, or refactoring TypeORM code.

Use this agent when you need to review backend TypeScript code, enforce type safety, or improve TypeScript patterns in Node.js applications. This agent specializes in TypeScript best practices, advanced types, generic patterns, and ensuring type safety across backend services. Examples include reviewing code for type errors, implementing proper generics, refactoring to leverage TypeScript features, or establishing TypeScript conventions.