cmd-productionize

What this skill does

# Productionize App Agent Rules

When asked to productionize an application for deployment:

## Overview

Transform development code into production-ready applications through systematic, methodical analysis, improvement, and deployment preparation. Supports multiple frameworks and deployment targets.

**Quality Over Speed Mandate**: Take time to be thorough and comprehensive. Focus on quality implementation over rapid completion. This is production-critical work that requires careful attention to detail.

## Usage Patterns

```bash
/cmd-productionize                          # Auto-detect framework, general production prep
/cmd-productionize flutter testflight       # Flutter app for TestFlight
/cmd-productionize react vercel            # React app for Vercel deployment
/cmd-productionize nodejs docker           # Node.js app for Docker deployment
/cmd-productionize python heroku           # Python app for Heroku
/cmd-productionize vue netlify             # Vue app for Netlify
```

## Workflow

### 1. **Initial Analysis & Planning**

- **Always start with TodoWrite tool** to create a comprehensive task list
- **Breadth AND Depth Navigation**: Look beyond immediate scope to understand:
  - Related systems that might be affected
  - Broader architectural implications
  - Integration points and dependencies
  - Edge cases and potential failure modes
  - Long-term maintenance considerations
- Analyze codebase structure and identify the framework/stack
- Read existing documentation (README, package.json, pubspec.yaml, etc.)
- Identify deployment target and requirements
- Create systematic task breakdown covering all productionization phases
- **Proactive Question Analysis**: Identify critical production questions the user hasn't asked yet

### 2. **Codebase Analysis Phase**

- **Architecture review**: Analyze project structure, dependencies, and patterns with methodical thoroughness
- **Comprehensive Production Readiness Audit**: Systematically identify potential issues:
  - Hardcoded values and missing environment configurations
  - Missing error handling and edge case coverage
  - Performance bottlenecks and optimization opportunities
  - Security vulnerabilities and data exposure risks
  - Missing caching and state management
  - API pagination and data fetching issues
  - UI/UX polish and accessibility concerns
  - Rate limiting and abuse protection
  - Offline support and network failure handling
  - Data validation and sanitization
  - Memory leaks and resource cleanup
  - Cross-platform compatibility issues
  - Third-party service dependencies and fallbacks
- **Framework-specific checks**: Apply framework-appropriate best practices with deep domain knowledge
- **Critical Questions Analysis**: Document what production concerns the user should consider but hasn't addressed

### 3. **Implementation Phase**

Execute improvements systematically with methodical attention to detail, updating TodoWrite progress frequently:

**Quality Focus**: Each implementation step should be thorough and well-tested. Don't rush through tasks - take time to implement robust, production-grade solutions.

#### **Configuration & Environment**
- Add environment-based configurations (dev/staging/prod)
- Implement feature toggles and debug modes
- Secure API keys and sensitive data
- Add configuration validation

#### **Performance & Reliability**
- Implement proper caching mechanisms (memory, disk, network)
- Add error handling and retry logic
- Optimize network requests and pagination
- Add loading states and offline handling
- Implement proper state persistence

#### **User Experience**
- Polish UI/UX with loading indicators and feedback
- Add proper error messages and user guidance
- Implement accessibility improvements
- Test edge cases and error scenarios

#### **Code Quality**
- Add comprehensive logging and monitoring
- Implement proper testing coverage
- Clean up technical debt and code smells
- Add documentation and comments

### 4. **Framework-Specific Optimizations**

#### **Flutter**
- Implement SharedPreferences for persistent caching
- Add proper error handling for network requests
- Optimize widget rebuilds and state management
- Add platform-specific configurations (iOS/Android)
- Implement proper navigation and state restoration

#### **React/Next.js**
- Implement proper state management (Redux, Zustand, Context)
- Add error boundaries and suspense loading
- Optimize bundle size and code splitting
- Implement proper caching (SWR, React Query)
- Add SEO and meta tag optimizations

#### **Node.js**
- Add proper middleware for error handling and logging
- Implement rate limiting and security headers
- Optimize database queries and connections
- Add health checks and monitoring endpoints
- Implement proper environment configuration

#### **Python**
- Add proper error handling and logging
- Implement caching (Redis, in-memory)
- Optimize database queries and ORM usage
- Add input validation and sanitization
- Implement proper testing and CI/CD

### 5. **Documentation Phase**

Create comprehensive production-ready documentation:

#### **README.md Structure** (based on proven patterns):
```markdown
# Project Name - Production Ready

_Brief compelling description with value proposition_

## Quick Start
- One-command setup instructions
- Environment requirements
- Configuration steps

## Features
- Core functionality overview
- Production-ready capabilities
- Toggle configurations

## Deployment
- Platform-specific deployment guides
- Environment variable setup
- Testing and validation steps

## Development
- Local development setup
- Testing procedures
- Contributing guidelines

## Architecture
- High-level system overview
- Key design decisions
- Production considerations
```

#### **Additional Documentation**
- Deployment checklists for each target platform
- API documentation if applicable
- Troubleshooting guides
- Performance optimization notes

### 6. **Deployment Preparation Phase**

#### **TestFlight (iOS)**
- Verify App Store Connect configurations
- Test provisioning profiles and certificates
- Validate Info.plist settings
- Create build and upload scripts
- Prepare app description and screenshots

#### **Google Play (Android)**
- Configure Play Console settings
- Test signing configurations
- Validate manifest permissions
- Create release notes and store listing
- Test different device configurations

#### **Web Deployment (Vercel/Netlify/AWS)**
- Configure build scripts and environment variables
- Set up domain and SSL certificates
- Test deployment pipeline
- Configure CDN and caching headers
- Set up monitoring and analytics

#### **Container Deployment (Docker/Kubernetes)**
- Create optimized Dockerfiles
- Configure health checks and resource limits
- Set up environment variable management
- Test scaling and load balancing
- Configure logging and monitoring

### 7. **Quality Assurance Checklist**

Before marking productionization complete:

- [ ] All configurations are environment-aware
- [ ] Error handling covers edge cases
- [ ] Caching is implemented and tested
- [ ] Performance is optimized for target platforms
- [ ] Security best practices are followed
- [ ] Documentation is comprehensive and accurate
- [ ] Deployment process is tested and reliable
- [ ] Monitoring and logging are configured
- [ ] User experience is polished and accessible
- [ ] All TodoWrite tasks are completed

### 8. **Proactive Question Analysis & Next Steps**

After completing productionization, **ALWAYS** provide:

#### **Critical Questions the User Should Have Asked**
Systematically identify and present production concerns the user hasn't considered:

**Example Framework-Specific Questions:**
- **Flutter**: "Have you considered rate limiting for API calls? What happens when the device goes offline? How will you handle app store review rejections?"
- **React/Web**: "What's your strategy for SEO and social media previews? How will you handle bot traffic? What about GDPR co