Prompt Enhancer

Prompt Enhancer

Transform brief development requests into clear, detailed requirements by analyzing project context. Present the enhanced requirements to the user for confirmation before implementation.

When to Use This Skill

Use this skill when:

• User provides a brief development request like "로그인 기능 만들어줘", "API 추가해줘"
• Request lacks specific implementation details
• User uploads project files or mentions "the project"
• Task requires understanding project architecture

Core Workflow

Step 1: Analyze Project Context

Check for uploaded files:

view /mnt/user-data/uploads

Gather key information:

• Project structure and organization
• Technology stack (package.json, pubspec.yaml, requirements.txt, etc.)
• Existing patterns (state management, API calls, routing)
• Code conventions (naming, file structure)
• Similar existing features

Step 2: Extract Request Intent

From the user's brief request, identify:

• Feature type: New feature, bug fix, refactoring, API integration
• Scope: Single screen, full flow, backend + frontend
• Dependencies: Related features or systems

Step 3: Build Enhanced Requirements

Create a structured requirement document with:

# [기능명] 구현 요구사항

## 📋 프로젝트 컨텍스트
- Framework: [detected framework and version]
- Architecture: [detected pattern]
- State Management: [detected library]
- Key Libraries: [list relevant dependencies]

## 🎯 구현 범위

### 주요 기능
1. [Main feature 1]
2. [Main feature 2]
3. [Main feature 3]

### 파일 구조

[Expected file structure based on project]

## 📝 상세 요구사항

### 1. [Layer/Component Name]
- **위치**: [File path]
- **목적**: [What it does]
- **구현 내용**:
  - [Specific requirement 1]
  - [Specific requirement 2]
- **기존 패턴 따르기**: [Reference to existing pattern]

### 2. [Next Layer/Component]
...

## ✅ 성공 기준
- [ ] [Acceptance criteria 1]
- [ ] [Acceptance criteria 2]
- [ ] [Acceptance criteria 3]
- [ ] 기존 코드 스타일 및 아키텍처 일관성 유지
- [ ] 모든 주요 기능에 대한 테스트 작성

## 🔍 확인 사항
- [Any questions or clarifications needed]
- [Assumptions made]

---
이 요구사항으로 진행할까요? 수정이 필요한 부분이 있다면 말씀해주세요.

Step 4: Present to User

Important: After creating the enhanced requirements, present them to the user and ask for confirmation:

위 요구사항을 분석해서 정리했습니다. 

이대로 진행해도 될까요? 
수정하거나 추가할 내용이 있으면 말씀해주세요!

Do NOT implement until the user confirms. The goal is to clarify requirements first.

Analysis Patterns by Stack

Flutter Projects

Detect: pubspec.yaml, lib/ directory

Key context to gather:

• State management (Riverpod, Bloc, Provider, GetX)
• Architecture (Clean Architecture, MVVM, MVC)
• Navigation (go_router, auto_route, Navigator)
• Network (Dio, http)
• Local storage (Hive, SharedPreferences, SQLite)

Enhanced requirements should include:

## 구현 범위

### Presentation Layer
- 화면: lib/presentation/[feature]/[screen]_screen.dart
- 상태: [StateNotifier/Bloc/Controller] with [state pattern]
- 위젯: 재사용 가능한 컴포넌트

### Domain Layer
- Entity: lib/domain/entities/[name].dart
- UseCase: lib/domain/usecases/[action]_usecase.dart
- Repository Interface: lib/domain/repositories/

### Data Layer
- Model: lib/data/models/[name]_model.dart (fromJson/toJson)
- Repository Implementation: lib/data/repositories/
- DataSource: lib/data/datasources/

### Navigation
- Route: [route path]
- Navigation method: [context.go/push based on router]

## 성공 기준
✅ [State management]로 상태 관리
✅ [Existing widget] 스타일 일관성 유지
✅ API 응답 에러 처리
✅ 로딩 상태 표시
✅ Widget test 작성

Next.js/React Projects

Detect: package.json with "next" or "react"

Key context to gather:

• Next.js version (App Router vs Pages Router)
• State management (Zustand, Redux, Context)
• Styling (Tailwind, CSS Modules, styled-components)
• API approach (Next.js API routes, external API)
• TypeScript usage

