ai-playbook 1.0.0

package/skills/devops/README.md

@@ -0,0 +1,177 @@
+# DevOps Skill
+
+## Overview
+
+The DevOps skill enables organizations to automate infrastructure, deployment pipelines, and operational processes while maintaining reliability, security, and observability. It encompasses designing CI/CD systems that enable rapid deployment, infrastructure as code that enables reproducibility, container orchestration for application scaling, and comprehensive monitoring for rapid incident diagnosis. DevOps bridges development and operations through automation, making deployment safe and frequent rather than risky and rare.
+
+---
+
+## Goals
+
+- **Automate Deployments**: Enable safe, frequent deployments through automated testing and deployment pipelines
+- **Infrastructure as Code**: Define all infrastructure in version-controlled code for reproducibility and safety
+- **Rapid Incident Response**: Implement comprehensive monitoring and alerting enabling rapid issue diagnosis
+- **High Reliability**: Design systems with redundancy, auto-healing, and graceful degradation
+- **Security by Default**: Integrate security scanning and secrets management into deployment pipelines
+- **Cost Optimization**: Optimize infrastructure costs through right-sizing, auto-scaling, and resource management
+- **Operational Efficiency**: Reduce manual operational work through automation and self-healing systems
+- **Compliance & Auditing**: Automate compliance checking and maintain audit trails for all changes
+
+---
+
+## Capabilities
+
+### Continuous Integration & Deployment
+- **CI Pipeline Design**: Automated build, test, and quality checks on every commit
+- **CD Pipeline Design**: Automated deployment to staging and production with safety gates
+- **Testing Automation**: Unit, integration, E2E, security, and performance testing
+- **Deployment Strategies**: Blue-green, canary, rolling deployments with automatic rollback
+- **Release Management**: Version management, release notes, deployment notifications
+
+### Infrastructure & Cloud
+- **Infrastructure as Code**: Terraform, CloudFormation, Ansible for infrastructure definition
+- **Cloud Platform Management**: AWS, Azure, GCP, multi-cloud strategies
+- **Container Orchestration**: Kubernetes, container management, auto-scaling
+- **Network Architecture**: VPC design, security groups, service mesh, load balancing
+- **Storage & Databases**: Managed database services, backup, replication, disaster recovery
+
+### Monitoring & Observability
+- **Metrics Collection**: Prometheus, time-series databases, metric aggregation
+- **Visualization**: Grafana dashboards, SLO dashboards, custom visualizations
+- **Logging**: Centralized log aggregation, structured logging, log analysis
+- **Distributed Tracing**: Service-to-service request tracing, latency analysis
+- **Alerting**: Alert rules, escalation policies, on-call management
+
+### Security & Compliance
+- **Secrets Management**: Secure credential storage, rotation, access control
+- **Security Scanning**: SAST, DAST, dependency scanning, container scanning
+- **Access Control**: RBAC, identity management, audit logging
+- **Compliance Automation**: Policy enforcement, compliance reporting
+- **Network Security**: Firewalls, DDoS protection, encryption
+
+### Disaster Recovery & Business Continuity
+- **Backup Strategy**: Automated backups, retention policies, backup verification
+- **Replication**: Database replication, geo-redundancy, failover mechanisms
+- **Disaster Recovery Planning**: RTO/RPO definitions, DR procedures, DR testing
+- **High Availability**: Multi-zone deployment, auto-healing, health checks
+
+---
+
+## When to Use
+
+**Use this skill when you need to:**
+- Design or improve CI/CD pipelines for frequent, safe deployments
+- Define infrastructure using Infrastructure as Code
+- Set up monitoring, logging, and alerting systems
+- Plan deployment strategies for zero-downtime releases
+- Implement secrets and configuration management
+- Design disaster recovery and business continuity plans
+- Optimize cloud infrastructure costs
+- Implement security scanning and compliance automation
+- Scale applications using container orchestration
+
+**Typical scenarios:**
+- Pre-production deployment planning
+- Infrastructure modernization (manual to IaC)
+- Scaling challenges requiring orchestration
+- Reliability improvements (monitoring, alerting, DR)
+- Security compliance initiatives
+- Cost optimization efforts
+- Team scaling to support more frequent deployments
+
+---
+
+## Expected Workflow
+
+```
+Define Requirements & Constraints
+        ↓
+Design Architecture (CI/CD, Infrastructure)
+        ↓
+Implement Automation & IaC
+        ↓
+Set Up Monitoring & Alerting
+        ↓
+Test Deployment Procedures
+        ↓
+Deploy to Staging
+        ↓
+Validation & Testing
+        ↓
+Deploy to Production
+        ↓
+Monitor & Optimize
+        ↓
+Continuous Improvement
+```
+
+---
+
+## Inputs
+
+- **Application Architecture**: Services, dependencies, deployment requirements
+- **Infrastructure Requirements**: Compute, storage, networking, database needs
+- **Scale Targets**: Throughput, latency, availability requirements
+- **Compliance Needs**: Regulatory requirements, audit requirements, retention policies
+- **Team Size**: Number of teams, deployment frequency targets
+- **Budget Constraints**: Cloud budget limitations, cost targets
+- **Existing Tools**: Current infrastructure, tools in use, constraints
+- **Risk Tolerance**: Acceptable downtime, data loss tolerance, blast radius
+
+---
+
+## Outputs
+
+- **CI/CD Pipeline Configuration**: GitHub Actions, GitLab CI, Jenkins, CircleCI configurations
+- **Infrastructure as Code**: Terraform modules, CloudFormation templates, Ansible playbooks
+- **Container Orchestration**: Kubernetes manifests, Helm charts, deployment configurations
+- **Monitoring & Observability Setup**: Prometheus/Grafana configs, alert rules, dashboard definitions
+- **Secrets Management**: Vault configuration, secret rotation policies, access controls
+- **Disaster Recovery Plan**: Backup strategies, RTO/RPO definitions, recovery procedures
+- **Runbooks**: Incident response procedures, troubleshooting guides, operational procedures
+- **Documentation**: Infrastructure documentation, deployment guides, operational guides
+- **Cost Analysis**: Cloud cost optimization recommendations, cost allocation strategies
+- **Security Configuration**: Network policies, firewall rules, RBAC definitions
+
+---
+
+## Related Skills
+
+- **Architecture**: System-level design, scalability planning, integration patterns
+- **Design Architecture**: User experience for operational dashboards and tooling
+- **Performance**: Performance optimization, benchmarking, load testing
+- **Documentation**: Creating operational documentation, runbooks, guides
+- **Software Development**: Application design for operational efficiency, structured logging
+- **Security**: Security architecture, threat modeling, security standards
+
+---
+
+## Best Practices
+
+1. **Automate Everything**: Reduce manual processes; manual work introduces errors and delays
+2. **Infrastructure as Code**: Version control all infrastructure; enable reproducibility
+3. **Test Thoroughly**: Test code, infrastructure, and deployments automatically
+4. **Fail Fast**: Detect issues early in pipelines; provide rapid feedback
+5. **Shift Left on Security**: Scan for vulnerabilities early in development, not just production
+6. **Monitor Comprehensively**: Monitor applications, infrastructure, and business metrics
+7. **Plan for Failure**: Design for failure with redundancy, graceful degradation, and quick recovery
+8. **Safe Deployments**: Use canary, blue-green, or rolling deployments with automatic rollback
+9. **Document Procedures**: Create clear runbooks for common tasks and incident response
+10. **Measure & Improve**: Track deployment frequency, lead time, MTTR; continuously improve
+
+---
+
+## Success Criteria
+
+1. **Deployment Frequency**: Multiple deployments per day without manual intervention
+2. **Lead Time**: Changes move from commit to production in minutes to hours
+3. **Mean Time to Recovery**: Systems recover from failures automatically within minutes
+4. **Change Failure Rate**: <15% of deployments cause issues requiring rollback
+5. **Security**: Zero unpatched critical vulnerabilities; compliance maintained automatically
+6. **Reliability**: 99.9%+ availability with clear SLOs and monitoring
+7. **Scalability**: System automatically scales to handle load spikes
+8. **Cost Efficiency**: Cloud costs optimized with appropriate resource allocation
+9. **Visibility**: All deployments, infrastructure, and incidents visible and auditable
+10. **Automation**: >95% of operational tasks automated without manual intervention
+
+---

