home / skills / shaul1991 / shaul-agents-plugin / backend-implementation

backend-implementation skill

safe

This skill orchestrates backend implementation workflow from API design to deployment, delivering structured artifacts and reliable, runnable services.

npx playbooks add skill shaul1991/shaul-agents-plugin --skill backend-implementation

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

7.7 KB

---
name: backend-implementation
description: Backend Implementation Workflow Agent. Backend만 구현이 필요한 경우 사용합니다. API 추가, 서비스 로직 구현, DB 스키마 변경 등을 오케스트레이션합니다.
allowed-tools: Read, Write, Edit, Task, AskUserQuestion, TodoWrite, Glob, Grep, Bash, Skill
---

# Backend Implementation Workflow Agent

## 역할
Backend만 구현이 필요한 경우 (API 추가, 서비스 로직, DB 변경 등)를 총괄하는 오케스트레이터입니다.

## 워크플로우 개요

```
┌─────────────────────────────────────────────────────────────┐
│                   /backend-implementation                     │
└─────────────────────────────────────────────────────────────┘
         │
         ▼
Phase 1: 설계
┌─────────────────────────────────────────────────────────────┐
│  ┌──────────────────┐      ┌──────────────────┐            │
│  │ backend-architect │  →  │ dba-architect    │            │
│  │ (API 설계)        │      │ (스키마 설계)    │            │
│  └──────────────────┘      └──────────────────┘            │
└─────────────────────────────────────────────────────────────┘
         │
         ▼
Phase 2: 구현
┌─────────────────────────────────────────────────────────────┐
│  ┌──────────────────┐                                      │
│  │ backend-developer│                                      │
│  │ (핵심 로직)       │                                      │
│  └────────┬─────────┘                                      │
│           ▼                                                │
│  ┌──────────────────┐                                      │
│  │ backend-{lang}   │  ← 사용자 선택 (Java/Kotlin/Node/Go/PHP) │
│  │ (언어별 구현)     │                                      │
│  └────────┬─────────┘                                      │
│           ▼                                                │
│  ┌──────────────────┐                                      │
│  │ dba-tuner        │                                      │
│  │ (쿼리 최적화)     │                                      │
│  └──────────────────┘                                      │
└─────────────────────────────────────────────────────────────┘
         │
         ▼
Phase 3: 검증
┌─────────────────────────────────────────────────────────────┐
│  ┌────────────┐  ┌─────────────────┐  ┌────────────────┐   │
│  │ qa-tester  │  │ security-auditor│  │ backend-reviewer│  │
│  │ (테스트)   │  │ (보안 감사)      │  │ (코드 리뷰)     │  │
│  └────────────┘  └─────────────────┘  └────────────────┘   │
│                      (병렬 실행)                             │
└─────────────────────────────────────────────────────────────┘
         │
         ▼
Phase 4: 배포
┌─────────────────────────────────────────────────────────────┐
│  ┌──────────────────┐      ┌──────────────────┐            │
│  │ devops-jenkins   │  →   │ devops-deployer  │            │
│  │ (CI/CD)          │      │ (배포)            │            │
│  └──────────────────┘      └──────────────────┘            │
└─────────────────────────────────────────────────────────────┘
```

## Phase별 상세

### Phase 1: 설계 (순차)

| 순서 | Agent | 역할 | 산출물 |
|------|-------|------|--------|
| 1 | backend-architect | API 엔드포인트 설계, 인터페이스 정의 | API 명세서 |
| 2 | dba-architect | DB 스키마 설계, 마이그레이션 생성 | 마이그레이션 파일 |

### Phase 2: 구현 (순차)

| 순서 | Agent | 역할 | 산출물 |
|------|-------|------|--------|
| 1 | backend-developer | 핵심 비즈니스 로직, 서비스 레이어 | 서비스 코드 |
| 2 | backend-{lang} | 언어별 컨트롤러, 라우터, DTO | API 구현 |
| 3 | dba-tuner | 쿼리 최적화, 인덱스 설계 | 인덱스 설정 |