Enhanced requirements should include:

## 구현 범위

### UI Components
- 컴포넌트: [path]/[ComponentName].tsx
- Props interface: [existing pattern]
- Styling: [Tailwind classes/CSS modules]

### State Management
- Store: [existing state structure]
- Actions: [action naming convention]

### API Layer
- Endpoint: [app/api or external]
- Method: [GET/POST/PUT/DELETE]
- Response type: [TypeScript interface]

### Routing
- Route: [app/[route] or pages/[route]]
- Dynamic segments: [if needed]

## 성공 기준
✅ TypeScript 타입 안정성
✅ [Existing components] 재사용
✅ 반응형 디자인 (모바일/데스크톱)
✅ SEO 최적화 (메타데이터)
✅ Unit test + Integration test

Python (Django/FastAPI) Projects

Detect: requirements.txt, manage.py, main.py

Key context to gather:

• Framework (Django, FastAPI, Flask)
• ORM (SQLAlchemy, Django ORM, Tortoise)
• Authentication approach
• API documentation (OpenAPI/Swagger)

Enhanced requirements should include:

## 구현 범위

### Models/Schema
- Model: [app]/models.py or schemas/[name].py
- Fields: [field definitions with types]
- Relationships: [ForeignKey/relationships]

### Views/Endpoints
- Route: [path]
- Method: [HTTP method]
- Request/Response schema: [Pydantic models]

### Business Logic
- Service: [if applicable]
- Validation: [input validation]

### Database
- Migration: [migration command]

## 성공 기준
✅ API documentation 자동 생성
✅ Request validation
✅ Error handling with proper status codes
✅ Unit test + Integration test
✅ [Authentication] 적용

Example Enhancement

User input:

로그인 기능 구현해줘

Skill output:

# 로그인 기능 구현 요구사항

## 📋 프로젝트 컨텍스트
- Framework: Flutter 3.16.0 with null safety
- Architecture: Clean Architecture
- State Management: Riverpod (StateNotifier pattern)
- Network: Dio 5.3.0
- Storage: flutter_secure_storage
- Navigation: go_router

## 🎯 구현 범위

### 주요 기능
1. 이메일/비밀번호 로그인 폼
2. JWT 토큰 기반 인증
3. 로그인 성공 시 홈 화면 이동
4. 에러 처리 및 사용자 피드백

### 파일 구조

lib/ ├── presentation/ │ └── auth/ │ ├── login_screen.dart │ ├── login_notifier.dart │ └── login_state.dart ├── domain/ │ ├── entities/user.dart │ ├── usecases/login_usecase.dart │ └── repositories/auth_repository.dart └── data/ ├── models/ │ ├── user_model.dart │ └── login_response.dart ├── repositories/auth_repository_impl.dart └── datasources/auth_remote_datasource.dart

## 📝 상세 요구사항

### 1. Presentation Layer - 로그인 화면
- **위치**: lib/presentation/auth/login_screen.dart
- **목적**: 사용자 로그인 UI 제공
- **구현 내용**:
  - ConsumerStatefulWidget 사용
  - Email TextFormField (이메일 형식 검증)
  - Password TextFormField (8자 이상, obscureText)
  - 로그인 PrimaryButton
  - 회원가입 링크
  - 로딩 상태 시 오버레이 표시
- **기존 패턴 따르기**: core/widgets/custom_text_field.dart 스타일 사용

### 2. State Management
- **위치**: lib/presentation/auth/login_notifier.dart
- **목적**: 로그인 상태 관리
- **구현 내용**:
  - StateNotifier<LoginState> 상속
  - login(email, password) 메서드
  - 성공 시 토큰 저장 후 상태 업데이트
  - 에러 시 에러 메시지 상태 설정
- **기존 패턴 따르기**: 다른 notifier들과 동일한 패턴

### 3. Domain Layer - 엔티티
- **위치**: lib/domain/entities/user.dart
- **목적**: 사용자 도메인 모델
- **구현 내용**:
  - Freezed로 불변 클래스 생성
  - id, email, name, profileImageUrl 필드
- **기존 패턴 따르기**: 다른 entity들과 동일한 구조

