Practical Examples

# Review pull request changes
git diff main..feature-branch > changes.diff
gemini --file changes.diff "Perform a comprehensive code review focusing on:
- Security vulnerabilities
- Performance issues  
- Code quality and best practices
- Potential bugs
- Suggestions for improvement"

# Analyze code complexity
find src/ -name "*.js" -exec wc -l {} + | sort -nr | head -10 |   while read lines file; do
    echo "Analyzing $file ($lines lines)"
    gemini --file "$file" "Assess code complexity and suggest refactoring opportunities"
  done

# Security audit for authentication code
gemini --file "src/auth/*.ts" --include "**/*auth*"   "Conduct a security audit focusing on authentication and authorization. 
   Check for common vulnerabilities like:
   - SQL injection
   - XSS vulnerabilities
   - Insecure session handling
   - Password security issues"

# Modernize React class components
gemini --file legacy-component.jsx "Convert this class component to modern React with hooks:
- Use functional component syntax
- Replace lifecycle methods with useEffect
- Convert state to useState
- Add TypeScript types
- Include proper error boundaries"

# Upgrade JavaScript to TypeScript
gemini --file "src/**/*.js" "Convert these JavaScript files to TypeScript:
- Add proper type annotations
- Define interfaces for complex objects
- Use generics where appropriate
- Handle null/undefined cases properly
- Maintain backwards compatibility"

# API modernization
gemini --file api-routes.js "Modernize this Express.js API:
- Convert to async/await from callbacks
- Add proper error handling
- Implement request validation
- Add rate limiting
- Include comprehensive logging"

# Analyze entire project structure
gemini "Analyze this project's architecture and provide insights:
$(find . -type f -name "*.json" -o -name "*.js" -o -name "*.ts" -o -name "*.md" | head -20 | xargs cat)

Focus on:
- Overall architecture patterns
- Dependency structure
- Scalability concerns
- Maintainability issues
- Recommended improvements"

# Database schema analysis
gemini --file schema.sql "Review this database schema:
- Identify normalization issues
- Suggest indexing strategies
- Check for performance bottlenecks
- Recommend optimization opportunities
- Assess scalability for 1M+ users"

# Microservices design review
gemini --include "**/docker-compose.yml" --include "**/package.json"   "Analyze this microservices architecture:
  - Service boundaries and responsibilities
  - Inter-service communication patterns
  - Data consistency strategies
  - Deployment and scaling considerations
  - Monitoring and observability setup"

# Generate comprehensive API documentation
gemini --file "routes/*.js" "Create comprehensive API documentation:
- Endpoint descriptions and purposes
- Request/response schemas
- Authentication requirements
- Error codes and handling
- Usage examples with curl commands
- Rate limiting information

Format as OpenAPI 3.0 specification."

# Create onboarding documentation
gemini "Generate a developer onboarding guide for this project:
$(cat package.json README.md .env.example 2>/dev/null)

Include:
- Project overview and architecture
- Development environment setup
- Common workflows and commands
- Testing and deployment procedures
- Troubleshooting common issues"

# Generate changelog from git history
git log --oneline --since="1 month ago" |   gemini "Create a professional changelog from these git commits:
  - Group by feature type (feat, fix, refactor, etc.)
  - Write user-friendly descriptions
  - Highlight breaking changes
  - Include migration instructions if needed"

# Generate comprehensive test suites
gemini --file utils.js "Create comprehensive Jest tests for these utility functions:
- Unit tests for each function
- Edge cases and error scenarios
- Mock external dependencies
- Parameterized tests for multiple inputs
- Performance tests for optimization
- Integration tests where applicable"

# Test existing codebase coverage analysis
gemini --file "src/**/*.test.js" --file "src/**/*.js"   "Analyze test coverage and suggest improvements:
  - Identify untested functions and modules
  - Suggest additional test scenarios
  - Recommend testing strategies
  - Highlight critical paths needing tests
  - Propose test refactoring opportunities"

# End-to-end test scenarios
gemini --file user-stories.md "Generate Cypress e2e tests based on these user stories:
- Critical user journeys
- Authentication flows
- Error handling scenarios
- Mobile responsiveness tests
- Performance benchmarks"

# Optimize GitHub Actions workflow
gemini --file .github/workflows/ci.yml "Optimize this CI/CD pipeline:
- Reduce build times
- Improve caching strategies
- Add security scanning
- Implement proper staging
- Include automated rollback
- Add performance monitoring"

# Docker optimization
gemini --file Dockerfile "Optimize this Dockerfile for production:
- Reduce image size
- Improve security
- Implement multi-stage builds
- Add health checks
- Optimize layer caching
- Include proper user permissions"

# Infrastructure as Code review
gemini --file infrastructure/ "Review this Terraform configuration:
- Security best practices
- Cost optimization opportunities
- Scalability improvements
- Disaster recovery planning
- Monitoring and alerting setup"

# React app performance analysis
gemini --file "src/components/**/*.tsx" "Analyze React components for performance:
- Identify unnecessary re-renders
- Suggest memoization opportunities
- Find heavy computations for optimization
- Recommend code splitting points
- Check for memory leaks
- Propose bundle size optimizations"

# Bundle analysis and optimization
npm run build -- --analyze |   gemini "Analyze this webpack bundle output:
  - Identify largest dependencies
  - Suggest code splitting strategies
  - Recommend tree shaking improvements
  - Find duplicate dependencies
  - Propose dynamic import opportunities"

# Database query optimization
gemini --file slow-queries.sql "Optimize these database queries:
- Add appropriate indexes
- Rewrite for better performance
- Suggest query plan improvements
- Identify N+1 query patterns
- Recommend caching strategies
- Propose query monitoring alerts"

# Analyze application logs
tail -1000 app.log |   gemini "Analyze these application logs for:
  - Error patterns and frequency
  - Performance bottlenecks
  - Security anomalies
  - User behavior insights
  - System health indicators
  - Recommended monitoring alerts"

# Process CSV data analysis
gemini --file sales-data.csv "Analyze this sales data:
- Identify trends and patterns
- Calculate key metrics
- Find anomalies or outliers
- Generate executive summary
- Suggest data visualization
- Recommend action items"

# API usage analytics
cat access.log | grep "API" | tail -1000 |   gemini "Analyze API usage patterns:
  - Most frequently used endpoints
  - Error rate analysis
  - Peak usage times
  - Geographic distribution
  - Rate limiting effectiveness
  - Performance optimization opportunities"

# Feature development workflow
#!/bin/bash
FEATURE="user-authentication"

# 1. Architecture planning
gemini "Design architecture for $FEATURE feature:
- Database schema requirements
- API endpoint specifications
- Frontend component structure
- Security considerations
- Testing strategy"

# 2. Implementation guidance
gemini --file requirements.md "Create implementation plan:
- Break down into development tasks
- Estimate effort for each task
- Identify dependencies and risks
- Suggest development order
- Define acceptance criteria"

# 3. Code generation
gemini "Generate boilerplate code for $FEATURE:
- Database models and migrations
- API routes with validation
- Frontend components
- Unit test scaffolding
- Documentation templates"

# 4. Review and optimization
git add . && git commit -m "Initial $FEATURE implementation"
git diff HEAD~1 |   gemini "Review this feature implementation:
  - Code quality assessment
  - Security vulnerability check
  - Performance optimization suggestions
  - Test coverage recommendations
  - Documentation completeness"