feature:create

Full Feature creation orchestration from Serverpod backend to Flutter frontend

항목	내용
Invoke	/feature:create
Aliases	/feature, /feature:new
Category	petmedi-workflow
Complexity	complex
MCP Servers	serena, sequential, context7, magic

/feature:create#

Context Framework Note: This behavioral instruction activates when Claude Code users type /feature:create patterns.

Triggers#

When creating a new Feature from start to finish
When implementing Serverpod backend and Flutter frontend simultaneously
When a complete Clean Architecture workflow is needed

Context Trigger Pattern#

/feature:create {feature_name} {entity_name} [--options]

Parameters#

Parameter	Required	Description	Example
`feature_name`	✅	Feature module name (snake_case)	`community`, `chat`, `wallet`
`entity_name`	✅	Entity name (PascalCase)	`Post`, `Message`, `Transaction`
`--location`	❌	Location	`application` , `common` , `console` (default: `application` )
`--caching`	❌	Caching strategy	`swr`, `cache-first`, `none` (default: `swr`)
`--endpoint-type`	❌	Endpoint type	`app`, `console`, `both` (default: `app`)
`--fields`	❌	Field Definition	`"title:String, content:String"`
`--with-bdd`	❌	BDD Test Generation	`true`, `false` (default: `true`)
`--bdd-from`	❌	BDD Scenario source	`claudedocs/{feature}/bdd/`

Execution Flow#

┌─────────────────────────────────────────────────────────┐
│  Phase 1: Requirements gathering (Interactive)                      │
├─────────────────────────────────────────────────────────┤
│  1. Feature/Entity 이름 확인                              │
│  2. 필드 정의 수집                                        │
│  3. CRUD 메서드 범위 확인                                  │
│  4. 캐싱 전략 선택                                        │
│  5. BDD 테스트 포함 여부 확인                               │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  Phase 2: Backend implementation                                    │
├─────────────────────────────────────────────────────────┤
│  Step 1: /serverpod:model                                │
│  Step 2: /serverpod:endpoint                             │
│  Step 3: melos run backend:pod:generate                  │
│  Step 4: 마이그레이션 (필요 시)                             │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  Phase 3: Frontend implementation                                   │
├─────────────────────────────────────────────────────────┤
│  Step 5: /feature:domain                                 │
│  Step 6: /feature:data                                   │
│  Step 7: /feature:presentation                           │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  Phase 4: BDD 테스트 생성 (--with-bdd true 시) ⭐          │
├─────────────────────────────────────────────────────────┤
│  Step 8: /bdd:generate {feature_name}                    │
│  Step 9: melos run test:bdd:generate --scope={feature}   │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  Phase 5: Integration and verification                                     │
├─────────────────────────────────────────────────────────┤
│  Step 10: DI 등록 확인                                    │
│  Step 11: Route 등록 확인                                  │
│  Step 12: melos run build                                │
│  Step 13: melos run analyze                              │
│  Step 14: melos run test --scope={feature}               │
│  Step 15: melos run test:bdd --scope={feature}           │
└─────────────────────────────────────────────────────────┘

Phase 1: Requirements Gathering#

Interactive Mode#

## Feature Creation Requirements

### default 정보
- **Feature name**: {feature_name}
- **Entity name**: {entity_name}
- **Location**: application / common / console

### Entity Fields
| Field Name | Type | Required | Description |
|--------|------|------|------|
| title | String | ✅ | Title |
| content | String | ✅ | Content |
| category | Enum | ✅ | Category |

### CRUD Methods
- [x] List query (pagination)
- [x] Single item query
- [x] Create
- [x] Update
- [x] Delete

### Caching Strategy
- [x] SWR (Stale-While-Revalidate)
- [ ] Cache-First
- [ ] None

Phase 2: Backend Implementation#

Step 1: Serverpod Model#

# Run /serverpod:model command
/serverpod:model {feature_name} {entity_name}
  --fields  " {fields} " 
   --has-crud true

Generated Files:

backend/.../model/entities/{entity_name}.spy.yaml
backend/.../model/dto/...
backend/.../model/enum/...

Step 2: Serverpod Endpoint#

# Run /serverpod:endpoint command
/serverpod:endpoint {feature_name} {entity_name}
  --type {endpoint_type}

Generated Files:

backend/.../endpoint/{feature_name}_endpoint.dart
backend/.../service/{feature_name}_service.dart

Step 3: Code Generation#

melos run backend:pod:generate

Step 4: Migration#

melos run backend:pod:create-migration
melos run backend:pod:run-migration

Phase 3: Frontend Implementation#

Step 5: Domain Layer#

# Run /feature:domain command
/feature:domain {feature_name} {entity_name}
  --location {location}

Generated Files:

Entity, Repository Interface, UseCase
UseCase Test

Step 6: Data Layer#

# Run /feature:data command
/feature:data {feature_name} {entity_name}
  --location {location}
  --caching {caching}

Generated Files:

Repository Implementation체, Serverpod Mixin
Cache Strategy, Local DB (Drift)

Step 7: Presentation Layer#

# Run /feature:presentation command
/feature:presentation {feature_name} {entity_name}
  --location {location}

Generated Files:

BLoC (Event, State), BLoC Test
Page, Widget, Widget Test
Route, Widgetbook UseCase

Phase 4: BDD Test Generation#

--with-bdd true (default) executed:

Step 8: BDD Scenario and Step Generation#

# Run /bdd:generate command
/bdd:generate {feature_name}
  --entity-name {entity_name}
  --location {location}
  --from-claudedocs true  # claudedocs에 BDD 파일이 있는 경우

Generated Files:

feature/{location}/{feature_name}/
├── build.yaml                    # BDD 빌더 설정
└── test/src/bdd/
    ├── {feature}_list.feature
    ├── {feature}_detail.feature
    ├── {feature}_form.feature
    ├── step/
    │   ├── common_steps.dart     # 공용 스텝 import
    │   └── {feature}_steps.dart  # Feature 전용 스텝
    └── hooks/
        └── hooks.dart            # Setup/Teardown

Step 9: Generate BDD test code#

# Run bdd_widget_test builder
melos run test:bdd:generate --scope={feature_name}

Generation result: Auto-generated test code from .feature files

Phase 5: Integration and Verification#

Step 10: Dependency Wiring Verification#

Items to verify: No di/ folder, no getIt usage, direct BlocProvider creation

// 페이지에서 BLoC 직접 생성
BlocProvider(create: (_) => {Feature}Bloc())

Step 9: Route Registration Verification#

File to verify: app/petmedi/lib/src/route/app_router.dart

Step 10-12: Build and test#

melos run build
melos run analyze
melos run test --scope={feature_name}

TodoWrite Template#

TodoWrite([
  // Backend
  {"content": "Generate Serverpod model", "status": "pending", "activeForm": "Generate Serverpod model in progress"},
  {"content": "Generate Serverpod endpoint", "status": "pending", "activeForm": "Generate Serverpod endpoint in progress"},
  {"content": "backend:pod:generate 실행", "status": "pending", "activeForm": "backend:pod:generate running"},

  // Frontend - Domain
  {"content": "Generate Domain Entity", "status": "pending", "activeForm": "Generate Domain Entity in progress"},
  {"content": "Generate Repository Interface", "status": "pending", "activeForm": "Generate Repository Interface in progress"},
  {"content": "Generate UseCase", "status": "pending", "activeForm": "Generate UseCase in progress"},
  {"content": "Generate UseCase tests", "status": "pending", "activeForm": "Generate UseCase tests in progress"},

  // Frontend - Data
  {"content": "Generate Repository implementation", "status": "pending", "activeForm": "Generate Repository implementation in progress"},
  {"content": "Generate Serverpod Mixin", "status": "pending", "activeForm": "Generate Serverpod Mixin in progress"},

  // Frontend - Presentation
  {"content": "Generate BLoC", "status": "pending", "activeForm": "Generate BLoC in progress"},
  {"content": "Generate BLoC tests", "status": "pending", "activeForm": "Generate BLoC tests in progress"},
  {"content": "Generate Page/Widget", "status": "pending", "activeForm": "Generate Page/Widget in progress"},
  {"content": "Generate Widget tests", "status": "pending", "activeForm": "Generate Widget tests in progress"},
  {"content": "Define Routes", "status": "pending", "activeForm": "Define Routes in progress"},
  {"content": "Generate Widgetbook UseCase", "status": "pending", "activeForm": "Generate Widgetbook UseCase in progress"},

  // BDD 테스트 (--with-bdd true 시)
  {"content": "Generate BDD .feature files", "status": "pending", "activeForm": "Generate BDD .feature files in progress"},
  {"content": "Generate BDD Step definitions", "status": "pending", "activeForm": "Generate BDD Step definitions in progress"},
  {"content": "Configure BDD Hooks", "status": "pending", "activeForm": "Configure BDD Hooks in progress"},
  {"content": "Generate BDD test code", "status": "pending", "activeForm": "Generate BDD test code in progress"},

  // Integration
  {"content": "Code generation and analysis", "status": "pending", "activeForm": "Code generation and analysis in progress"},
  {"content": "Run unit tests", "status": "pending", "activeForm": "Run unit tests in progress"},
  {"content": "Run BDD tests", "status": "pending", "activeForm": "Run BDD tests in progress"},
])

MCP Integration#

Phase	MCP Server	Purpose
Requirements analysis	Sequential	Complex analysis and planning
Backend	Serena, Context7	Pattern analysis, Serverpod Document
Domain	Serena, Context7	UseCase Pattern, Clean Architecture
Data	Serena, Context7	Mixin Pattern, Drift Document
Presentation	Magic, Serena	UI generation, BLoC Pattern
Verification	Serena	Symbol search, reference verification

Reference Agents#

Reference ~/.claude/commands/agents/feature-orchestrator-agent.md for detailed implementation rules

Examples#

Create Community Post Feature#

/feature:create community Post
  --location application
  --caching swr
  --endpoint-type app
  --fields  " title:String, content:String, category:PostCategory, imageUrls:List < String > ? "

Create Chat Message Feature#

/feature:create chat Message
  --location application
  --caching cache-first
  --endpoint-type app
  --fields  " content:String, senderId:int, chatRoomId:int, readAt:DateTime? "

Create Admin Dashboard Feature#

/feature:create dashboard Stats
  --location console
  --caching none
  --endpoint-type console
  --fields  " totalUsers:int, totalPosts:int, activeUsers:int "

Success Criteria#

✅ All files generated in correct locations
✅ melos run analyze No errors
✅ melos run test --scope={feature_name} Passes
✅ melos run test:bdd --scope={feature_name} Passes (--with-bdd true when)
✅ DI Registration complete
✅ Route Registration complete
✅ Components verifiable from Widgetbook
✅ BDD .feature File Gherkin 문법 준수

Core Rules Summary#

Backend#

Korean comments on all fields
Follow import order
Separate business logic into Service

Domain#

UseCase const constructor + Optional Constructor Injection
getIt/@injectable prohibited
All UseCase tests required

Data#

Serverpod Mixin as pod namespace required
SWR/Cache-First caching strategy

Presentation#

BLoC Event: sealed class + private implementation
UseCase Optional Constructor Injection (Bloc(useCase: mockUseCase) Test)
Widget super.key last position
BLoC/Widget tests required
Widgetbook reflection required