### 4. Domain Layer - UseCase
- **위치**: lib/domain/usecases/login_usecase.dart
- **목적**: 로그인 비즈니스 로직
- **구현 내용**:
  - call(LoginParams) 메서드
  - Either<Failure, User> 반환
  - repository 의존성 주입
- **기존 패턴 따르기**: 단일 책임 UseCase 패턴

### 5. Data Layer - API 통신
- **위치**: lib/data/datasources/auth_remote_datasource.dart
- **목적**: 로그인 API 호출
- **구현 내용**:
  - POST /api/auth/login
  - Request: {"email": string, "password": string}
  - Response: LoginResponse (accessToken, refreshToken, user)
  - Dio instance 재사용
- **기존 패턴 따르기**: 기존 datasource들의 에러 처리 방식

### 6. Data Layer - Repository 구현
- **위치**: lib/data/repositories/auth_repository_impl.dart
- **목적**: Repository 인터페이스 구현
- **구현 내용**:
  - login 메서드 구현
  - 토큰 저장 (TokenStorage 사용)
  - DioException 처리
  - UserModel을 User entity로 변환
- **기존 패턴 따르기**: try-catch-Either 패턴

### 7. Navigation 설정
- **위치**: lib/core/router/app_router.dart
- **목적**: 로그인 라우트 추가
- **구현 내용**:
  - /login 라우트 추가
  - 로그인 성공 시 /home으로 리다이렉트
  - 인증 가드 로직
- **기존 패턴 따르기**: 기존 go_router 설정 방식

## ✅ 성공 기준
- [ ] 사용자가 이메일과 비밀번호 입력
- [ ] 로그인 버튼 클릭 시 API 호출
- [ ] 성공 시 토큰 저장 및 홈 화면 이동
- [ ] 실패 시 적절한 에러 메시지 표시 (SnackBar)
- [ ] 로딩 중 버튼 비활성화 및 로딩 인디케이터
- [ ] 이메일 형식 및 비밀번호 길이 검증
- [ ] 기존 코드 스타일 및 아키텍처 일관성 유지
- [ ] Widget test 작성 (로그인 화면)
- [ ] Repository test 작성 (mock API)
- [ ] UseCase test 작성

## 🔍 확인 사항
- API 엔드포인트 주소가 `https://api.example.com`이 맞나요?
- 토큰 만료 시 자동 갱신 기능이 필요한가요?
- 소셜 로그인(구글, 애플 등)도 함께 구현할까요?
- "비밀번호 찾기" 기능이 필요한가요?

---
위 요구사항으로 진행할까요? 수정이 필요한 부분이 있다면 말씀해주세요!

Tips for Effective Enhancement

Always Ask for Clarification

If the project context is unclear or insufficient:

프로젝트 파일을 업로드해주시면 더 정확한 요구사항을 만들 수 있습니다.
또는 다음 정보를 알려주세요:
- 사용 중인 프레임워크
- 상태 관리 라이브러리
- 기존 프로젝트 구조

Include Visual Examples

When helpful, mention existing screens/components:

기존 ProfileScreen과 유사한 레이아웃으로 구현
- AppBar 스타일 동일
- TextFormField 디자인 재사용
- PrimaryButton 컴포넌트 사용

Highlight Dependencies

## 🔗 연관 기능
- UserRepository: 사용자 정보 조회에 재사용
- TokenStorage: 기존 토큰 저장 로직 활용
- ErrorHandler: 공통 에러 처리 적용

Reference Files

For detailed patterns:

• Enhancement patterns: references/enhancement-patterns.md
• Framework guides: references/framework-guides.md

Enhancement Patterns

Common scenarios and enhancement strategies for different types of development requests.

Feature Addition Patterns

New UI Component

Original: "버튼 컴포넌트 만들어줘"

Enhancement checklist:

• Check existing component library (shadcn/ui, MUI, custom)
• Review existing button variants in codebase
• Identify styling system (CSS modules, Tailwind, styled-components)
• Check TypeScript prop patterns
• Find testing approach for components

Enhanced structure:

Create a Button component following project patterns:
- Location: /components/ui/Button.tsx
- Props: Match existing component prop patterns
- Variants: [list existing button types in project]
- Styling: [styling approach used]
- Accessibility: Match existing ARIA patterns
- Testing: Add tests in __tests__/components/

