# Review code style
Check for:
- Consistent indentation
- Proper naming conventions
- Code formatting
- Line length limits
- File organization

# Review comments
Check for:
- Clear and concise comments
- Documentation completeness
- Comment relevance
- Comment placement
- Comment formatting

# Review function implementation
Check for:
- Single responsibility
- Proper error handling
- Input validation
- Return value consistency
- Function length

# Review function parameters
Check for:
- Parameter naming
- Parameter order
- Optional parameters
- Default values
- Parameter types

# Review class structure
Check for:
- Class responsibility
- Method organization
- Property visibility
- Constructor implementation
- Class size

# Review class relationships
Check for:
- Inheritance usage
- Interface implementation
- Composition patterns
- Dependency injection
- Coupling level

# Review input handling
Check for:
- Input sanitization
- Type checking
- Length validation
- Format validation
- Boundary checks

# Review data handling
Check for:
- Sensitive data exposure
- Data encryption
- Secure storage
- Data transmission
- Data retention

# Review authentication
Check for:
- Password hashing
- Session management
- Token handling
- Access control
- Authentication flow

# Review authorization
Check for:
- Role-based access
- Permission checks
- Resource access
- API security
- Security headers

# Review API security
Check for:
- Input validation
- Rate limiting
- CORS configuration
- Error handling
- Security headers

# Review API endpoints
Check for:
- Authentication
- Authorization
- Data validation
- Error responses
- Security best practices

# Review algorithm efficiency
Check for:
- Time complexity
- Space complexity
- Edge cases
- Optimization opportunities
- Resource usage

# Review data structures
Check for:
- Appropriate usage
- Memory efficiency
- Access patterns
- Modification patterns
- Scalability

# Review database operations
Check for:
- Query efficiency
- Index usage
- Connection management
- Transaction handling
- Data consistency

# Review database design
Check for:
- Table structure
- Relationship design
- Normalization
- Index design
- Query patterns

# Review resource usage
Check for:
- Memory management
- File handling
- Connection pooling
- Resource cleanup
- Resource limits

# Review caching
Check for:
- Cache strategy
- Cache invalidation
- Cache consistency
- Memory usage
- Performance impact

# Review unit tests
Check for:
- Test coverage
- Test isolation
- Assertion quality
- Test naming
- Test organization

# Review test cases
Check for:
- Edge cases
- Error cases
- Input validation
- Expected outputs
- Test data quality

# Review integration tests
Check for:
- Component interaction
- Test setup
- Test teardown
- Test isolation
- Test coverage

# Review test environment
Check for:
- Environment setup
- Test data
- Mock objects
- Test dependencies
- Test configuration

# Review performance tests
Check for:
- Test scenarios
- Load patterns
- Metrics collection
- Resource monitoring
- Test duration

# Review stress tests
Check for:
- System limits
- Error handling
- Recovery testing
- Resource usage
- Test documentation

# Review code organization
Check for:
- File structure
- Module organization
- Code grouping
- Dependency management
- Code reusability

# Review code complexity
Check for:
- Cyclomatic complexity
- Code duplication
- Method length
- Class size
- Module coupling

# Review code documentation
Check for:
- Documentation completeness
- Documentation accuracy
- Documentation clarity
- Documentation relevance
- Documentation maintenance

# Review API documentation
Check for:
- Endpoint documentation
- Parameter documentation
- Response documentation
- Error documentation
- Example usage

# Review coding standards
Check for:
- Design patterns
- SOLID principles
- DRY principle
- KISS principle
- Code style guidelines

# Review error handling
Check for:
- Error types
- Error messages
- Error logging
- Error recovery
- Error propagation