/create-feature

Create Feature Command

Scaffold new feature with boilerplate code

Instructions

Follow this systematic approach to create a new feature: **$ARGUMENTS**

1. **Feature Planning**

• Define the feature requirements and acceptance criteria
• Break down the feature into smaller, manageable tasks
• Identify affected components and potential impact areas
• Plan the API/interface design before implementation

2. **Research and Analysis**

• Study existing codebase patterns and conventions
• Identify similar features for consistency
• Research external dependencies or libraries needed
• Review any relevant documentation or specifications

3. **Architecture Design**

• Design the feature architecture and data flow
• Plan database schema changes if needed
• Define API endpoints and contracts
• Consider scalability and performance implications

4. **Environment Setup**

• Create a new feature branch: `git checkout -b feature/$ARGUMENTS`
• Ensure development environment is up to date
• Install any new dependencies required
• Set up feature flags if applicable

5. **Implementation Strategy**

• Start with core functionality and build incrementally
• Follow the project's coding standards and patterns
• Implement proper error handling and validation
• Use dependency injection and maintain loose coupling

6. **Database Changes (if applicable)**

• Create migration scripts for schema changes
• Ensure backward compatibility
• Plan for rollback scenarios
• Test migrations on sample data

7. **API Development**

• Implement API endpoints with proper HTTP status codes
• Add request/response validation
• Implement proper authentication and authorization
• Document API contracts and examples

8. **Frontend Implementation (if applicable)**

• Create reusable components following project patterns
• Implement responsive design and accessibility
• Add proper state management
• Handle loading and error states

9. **Testing Implementation**

• Write unit tests for core business logic
• Create integration tests for API endpoints
• Add end-to-end tests for user workflows
• Test error scenarios and edge cases

10. **Security Considerations**

• Implement proper input validation and sanitization
• Add authorization checks for sensitive operations
• Review for common security vulnerabilities
• Ensure data protection and privacy compliance

11. **Performance Optimization**

• Optimize database queries and indexes
• Implement caching where appropriate
• Monitor memory usage and optimize algorithms
• Consider lazy loading and pagination

12. **Documentation**

• Add inline code documentation and comments
• Update API documentation
• Create user documentation if needed
• Update project README if applicable

13. **Code Review Preparation**

• Run all tests and ensure they pass
• Run linting and formatting tools
• Check for code coverage and quality metrics
• Perform self-review of the changes

14. **Integration Testing**

• Test feature integration with existing functionality
• Verify feature flags work correctly
• Test deployment and rollback procedures
• Validate monitoring and logging

15. **Commit and Push**

• Create atomic commits with descriptive messages
• Follow conventional commit format if project uses it
• Push feature branch: `git push origin feature/$ARGUMENTS`

16. **Pull Request Creation**

• Create PR with comprehensive description
• Include screenshots or demos if applicable
• Add appropriate labels and reviewers
• Link to any related issues or specifications

17. **Quality Assurance**

• Coordinate with QA team for testing
• Address any bugs or issues found
• Verify accessibility and usability requirements
• Test on different environments and browsers

18. **Deployment Planning**

• Plan feature rollout strategy
• Set up monitoring and alerting
• Prepare rollback procedures
• Schedule deployment and communication

Remember to maintain code quality, follow project conventions, and prioritize user experience throughout the development process.