API Endpoint

Original: "사용자 목록 API 만들어줘"

Enhancement checklist:

• Identify API framework (Express, FastAPI, Next.js API routes)
• Check existing endpoint patterns
• Review authentication/authorization approach
• Find database/ORM patterns
• Check error handling conventions
• Identify response format standards

Enhanced structure:

Create user list API endpoint:
- Route: [follow existing route structure]
- Method: GET
- Auth: [existing auth middleware]
- Query params: pagination, filters (match existing patterns)
- Response format: [existing JSON structure]
- Error handling: [existing error response format]
- Database: [ORM/query pattern used]

State Management

Original: "장바구니 상태 관리 추가해줘"

Enhancement checklist:

• Identify state management library (Redux, Zustand, Context, Jotai)
• Review existing store structure
• Check action/reducer patterns
• Find persistence approach (localStorage, sessionStorage)
• Identify type definitions location

Enhanced structure:

Add cart state management:
- Store: [library being used]
- Location: [existing store directory]
- State shape: Match existing entity patterns
- Actions: [naming convention used]
- Selectors: [existing selector patterns]
- Persistence: [current persistence strategy]
- Types: [type definition location]

Bug Fix Patterns

Runtime Error

Original: "이 에러 고쳐줘"

Enhancement checklist:

• Identify error source file and line
• Check related dependencies
• Review error handling patterns in similar code
• Find test coverage for affected code
• Check recent changes to related files

Enhanced structure:

Fix [error type] in [file]:
- Error location: [file:line]
- Related files: [list dependencies]
- Current behavior: [describe issue]
- Expected behavior: [describe fix]
- Error handling: Match existing try-catch patterns
- Testing: Add regression test in [test location]

Logic Error

Original: "계산이 잘못됐어"

Enhancement checklist:

• Identify calculation logic location
• Check input/output types
• Review similar calculations in codebase
• Find existing validation patterns
• Check edge cases handling

Refactoring Patterns

Code Organization

Original: "이 파일 리팩토링해줘"

Enhancement checklist:

• Understand current file structure
• Identify separation concerns
• Check existing module patterns
• Review import conventions
• Find related files to update

Enhanced structure:

Refactor [file] following project patterns:
- Split into: [component structure used in project]
- Extract utilities to: [utility directory location]
- Update imports: [existing import style]
- Maintain: [critical dependencies]
- Update tests: [test locations to modify]

Performance Optimization

Original: "이 코드 최적화해줘"

Enhancement checklist:

• Profile current performance
• Identify optimization approach used in project (memoization, lazy loading)
• Check bundler/build tool capabilities
• Review caching strategies in use
• Find monitoring/metrics approach

Database/Data Patterns

Schema Changes

Original: "데이터베이스에 필드 추가해줘"

Enhancement checklist:

• Identify ORM/migration tool
• Check existing migration patterns
• Review schema conventions
• Find related model/type definitions
• Check seed data approach

Enhanced structure:

Add field to [table]:
- Migration: [migration tool and location]
- Field definition: [follow existing field patterns]
- Model update: [ORM model location]
- Type update: [TypeScript interface location]
- Seed data: [seed file to update]

Query Optimization

Original: "쿼리 최적화해줘"

Enhancement checklist:

• Identify query builder/ORM
• Check existing index patterns
• Review join strategies used
• Find caching approach
• Check query logging setup

Testing Patterns

Unit Tests

Original: "테스트 작성해줘"

Enhancement checklist:

• Identify test framework (Jest, Vitest, PyTest)
• Review existing test file structure
• Check mocking patterns
• Find test data/fixtures approach
• Review assertion style

Enhanced structure:

Add tests for [component/function]:
- Test file: [location following convention]
- Framework: [test framework in use]
- Mocking: [existing mock patterns]
- Test data: [fixture/factory location]
- Coverage: [minimum coverage requirement]

Flutter Widget Tests

Original: "위젯 테스트 작성해줘"

Enhancement checklist:

• Check test file location (test/ directory)
• Review existing widget test patterns
• Identify mock patterns (mockito, mocktail)
• Check provider/bloc testing approach
• Find golden test usage