**언어 선택 옵션**:
- `backend-java`: Java/Spring Boot
- `backend-kotlin`: Kotlin/Spring Boot
- `backend-node`: Node.js/NestJS/Express
- `backend-golang`: Go/Gin/Echo
- `backend-php`: PHP/Laravel

### Phase 3: 검증 (병렬)

| Agent | 역할 | 산출물 |
|-------|------|--------|
| qa-tester | 단위 테스트, 통합 테스트 | 테스트 리포트 |
| security-auditor | 보안 감사, 취약점 스캔 | 보안 리포트 |
| backend-reviewer | 코드 리뷰, 품질 검토 | 리뷰 코멘트 |

### Phase 4: 배포 (순차)

| 순서 | Agent | 역할 | 산출물 |
|------|-------|------|--------|
| 1 | devops-jenkins | CI/CD 파이프라인 실행 | 빌드 로그 |
| 2 | devops-deployer | 프로덕션 배포 | 배포 완료 |

## 산출물 디렉토리 구조

```
docs/implementation/<기능명>/backend/
├── README.md           # 구현 개요
├── api-spec.md         # API 명세
├── db-schema.sql       # DB 스키마
├── impl-notes.md       # 구현 노트
├── test-report.md      # 테스트 결과
├── security-audit.md   # 보안 감사
└── deploy-log.md       # 배포 로그
```

## 사용 방법

```bash
/backend-implementation <기능명>
```

### 예시
```bash
/backend-implementation 사용자 인증 API
/backend-implementation 결제 처리 로직
/backend-implementation 파일 업로드 기능
```

## 협업 Agent

| Agent | 용도 |
|-------|------|
| tech-implementation | 전체 구현 (Backend + Frontend) |
| frontend-implementation | Frontend 연동 필요 시 |
| dba-admin | DB 백업/복구 필요 시 |

## 주의사항

- Phase 3 검증 통과 후 자동 배포
- 보안 감사 Critical 이슈 시 배포 차단
- 테스트 커버리지 80% 미만 시 경고
- 기존 API 변경 시 하위 호환성 검토 필수

Overview

This skill coordinates backend-only implementation tasks including API additions, service logic, and database schema changes. It orchestrates design, implementation, verification, and deployment phases with specialized agents so you get repeatable, auditable backend delivery. Use it to translate feature requirements into production-ready backend artifacts and CI/CD deployment.

How this skill works

The skill runs a four-phase workflow: Phase 1 designs API and schema, Phase 2 implements core logic and language-specific controllers, Phase 3 performs parallel validation (tests, security audit, code review), and Phase 4 executes CI/CD and deployment. Each phase delegates to focused agents (backend-architect, dba-architect, backend-developer, backend-{lang}, qa-tester, security-auditor, backend-reviewer, devops-jenkins, devops-deployer) and produces concrete deliverables like API specs, migrations, code, reports, and deploy logs.

When to use it

When only backend work is required (no frontend changes).
Adding new API endpoints or modifying existing ones.
Implementing or migrating database schemas and indexes.
Building or updating core service/business logic.
Preparing backend code for CI/CD and production deployment.

Best practices

Start with clear API and DB contract files (API spec, migration) before coding.
Select the language-specific agent early (Java/Kotlin/Node/Go/PHP) to align scaffolding and DTOs.
Enforce automated tests and aim for >=80% coverage; block deployment if coverage is low.
Treat security-auditor findings as gating; resolve critical issues before release.
Keep implementation artifacts in docs/implementation/<feature>/backend/ for traceability.

Example use cases

Add a user authentication API with DB schema and migration, service layer, and tests.
Implement payment processing logic including new endpoints, DB changes, and CI/CD deploy.
Optimize a slow query path: schema migration, index changes, query tuning, and regression tests.
Create file upload backend: controller, DTOs, storage integration, security audit, and deployment.

FAQ

How do I trigger the workflow?

Run the skill with the feature name (e.g., /backend-implementation user-auth) to start the orchestration.

Which programming languages are supported?

Supported language agents: backend-java, backend-kotlin, backend-node, backend-golang, backend-php. Choose the one matching your stack.

What blocks automatic deployment?

Automatic deployment is blocked if Phase 3 returns critical security issues or test coverage is below thresholds; those must be remediated before Phase 4.