Add Backend Developer Agent

[JeremyDev87]

Add Backend Developer Agent

Summary

Add a Backend Developer Agent to Codebuddy's AI Agent system to provide specialized AI assistance for backend development tasks.

Background

Codebuddy currently provides 12 specialist agents, with frontend-developer.json included as an example Primary Developer Agent. The README mentions backend-developer.json as an example, but no actual implementation exists.

Current Agent List:

• Core Agents: frontend-developer, code-reviewer
• Domain Specialists: accessibility, architecture, design-system, documentation, performance, security, seo, test-strategy
• Utility Agents: code-quality, devops-engineer

A Backend Developer Agent is needed to utilize Codebuddy in backend development projects.

Requirements

Functional Requirements

1. Create Agent Definition File

   • Create .ai-rules/agents/backend-developer.json file
   • Follow the same structural pattern as frontend-developer.json

2. Define Backend Development Expertise Areas

   • Backend frameworks (Node.js/Express, NestJS, etc.)
   • REST API and GraphQL design
   • Database design and ORM (Prisma, TypeORM, etc.)
   • Authentication/Authorization (JWT, OAuth, Session)
   • Middleware and error handling
   • Testing strategies (Unit, Integration, E2E)

3. Integration with Existing Rules

   • Reference core.md, project.md, augmented-coding.md
   • Apply TDD workflow
   • Support PLAN/ACT/EVAL modes

Non-Functional Requirements

1. Maintain consistency with existing agent structure
2. Support integration with other specialist agents
3. Support Korean language responses

Technical Specification

File Structure

.ai-rules/agents/backend-developer.json

Agent Schema

{
  "name": "Backend Developer",
  "version": "1.0.0",
  "description": "...",
  "role": {
    "title": "Senior Backend Developer",
    "expertise": [...],
    "tech_stack_reference": "See project.md 'Tech Stack' section",
    "responsibilities": [...]
  },
  "context_files": [
    ".ai-rules/rules/core.md",
    ".ai-rules/rules/project.md",
    ".ai-rules/rules/augmented-coding.md"
  ],
  "activation": {
    "trigger": "...",
    "mandatory_checklist": {...},
    "verification_guide": {...},
    "execution_order": {...},
    "planning_framework": {...},
    "implementation_framework": {...}
  },
  "workflow": {
    "core_logic": {...},
    "api_endpoints": {...}
  },
  "development_philosophy": {
    "modern_approach": {...},
    "api_design": {...},
    "database_strategy": {...},
    "security_standards": {...}
  },
  "code_quality_checklist": [...],
  "tdd_cycle": {...},
  "ai_monitoring": {...},
  "commit_rules": {...},
  "communication": {...},
  "file_naming": {...},
  "reference": {...}
}

Key Expertise Areas

Category	Technologies
Framework	Node.js, Express, NestJS, Fastify
Language	TypeScript (strict mode)
Database	PostgreSQL, MySQL, MongoDB, Redis
ORM	Prisma, TypeORM, Drizzle
API	REST, GraphQL, gRPC
Auth	JWT, OAuth 2.0, Session, Passport.js
Testing	Jest, Supertest, Testcontainers
Validation	Zod, class-validator, Joi
Documentation	OpenAPI/Swagger, TypeDoc

Development Philosophy

1. API-First Design

   • Define OpenAPI spec first
   • Contract-First development

2. Database-First vs Code-First

   • Prioritize Prisma schema definition
   • Migration management

3. Security-First

   • Mandatory input validation
   • SQL Injection, XSS prevention
   • Rate limiting
   • CORS configuration

4. Clean Architecture

   • Layer separation (Controller → Service → Repository)
   • Dependency Injection
   • Pure functions first

Workflow Integration

┌─────────────────────────────────────────────────────┐
│                    PLAN Mode                        │
│  - API endpoint design                              │
│  - Database schema design                           │
│  - Test strategy planning                           │
│  - Security requirements review                     │
└───────────────────────┬─────────────────────────────┘
                        │ ACT
                        ▼
┌─────────────────────────────────────────────────────┐
│                     ACT Mode                        │
│  1. TDD: Write tests (Red)                          │
│  2. Minimal implementation (Green)                  │
│  3. Refactoring (Refactor)                          │
│  4. Integration tests                               │
└───────────────────────┬─────────────────────────────┘
                        │ EVAL (optional)
                        ▼
┌─────────────────────────────────────────────────────┐
│                    EVAL Mode                        │
│  - Code Reviewer Agent auto-activation              │
│  - API design review                                │
│  - Security vulnerability check                     │
│  - Performance analysis                             │
└─────────────────────────────────────────────────────┘

Specialist Integration

Backend Developer Agent integrates with the following specialist agents:

Specialist	Integration Point
Architecture	Layer structure, DI patterns, module design
Security	Authentication/Authorization, input validation, OWASP
Performance	Query optimization, caching, Connection Pool
Test Strategy	TDD vs Test-After decisions, coverage
Documentation	API docs, code comments, README
Code Quality	SOLID, DRY, complexity management

Acceptance Criteria

Must Have

• Create .ai-rules/agents/backend-developer.json file
• Apply same structural pattern as frontend-developer.json
• Support PLAN/ACT modes
• Define TDD workflow
• Configure Korean language responses
• Reference existing context_files

Should Have

• Define integration points with all specialist agents
• Define Backend-specific code_quality_checklist
• Document API design principles
• Database design guidelines

Nice to Have

• Add Backend Developer Agent section to README.md
• Example project structure template
• OpenAPI spec generation guide

Test Plan

1. Structure Validation

   • JSON file validity check
   • Required fields existence verification

2. Functional Validation

   • Verify Backend Developer Agent activation in PLAN mode
   • Verify TDD workflow operation in ACT mode
   • Verify Korean language response output

3. Integration Validation

   • Agent query availability from MCP server
   • Information retrieval via get_agent_details tool

Dependencies

• Existing .ai-rules/rules/ rule files
• Existing specialist agent JSON files