Enhanced structure:

Add widget tests for [screen/widget]:
- Test file: test/presentation/[feature]/[widget]_test.dart
- Setup: testWidgets with WidgetTester
- Mocking: Mock repositories/providers
- State management testing:
  - Provider: ChangeNotifierProvider with mock
  - Bloc: BlocProvider with mock bloc
  - Riverpod: ProviderScope with overrides
- Finders: find.byType, find.text, find.byKey
- Interactions: tester.tap, tester.enterText
- Assertions: expect, findsOneWidget, findsNothing
- Pump: tester.pump(), tester.pumpAndSettle()

Mobile App Patterns

Flutter Screen/Feature

Original: "프로필 화면 만들어줘"

Enhancement checklist:

• Identify app architecture (Clean Architecture, MVVM)
• Check state management (Provider, Bloc, Riverpod, GetX)
• Review navigation approach
• Find existing screen patterns
• Check responsive design strategy
• Identify localization approach

Enhanced structure:

Create profile screen following project architecture:

1. Presentation Layer:
   - lib/presentation/profile/profile_screen.dart
   - Widget type: [StatefulWidget/ConsumerWidget/BlocConsumer]
   - Layout: Match existing screen structure
   - AppBar: Follow existing AppBar style
   - Responsive: Use MediaQuery if project uses it