package/skills/devops/examples.md

@@ -0,0 +1,376 @@
+# DevOps Skill - Examples
+
+## Example 1: Build Complete CI/CD Pipeline
+
+**User Request**: "We're deploying manually and this is error-prone. Build a CI/CD pipeline that tests code and deploys automatically to staging/production."
+
+**Expected Behavior**:
+- Set up GitHub Actions (or GitLab CI) workflow
+- Create pipeline stages: build, test, security scan, deploy to staging, deploy to production
+- Implement automated testing (unit, integration, E2E tests)
+- Add code quality checks (linting, coverage requirements)
+- Implement security scanning (SAST, dependency scanning)
+- Deploy to staging on every merge to main
+- Require manual approval for production deployment
+- Enable rollback capability
+- Create deployment notifications
+- Implement deployment frequency metrics
+
+**Success Criteria**:
+- Deployments happen multiple times per day
+- All tests pass before deployment
+- Security vulnerabilities detected automatically
+- Rollback capability works reliably
+- Deployment time <15 minutes from commit to production
+
+---
+
+## Example 2: Infrastructure as Code Migration
+
+**User Request**: "Our infrastructure is manually configured and undocumented. Migrate to Infrastructure as Code with Terraform."
+
+**Expected Behavior**:
+- Audit current infrastructure (compute, storage, networking, databases)
+- Create Terraform modules for each resource type
+- Define variables for environment-specific configurations
+- Implement state management with remote backend
+- Create separate workspaces for dev, staging, production
+- Implement version control for all infrastructure code
+- Design for destroy and recreate ability
+- Create documentation of module usage
+- Plan migration path with minimal downtime
+- Test infrastructure changes before applying
+
+**Success Criteria**:
+- All infrastructure defined in Terraform
+- Infrastructure reproducible from code
+- Infrastructure changes tracked in version control
+- Deployment time <1 hour for new environment
+- Zero manual infrastructure configuration
+
+---
+
+## Example 3: Kubernetes Cluster Setup & Management
+
+**User Request**: "Migrate our containerized applications to Kubernetes. Set up cluster with auto-scaling, monitoring, and self-healing."
+
+**Expected Behavior**:
+- Set up Kubernetes cluster (EKS, GKE, or AKS)
+- Configure auto-scaling based on CPU/memory
+- Implement pod disruption budgets
+- Set up resource requests/limits
+- Implement health checks and probes
+- Configure persistent storage
+- Set up RBAC for access control
+- Implement network policies
+- Deploy monitoring (Prometheus, Grafana)
+- Create deployment guides and runbooks
+
+**Success Criteria**:
+- All applications containerized and deployed
+- Automatic scaling works for traffic spikes
+- Pods automatically restart on failure
+- System remains available during updates
+- Resource utilization optimized
+
+---
+
+## Example 4: Monitoring & Alerting System
+
+**User Request**: "We have no visibility into what's happening in production. Design a comprehensive monitoring and alerting system."
+
+**Expected Behavior**:
+- Set up Prometheus for metrics collection
+- Create Grafana dashboards for different audiences (ops, dev, business)
+- Implement distributed tracing across services
+- Set up centralized logging (ELK Stack or similar)
+- Create alert rules for critical metrics
+- Implement escalation policies
+- Configure on-call rotations
+- Create runbooks for common alerts
+- Set up SLO monitoring and dashboards
+- Implement chaos testing for resilience
+
+**Success Criteria**:
+- All critical issues detected within 1 minute
+- 90%+ alert accuracy (minimal false positives)
+- Root cause diagnosis <5 minutes
+- Dashboard visibility for all teams
+- On-call team notified automatically
+
+---
+
+## Example 5: Secrets Management Implementation
+
+**User Request**: "Database credentials and API keys are stored in code/config files. Implement secure secrets management."
+
+**Expected Behavior**:
+- Set up HashiCorp Vault (or cloud equivalent)
+- Define secret types (database credentials, API keys, tokens)
+- Implement secret rotation policies
+- Create role-based access control for secrets
+- Implement secret injection into applications
+- Migrate existing secrets to vault
+- Create audit logging for secret access
+- Implement automatic secret rotation
+- Design emergency access procedures
+- Create documentation and training
+
+**Success Criteria**:
+- All secrets stored securely in vault
+- Zero secrets in code or config files
+- Secrets rotated automatically on schedule
+- Secret access audited and tracked
+- Emergency access procedures documented
+
+---
+
+## Example 6: Zero-Downtime Deployment Strategy
+
+**User Request**: "Our deployments cause 5-10 minutes of downtime. Design a zero-downtime deployment strategy."
+
+**Expected Behavior**:
+- Implement blue-green deployment strategy
+- Create pre-deployment health checks
+- Implement graceful shutdown procedures
+- Design connection draining for long-lived connections
+- Set up load balancer traffic switching
+- Create rollback capability if health checks fail
+- Implement health check thresholds
+- Test deployments with chaos engineering
+- Create deployment runbooks
+- Monitor for user-visible issues during deployment
+
+**Success Criteria**:
+- Deployments never cause service unavailability
+- Rollback automatic if health checks fail
+- Deployment verification automated
+- Zero customer-visible deployment failures
+- Deployment risk reduced to <1% change failure rate
+
+---
+
+## Example 7: Database Backup & Disaster Recovery
+
+**User Request**: "Design a database backup and disaster recovery strategy that meets 1-hour RTO and 15-minute RPO."
+
+**Expected Behavior**:
+- Implement continuous replication to secondary region
+- Create automated daily backups to separate storage
+- Design backup retention policy (daily for 30 days, weekly for 1 year)
+- Implement automated backup testing and validation
+- Create procedures for point-in-time recovery
+- Design failover procedures with clear runbooks
+- Test DR procedures monthly
+- Implement backup monitoring and alerts
+- Document RPO and RTO for each database
+- Create cross-region replication
+
+**Success Criteria**:
+- Backups tested and verified weekly
+- Recovery time to secondary <30 minutes
+- Data loss limited to 15 minutes in worst case
+- Backup storage cost optimized
+- DR procedures documented and practiced
+
+---
+
+## Example 8: Security Scanning in CI/CD
+
+**User Request**: "We need to detect security vulnerabilities early in development. Integrate security scanning into CI/CD."
+
+**Expected Behavior**:
+- Implement SAST (static application security testing)
+- Add dependency vulnerability scanning
+- Implement container image scanning
+- Add secrets detection (prevent commit of secrets)
+- Implement DAST (dynamic security testing) for APIs
+- Create security policy enforcement
+- Implement policy-as-code for infrastructure
+- Create override procedures for exceptions
+- Generate security reports and dashboards
+- Train developers on security issues
+
+**Success Criteria**:
+- 0 critical vulnerabilities in production
+- Security issues detected before production
+- False positive rate <10%
+- Developer awareness of security improved
+- Compliance requirements met automatically
+
+---
+
+## Example 9: Cost Optimization & FinOps
+
+**User Request**: "Our cloud bill is 40% higher than expected. Identify cost optimization opportunities."
+
+**Expected Behavior**:
+- Audit cloud spending by service and team
+- Identify unused resources and eliminate them
+- Right-size instances based on actual usage
+- Implement reserved instances for predictable workloads
+- Design spot instance strategy for batch jobs
+- Implement auto-scaling to eliminate over-provisioning
+- Create cost allocation tags
+- Set up budget alerts
+- Design cost monitoring dashboards
+- Create showback/chargeback models
+
+**Success Criteria**:
+- Cloud costs reduced by 30-40%
+- Cost per transaction optimized
+- Resource utilization improved to >70%
+- Budget alerts prevent surprises
+- Cost visibility improved across teams
+
+---
+
+## Example 10: Multi-Environment Deployment Strategy
+
+**User Request**: "We have dev, staging, and production environments but they're inconsistent. Design a strategy for environment parity."
+
+**Expected Behavior**:
+- Use Infrastructure as Code for all environments
+- Create environment templates with variables
+- Implement promotion pipeline (dev → staging → production)
+- Automate environment provisioning
+- Implement consistency checking between environments
+- Design for rapid environment recreation
+- Create environment lifecycle management
+- Implement secrets management per environment
+- Design disaster recovery for each environment
+- Create environment documentation
+
+**Success Criteria**:
+- All environments use identical infrastructure code
+- New environments provisioned in <1 hour
+- Issues found in staging before production
+- No manual environment configuration
+- Environment consistency verified automatically
+
+---
+
+## Example 11: Automated Testing Strategy
+
+**User Request**: "Our tests are flaky and don't catch bugs. Design a comprehensive automated testing strategy."
+
+**Expected Behavior**:
+- Implement unit tests with >70% coverage
+- Create integration tests for key flows
+- Design end-to-end tests for user journeys
+- Implement contract tests for APIs
+- Add performance tests and benchmarks
+- Design test data management strategy
+- Implement flake detection and quarantine
+- Create test retry strategies
+- Design test execution parallelization
+- Create test coverage dashboards
+
+**Success Criteria**:
+- Test suite runs in <10 minutes
+- >70% code coverage achieved
+- <5% test flakiness
+- 95%+ of bugs caught in testing
+- Deployment confidence increased
+
+---
+
+## Example 12: Log Aggregation & Analysis
+
+**User Request**: "Debugging production issues is difficult because logs are spread across servers. Implement centralized logging."
+
+**Expected Behavior**:
+- Set up ELK Stack (Elasticsearch, Logstash, Kibana) or equivalent
+- Implement structured logging in all services
+- Design log retention policies
+- Create dashboards for common searches
+- Implement log-based alerting
+- Design log sampling for high-volume services
+- Create log analysis tools for debugging
+- Implement performance monitoring via logs
+- Create audit logging for compliance
+- Design security logging
+
+**Success Criteria**:
+- All logs centralized and searchable
+- Issue diagnosis <5 minutes
+- Log storage costs optimized through sampling
+- Compliance logging automated
+- Debugging capability dramatically improved
+
+---
+
+## Example 13: Container Image Management
+
+**User Request**: "Build a system for managing container images across dev, staging, and production."
+
+**Expected Behavior**:
+- Set up private container registry (ECR, GCR, Harbor)
+- Implement automated image building from CI/CD
+- Design image tagging strategy
+- Implement image scanning for vulnerabilities
+- Design image promotion pipeline
+- Implement image cleanup (remove old images)
+- Design multi-architecture image support
+- Create image documentation
+- Implement image signing and verification
+- Design disaster recovery for image registry
+
+**Success Criteria**:
+- All images scanned for vulnerabilities
+- Clear image tagging enables traceability
+- Old images cleaned up automatically
+- Image storage costs optimized
+- Image promotion to production automated
+
+---
+
+## Example 14: Network Architecture & Security
+
+**User Request**: "Design network architecture that segments services and prevents unauthorized access."
+
+**Expected Behavior**:
+- Design VPC with public/private subnets
+- Implement network policies for service-to-service communication
+- Design firewall rules and security groups
+- Implement DDoS protection
+- Design VPN access for engineers
+- Implement network segmentation by environment
+- Create network monitoring and logging
+- Design network resilience (multi-AZ)
+- Implement SSL/TLS for all communication
+- Create network troubleshooting guides
+
+**Success Criteria**:
+- Services cannot communicate unless explicitly allowed
+- All external traffic encrypted
+- DDoS attacks mitigated automatically
+- Network outages detected within 1 minute
+- Security audit passes
+
+---
+
+## Example 15: GitOps & Declarative Infrastructure
+
+**User Request**: "We want Git to be the single source of truth for infrastructure and application state."
+
+**Expected Behavior**:
+- Set up ArgoCD (or Flux) for GitOps
+- Define desired state in Git for all resources
+- Implement automatic reconciliation of actual vs. declared state
+- Design Git workflow for infrastructure changes
+- Implement PR-based change management
+- Create rollback capability via Git revert
+- Implement secret management in Git
+- Design audit trail for all changes
+- Implement policy enforcement
+- Create GitOps debugging tools
+
+**Success Criteria**:
+- All infrastructure changes via Git PRs
+- Automatic rollback if deployment fails
+- Audit trail of all changes in Git
+- Developer and ops workflows unified
+- Deployment reproducibility guaranteed
+
+---