2. State Management:
   [Based on project's approach]
   - Provider: profile_provider.dart with ChangeNotifier
   - Bloc: profile_bloc.dart, profile_event.dart, profile_state.dart
   - Riverpod: profile_provider.dart with StateNotifier
   - GetX: profile_controller.dart with GetxController

3. Data Layer:
   - Repository: lib/data/repositories/profile_repository.dart
   - Model: lib/data/models/profile_model.dart with fromJson/toJson
   - API: Use existing Dio/http client pattern

4. Domain Layer (if Clean Architecture):
   - Entity: lib/domain/entities/profile.dart
   - Use case: lib/domain/usecases/get_profile.dart

5. Navigation:
   - Route definition: [follow existing routing pattern]
   - Access from: [menu/drawer/bottom navigation]

6. UI Components:
   - Reuse existing widgets: [list existing components]
   - Form fields: Match existing input styling
   - Buttons: Use existing button widgets
   - Loading: CircularProgressIndicator with existing pattern
   - Error: SnackBar/Dialog matching project style

7. Assets:
   - Profile placeholder: assets/images/
   - Update pubspec.yaml if needed

8. Localization:
   - Add strings to: [existing l10n approach]
   - Use: AppLocalizations.of(context) or Get.find()

9. Testing:
   - Widget test: test/presentation/profile/profile_screen_test.dart
   - Repository test: test/data/repositories/profile_repository_test.dart

Flutter API Integration

Original: "상품 목록 API 연결해줘"

Enhancement checklist:

• Identify HTTP client (Dio, http package)
• Check existing API client configuration
• Review error handling approach
• Find model serialization pattern (json_serializable, freezed)
• Check caching strategy

Enhanced structure:

Integrate product list API:

1. API Client:
   - Location: lib/data/datasources/remote/product_api.dart
   - Use existing Dio instance with interceptors
   - Endpoint: GET /api/products
   - Headers: Match existing auth/content-type

2. Model:
   - lib/data/models/product_model.dart
   - Serialization: [json_serializable/freezed/manual]
   - Fields: Match API response structure
   - fromJson/toJson methods

3. Repository:
   - lib/data/repositories/product_repository.dart
   - Interface: lib/domain/repositories/product_repository.dart
   - Methods: Future<List<Product>> getProducts()
   - Error handling: try-catch with Either/Result type

4. State Management:
   - Provider: ProductListProvider with loading/error states
   - Bloc: ProductListBloc with events (Load, Refresh)
   - Riverpod: FutureProvider or AsyncNotifier
   
5. UI Update:
   - Show loading: CircularProgressIndicator
   - Display list: ListView.builder with product items
   - Handle errors: Show retry option
   - Pull to refresh: RefreshIndicator

6. Caching (if needed):
   - Use existing cache approach (Hive, SharedPreferences)
   - Cache duration: [project standard]

7. Pagination (if applicable):
   - Infinite scroll with ScrollController
   - Load more indicator at bottom

Documentation Patterns

README Updates

Original: "문서 업데이트해줘"

Enhancement checklist:

• Review existing README structure
• Check documentation style
• Find related docs to update
• Review example format
• Check if auto-generated docs exist

Enhanced structure:

Update documentation:
- Main README: [section to update]
- API docs: [doc tool in use]
- Examples: [example format used]
- Changelog: [changelog location]
- Comments: [JSDoc/docstring style]

Tips for Pattern Recognition

Quick Context Gathering

1. Project root files: Check package.json, requirements.txt for dependencies 2. Config files: Review .eslintrc, tsconfig.json for conventions 3. Directory structure: Scan for organization patterns 4. Recent commits: Check git history for active patterns

Common Warning Signs

• Multiple approaches for same task → clarify preferred pattern
• Outdated dependencies → mention version constraints
• Missing tests → emphasize test requirements
• Inconsistent naming → enforce existing convention

Framework-Specific Guides

Quick reference for enhancing prompts in popular frameworks.

Frontend Frameworks

Next.js

Key context to gather:

• App Router vs Pages Router
• TypeScript usage
• API route patterns
• Server/Client component split
• State management approach
• CSS solution (Tailwind, CSS Modules, styled-components)

Enhancement focus:

- Route structure: app/[route]/page.tsx or pages/[route].tsx
- Server components: Default in App Router
- Client components: 'use client' directive
- Data fetching: async components, fetch, SWR, React Query
- Metadata: generateMetadata for SEO
- API routes: app/api/[route]/route.ts or pages/api/[route].ts

React (Create React App / Vite)

Key context to gather:

• State management (Context, Redux, Zustand)
• Routing library (React Router)
• Component patterns (functional vs class)
• Build tool (Webpack, Vite)
• CSS approach

Enhancement focus:

- Component location: src/components/
- Hooks usage: useState, useEffect, custom hooks
- Route definitions: React Router configuration
- State structure: Global vs local state
- Build configuration: vite.config.ts or webpack config

Vue.js

Key context to gather:

• Vue 2 vs Vue 3
• Composition API vs Options API
• State management (Vuex, Pinia)
• TypeScript integration
• Component style (SFC structure)

Enhancement focus:

- Component structure: <template>, <script>, <style>
- Composition API: setup(), ref, reactive
- Store: Vuex modules or Pinia stores
- Router: vue-router configuration
- Props and emits: defineProps, defineEmits

Angular

Key context to gather:

• Angular version
• Module structure
• Component/Service patterns
• RxJS usage
• TypeScript strict mode

Enhancement focus:

- Module organization: feature modules
- Component structure: @Component decorator
- Services: @Injectable and dependency injection
- Observables: RxJS operators
- Forms: Reactive vs template-driven

Backend Frameworks

Express.js

Key context to gather:

• Middleware patterns
• Route organization
• Database/ORM (Prisma, TypeORM, Sequelize)
• Authentication approach
• TypeScript usage

Enhancement focus:

- Route structure: /routes directory
- Middleware: auth, validation, error handling
- Controllers: separation of concerns
- Database: ORM models and migrations
- Error handling: centralized error middleware

FastAPI (Python)

Key context to gather:

• Router organization
• Pydantic models
• Database/ORM (SQLAlchemy, Tortoise)
• Authentication (OAuth2, JWT)
• Async patterns

Enhancement focus:

- Routers: APIRouter organization
- Models: Pydantic schemas vs SQLAlchemy models
- Dependencies: Depends() for injection
- Async routes: async def endpoints
- Documentation: automatic OpenAPI docs

Django

Key context to gather:

• Django version
• App structure
• ORM usage
• Django REST Framework (if API)
• Template vs API approach

Enhancement focus:

- Apps: Django app organization
- Models: ORM model definitions
- Views: function-based vs class-based
- URLs: url patterns
- Migrations: makemigrations workflow

Spring Boot (Java)

Key context to gather:

• Spring Boot version
• Maven vs Gradle
• JPA/Hibernate usage
• Controller patterns
• Service layer structure

Enhancement focus:

- Controllers: @RestController patterns
- Services: @Service and business logic
- Repositories: JPA repositories
- Configuration: application.properties/yml
- DTOs: data transfer objects

Full-Stack Frameworks

Ruby on Rails

Key context to gather:

• Rails version
• MVC structure
• ActiveRecord patterns
• Asset pipeline vs Webpacker
• Testing framework (RSpec, Minitest)

Enhancement focus:

- Models: ActiveRecord associations
- Controllers: RESTful actions
- Views: ERB templates or API mode
- Routes: config/routes.rb
- Migrations: db/migrate/

Laravel (PHP)

Key context to gather:

• Laravel version
• Eloquent ORM usage
• Blade templates
• API vs full-stack
• Testing approach

Enhancement focus:

- Models: Eloquent model patterns
- Controllers: resource controllers
- Routes: web.php vs api.php
- Migrations: database/migrations/
- Middleware: app/Http/Middleware/

Mobile Frameworks

React Native

Key context to gather:

• Expo vs bare workflow
• Navigation library (React Navigation)
• State management
• Native modules usage
• Platform-specific code

Enhancement focus:

- Components: React Native primitives
- Navigation: stack, tab, drawer navigators
- Platform code: Platform.select()
- Native modules: linking and configuration
- Styling: StyleSheet API

Flutter

Key context to gather:

• Flutter version (2.x vs 3.x+)
• State management (Provider, Riverpod, Bloc, GetX, MobX)
• Null safety enabled
• Package dependencies (pubspec.yaml)
• Platform-specific code (iOS/Android)
• Architecture pattern (Clean Architecture, MVVM, MVC)
• Routing approach (Navigator 1.0, Navigator 2.0, go_router, auto_route)
• Network layer (Dio, http package)
• Local storage (Hive, SharedPreferences, SQLite)

Enhancement focus:

- Widgets: StatelessWidget vs StatefulWidget
  - Prefer StatelessWidget for UI-only components
  - Use StatefulWidget only when managing local state
  - Consider using Hooks (flutter_hooks) if in use

- State Management Pattern:
  - Provider: ChangeNotifier, Consumer, Provider.of
  - Riverpod: StateProvider, StateNotifierProvider, ConsumerWidget
  - Bloc: BlocProvider, BlocBuilder, BlocListener, BlocConsumer
  - GetX: GetxController, Obx, GetBuilder

- Navigation:
  - Navigator 1.0: Named routes in MaterialApp
  - Navigator 2.0: Router, RouterDelegate, RouteInformationParser
  - go_router: GoRoute configuration, nested routes
  - auto_route: @AutoRoute annotations, generated routing

- Project Structure:
  lib/
  ├── core/          (constants, themes, utils)
  ├── data/          (repositories, data sources, models)
  ├── domain/        (entities, use cases)
  ├── presentation/  (screens, widgets, state management)
  └── main.dart

- UI Components:
  - Material vs Cupertino widgets
  - Custom themes: ThemeData configuration
  - Responsive design: MediaQuery, LayoutBuilder
  - Custom widgets: reusable component patterns

- Data Layer:
  - Models: fromJson/toJson serialization
  - Repositories: abstraction layer
  - API clients: Dio interceptors, error handling
  - Local storage: async data persistence

- Platform Channels:
  - MethodChannel for platform-specific code
  - EventChannel for streaming data
  - Platform-specific implementations (iOS/Android)

- Assets and Resources:
  - pubspec.yaml: asset declarations
  - Image loading: AssetImage, NetworkImage, CachedNetworkImage
  - Fonts: custom font configuration
  - Localization: intl package, arb files

Common Flutter Enhancement Patterns:

Example 1 - Feature Addition:

Original: "로그인 화면 만들어줘"

Enhanced:
Create login screen following project architecture:

1. UI Layer (lib/presentation/auth/):
   - login_screen.dart: StatefulWidget with form
   - Use existing TextFormField styling from theme
   - Apply validation matching existing patterns
   - Follow project's responsive design approach

2. State Management (based on project):
   - Provider: Create AuthProvider with login method
   - Bloc: Create LoginBloc with LoginEvent and LoginState
   - Riverpod: Create loginProvider with StateNotifier
   - GetX: Create LoginController with login method

3. Data Layer (lib/data/):
   - auth_repository.dart: login API call
   - Use existing Dio instance and interceptors
   - Follow error handling pattern (try-catch, Either type)
   - user_model.dart: Add/update user model with serialization

4. Navigation:
   - After successful login, navigate to home
   - Use existing navigation pattern (context.go, Navigator.push)
   - Handle back button with WillPopScope if needed

5. Validation:
   - Email validator: match existing validation utils
   - Password strength: follow existing requirements
   - Form key: GlobalKey<FormState>

6. Error Handling:
   - Show SnackBar for errors (match existing UI feedback)
   - Loading state: CircularProgressIndicator
   - Disable button during loading

7. Testing:
   - Widget tests: test/presentation/auth/login_screen_test.dart
   - Unit tests: test/data/auth_repository_test.dart
   - Follow existing test patterns (mockito, mocktail)

Example 2 - State Management Integration:

Original: "장바구니 기능 추가해줘"

Enhanced based on Riverpod project:

1. State (lib/presentation/cart/):
   - cart_state.dart: CartState class (items, total, loading)
   - cart_notifier.dart: StateNotifier<CartState>
   - cart_provider.dart: StateNotifierProvider definition

2. UI (lib/presentation/cart/):
   - cart_screen.dart: ConsumerWidget
   - Use ref.watch(cartProvider) for state
   - Use ref.read(cartProvider.notifier) for actions
   - cart_item_widget.dart: reusable cart item component

3. Models (lib/domain/):
   - cart_item.dart: CartItem entity with Freezed
   - Follow existing entity patterns
   - Include copyWith, toJson, fromJson

4. Repository (lib/data/):
   - cart_repository.dart: local storage operations
   - Use existing Hive box or SharedPreferences approach
   - Implement caching strategy

5. Actions:
   - addToCart(Product product)
   - removeFromCart(String productId)
   - updateQuantity(String productId, int quantity)
   - clearCart()
   - Match existing method naming conventions

6. UI Integration:
   - Add cart icon to AppBar with badge (item count)
   - Use existing badge widget if available
   - Navigate to cart on tap

Flutter-Specific Considerations:

• Null Safety: Use sound null safety (required, ?, !)
• Async Operations: FutureBuilder, StreamBuilder, or state management
• Immutability: Consider using Freezed for immutable models
• Performance:
• Use const constructors where possible
• Implement shouldRepaint for CustomPainters
• ListView.builder for long lists
• Testing:
• Widget tests: testWidgets, find, expect
• Golden tests: matchesGoldenFile
• Integration tests: flutter_driver or integration_test

Enhancement Strategies by Framework

For Component-Based Frameworks (React, Vue, Angular)

1. Check existing component structure 2. Identify state management pattern 3. Review prop/event patterns 4. Check testing approach (component tests) 5. Verify styling solution

For MVC Frameworks (Rails, Django, Laravel)

1. Understand model relationships 2. Check controller patterns 3. Review route organization 4. Identify view/template approach 5. Verify migration patterns

For API Frameworks (Express, FastAPI)

1. Check route organization 2. Review middleware patterns 3. Identify validation approach 4. Check authentication/authorization 5. Verify error handling strategy

Quick Detection Commands

# Next.js
ls app/ pages/ next.config.js

# React
ls src/App.tsx package.json vite.config.ts

# Vue
ls src/main.ts vue.config.js

# Angular  
ls angular.json src/app/app.module.ts

# Express
ls index.js routes/ middleware/

# FastAPI
ls main.py routers/ models/

# Django
ls manage.py settings.py

# Rails
ls config/routes.rb app/models/

# React Native
ls App.tsx app.json

# Flutter
ls pubspec.yaml lib/main.dart

Framework Version Considerations

Breaking Changes to Note

• Next.js 13+: App Router vs Pages Router
• React 18+: Concurrent features, automatic batching
• Vue 3: Composition API, Teleport
• Angular 14+: Standalone components
• Django 3.2+: Async views support
• Rails 7+: Hotwire/Turbo
• Spring Boot 3+: Jakarta EE namespace

When enhancing prompts, always note the framework version if it affects implementation patterns.