Cicd Pipeline Qe Orchestrator

CI/CD Pipeline QE Orchestrator

<default_to_action> When orchestrating quality across CI/CD pipeline: 1. ANALYZE pipeline phases: commit, build, test, staging, production 2. SELECT optimal skills and agents for each phase 3. CONFIGURE quality gates with measurable thresholds 4. EXECUTE with parallel agent coordination 5. ADAPT strategy based on risk, complexity, and environment

Quick Phase Selection:

• Commit (Shift-Left) → TDD, code review, unit tests
• Build → Coverage analysis, mutation testing, flaky detection
• Integration → API contracts, performance, security
• Staging → Chaos testing, visual regression, accessibility
• Production (Shift-Right) → Synthetic monitoring, RUM, compliance

Critical Success Factors:

• Quality gates block bad deployments
• Agents coordinate through memory namespaces
• Adapt strategy based on risk level

</default_to_action>

Quick Reference Card

When to Use

• Designing pipeline test strategies
• Implementing quality gates
• Coordinating multiple QE agents
• Shift-left and shift-right testing

Phase-Agent Matrix

Quality Gate Thresholds

Fleet Configuration

• Topology: hierarchical
• Max Agents: 10 per phase
• Coordination: aqe/* memory namespace

---

Pipeline Phases

Phase 1: Commit (Shift-Left)

Goal: Catch defects early, ensure testability

Agents:

• qe-test-generator - Generate unit tests
• qe-requirements-validator - BDD scenarios, INVEST criteria

Skills: shift-left-testing, tdd-london-chicago, code-review-quality

// Parallel execution
Task("Generate Tests", "Create unit tests for new methods", "qe-test-generator")
Task("Validate Requirements", "Check BDD scenarios", "qe-requirements-validator")

Gates: Unit coverage > 80%, Static analysis clean, Code review approved

---

Phase 2: Build

Goal: Validate integration, ensure coverage

Agents:

• qe-test-executor - Run test suites
• qe-coverage-analyzer - Coverage gaps (O(log n))
• qe-flaky-test-hunter - Detect/stabilize flaky tests
• qe-regression-risk-analyzer - Minimal regression suite

Skills: test-automation-strategy, mutation-testing, regression-testing

Task("Execute Tests", "Run full suite, store in aqe/test-results/*", "qe-test-executor")
Task("Coverage Analysis", "Identify gaps", "qe-coverage-analyzer")
Task("Flaky Detection", "Analyze test history", "qe-flaky-test-hunter")

Gates: All tests pass, Coverage > 90% critical paths, No new flaky tests

---

Phase 3: Integration/Test

Goal: Validate contracts, performance, security

Agents:

• qe-api-contract-validator - Breaking changes detection
• qe-performance-tester - Load test critical paths
• qe-security-scanner - SAST/DAST scans
• qe-test-data-architect - Realistic test data (10k+/sec)

Skills: api-testing-patterns, performance-testing, security-testing

// Parallel testing
Task("API Contracts", "Validate for breaking changes", "qe-api-contract-validator")
Task("Performance", "Load test 1000 users", "qe-performance-tester")
Task("Security", "SAST/DAST scan", "qe-security-scanner")

Gates: No breaking API changes, p95 < 200ms, No critical vulnerabilities

---

Phase 4: Staging

Goal: Validate production-like environment, resilience

Agents:

• qe-chaos-engineer - Fault injection
• qe-visual-tester - Visual regression
• qe-deployment-readiness - Risk assessment

Skills: chaos-engineering-resilience, accessibility-testing, visual-testing

Task("Chaos Testing", "Controlled failure injection", "qe-chaos-engineer")
Task("Visual Testing", "Visual regression", "qe-visual-tester")
Task("Deployment Check", "Risk assessment", "qe-deployment-readiness")

Gates: Chaos tests pass, No visual regressions, Readiness > 85%

---

Phase 5: Production (Shift-Right)

Goal: Monitor real usage, validate compliance

Agents:

• qe-production-intelligence - Incident → test scenarios
• qe-quality-analyzer - Quality metrics and trends

Skills: shift-right-testing, compliance-testing

Task("Production Intelligence", "Convert incidents to tests", "qe-production-intelligence")
Task("Quality Analysis", "Production metrics", "qe-quality-analyzer")

Gates: Synthetic monitors pass, Error rate < 0.1%, Compliance validated

---

Complete Pipeline Example

// Phase 1: Commit
Task("TDD Generation", "Generate tests for new features", "qe-test-generator")
Task("Requirements", "Validate BDD scenarios", "qe-requirements-validator")

// Phase 2: Build
Task("Execute Tests", "Full suite with coverage", "qe-test-executor")
Task("Coverage", "Analyze gaps", "qe-coverage-analyzer")
Task("Flaky Hunt", "Stabilize flaky tests", "qe-flaky-test-hunter")

// Phase 3: Integration
Task("API Contracts", "Check breaking changes", "qe-api-contract-validator")
Task("Performance", "1000 user load test", "qe-performance-tester")
Task("Security", "SAST/DAST scans", "qe-security-scanner")

// Phase 4: Staging
Task("Chaos", "Fault injection testing", "qe-chaos-engineer")
Task("Visual", "Visual regression", "qe-visual-tester")
Task("Readiness", "Deployment assessment", "qe-deployment-readiness")

// Phase 5: Production
Task("Intelligence", "Convert incidents", "qe-production-intelligence")
Task("Quality Gate", "Final validation", "qe-quality-gate")

---

Adaptive Strategy

By Risk Level

By Application Type

---

Agent Coordination Hints

Memory Namespace

aqe/pipeline/
├── phase-results/*         - Results from each phase
├── quality-gates/*         - Gate validation results
├── orchestration-plan/*    - Selected skills and agents
├── test-plan/generated     - Test plans
├── coverage/gaps           - Coverage analysis
├── security/findings       - Security results
└── performance/results     - Performance data

Fleet Orchestration

Task("Fleet Orchestration",
     "Coordinate 10 agents across phases: commit (2), build (3), test (3), staging (2)",
     "qe-fleet-commander")

Blackboard Events

---

Quality Gate Configuration

{
  "commit": {
    "gates": [
      { "metric": "unit_coverage", "threshold": 80, "blocking": true },
      { "metric": "static_analysis_critical", "max": 0, "blocking": true }
    ]
  },
  "build": {
    "gates": [
      { "metric": "all_tests_passed", "threshold": 100, "blocking": true },
      { "metric": "mutation_score", "threshold": 70, "blocking": false }
    ]
  },
  "integration": {
    "gates": [
      { "metric": "api_breaking_changes", "max": 0, "blocking": true },
      { "metric": "performance_p95_ms", "threshold": 200, "blocking": true },
      { "metric": "security_critical", "max": 0, "blocking": true }
    ]
  }
}

---

Troubleshooting

---

Related Skills

• agentic-quality-engineering - Fleet coordination
• shift-left-testing - Early defect detection
• shift-right-testing - Production monitoring
• chaos-engineering-resilience - Resilience testing

---

Remember

The CI/CD Pipeline QE Orchestrator provides:

• Phase-based strategy with optimal skill/agent selection
• Quality gates that block bad deployments
• Adaptive strategy based on risk and context
• Full fleet coordination through memory namespaces

With Agents: Use qe-fleet-commander for multi-agent orchestration. Coordinate through aqe/* memory namespace. Batch operations for efficiency.

CI/CD Pipeline QE Orchestrator

Comprehensive quality engineering orchestration across all CI/CD pipeline phases.

What is This?

The CI/CD Pipeline QE Orchestrator is an advanced Claude Code skill that provides intelligent, phase-based quality engineering across your entire software delivery pipeline. It intelligently selects from 41 QE skills and coordinates 19 specialized QE agents to ensure holistic quality coverage from commit to production.

Quick Start

1. Invoke the Skill

// In Claude Code
Skill("cicd-pipeline-qe-orchestrator")

2. Analyze Your Pipeline

Task("Pipeline Analysis",
     "Analyze our CI/CD pipeline and recommend quality strategy for all phases",
     "qe-fleet-commander")

3. Get Phase-Specific Recommendations

The orchestrator will provide:

• Skill selections per pipeline phase
• Agent coordination patterns
• Quality gate configurations
• Timing budgets
• Rollback strategies

What Makes This Different?

Traditional QE Approach

┌─────────────┐
│ Run Tests   │  Manual selection
│ Manual QA   │  Ad-hoc coverage
│ Deploy      │  Hope for the best
└─────────────┘

Orchestrated QE Approach

┌──────────────────────────────────────────────┐
│ Commit Phase (Shift-Left)                    │
│  ├─ Skills: shift-left-testing, tdd          │
│  ├─ Agents: qe-test-generator (parallel)     │
│  └─ Gates: 80% coverage, 0 critical issues   │
├──────────────────────────────────────────────┤
│ Build Phase                                  │
│  ├─ Skills: test-automation, mutation        │
│  ├─ Agents: qe-test-executor (batched)       │
│  └─ Gates: 90% coverage, mutation > 70%      │
├──────────────────────────────────────────────┤
│ Integration Phase                            │
│  ├─ Skills: api-testing, performance         │
│  ├─ Agents: qe-performance-tester (parallel) │
│  └─ Gates: p95 < 200ms, 0 security critical  │
├──────────────────────────────────────────────┤
│ Staging Phase                                │
│  ├─ Skills: chaos-engineering, visual        │
│  ├─ Agents: qe-chaos-engineer (sequential)   │
│  └─ Gates: resilience validated, 0 visual    │
├──────────────────────────────────────────────┤
│ Production Phase (Shift-Right)               │
│  ├─ Skills: shift-right-testing              │
│  ├─ Agents: qe-production-intelligence       │
│  └─ Gates: error rate < 0.1%, monitors pass  │
└──────────────────────────────────────────────┘

Key Features

🎯 Intelligent Skill Selection

Automatically selects optimal skills based on:

• Pipeline phase (commit, build, test, staging, production)
• Application type (API, web, mobile, backend)
• Risk level (critical, high, medium, low)
• Deployment frequency (continuous, daily, weekly, monthly)

🤖 Agent Coordination

Orchestrates 19 specialized QE agents:

• Parallel execution for speed
• Sequential execution for dependencies
• Memory-based coordination via aqe/* namespace
• Smart batching to avoid OOM issues

📊 Quality Gates

Configurable gates per phase:

• Coverage thresholds
• Performance SLAs
• Security vulnerability limits
• Deployment readiness scores

🔄 Adaptive Strategies

Adapts testing approach based on:

• Code change risk analysis
• Historical failure patterns
• Resource constraints
• Time budgets

Use Cases

Microservices Pipeline

// See resources/workflows/microservice-pipeline.md
// Fast feedback, contract testing, chaos engineering

Monolith Pipeline

// See resources/workflows/monolith-pipeline.md
// Smart test selection, comprehensive regression, DB migrations

Mobile App Pipeline

// See resources/workflows/mobile-pipeline.md
// Device testing, accessibility, localization, staged rollout

Integration with AQE Fleet

All 41 Skills Available

The orchestrator can invoke any of the 41 QE skills:

Phase 1 Skills (18):

• Core Testing: agentic-quality-engineering, context-driven-testing, holistic-testing-pact
• Methodologies: tdd-london-chicago, xp-practices, risk-based-testing, test-automation-strategy
• Techniques: api-testing-patterns, exploratory-testing-advanced, performance-testing, security-testing
• Code Quality: code-review-quality, refactoring-patterns, quality-metrics
• Communication: bug-reporting-excellence, technical-writing, consultancy-practices

Phase 2 Skills (16):

• Methodologies: regression-testing, shift-left-testing, shift-right-testing, test-design-techniques, mutation-testing, test-data-management
• Specialized: accessibility-testing, mobile-testing, database-testing, contract-testing, chaos-engineering-resilience, compatibility-testing, localization-testing, compliance-testing, visual-testing-advanced
• Infrastructure: test-environment-management, test-reporting-analytics

Phase 3 Skills (4):

• Strategic: six-thinking-hats, brutal-honesty-review, sherlock-review, cicd-pipeline-qe-orchestrator

Phase 4 Skills (3):

• Advanced: testability-scoring, verification-quality, pair-programming

All 19 Agents Available

The orchestrator coordinates all 19 QE agents:

Core Testing (5): test-generator, test-executor, coverage-analyzer, quality-gate, quality-analyzer Performance & Security (2): performance-tester, security-scanner Strategic Planning (3): requirements-validator, production-intelligence, fleet-commander Deployment (1): deployment-readiness Advanced Testing (4): regression-risk-analyzer, test-data-architect, api-contract-validator, flaky-test-hunter Specialized (2): visual-tester, chaos-engineer

Example Workflows

Example 1: New Feature Development

// Commit phase
Task("TDD Tests", "Generate tests for new UserService.createUser()", "qe-test-generator")
Skill("tdd-london-chicago")

// Build phase
Task("Run Tests", "Execute full suite with coverage", "qe-test-executor")
Task("Coverage Check", "Analyze and report gaps", "qe-coverage-analyzer")

// Integration phase
Task("API Tests", "Validate new API contracts", "qe-api-contract-validator")
Task("Performance", "Load test new endpoint", "qe-performance-tester")

// Production
Task("Monitor", "Track new feature adoption", "qe-production-intelligence")

Example 2: Hotfix Deployment

// Commit phase (minimal)
Task("Risk Analysis", "Identify affected code", "qe-regression-risk-analyzer")
Task("Targeted Tests", "Run minimal test suite", "qe-test-executor")

// Build phase (fast)
Task("Smoke Tests", "Critical path validation", "qe-test-executor")

// Production (monitored)
Task("Canary Deploy", "Monitor hotfix rollout", "qe-production-intelligence")

Example 3: Comprehensive Release

// Full pipeline orchestration
Skill("cicd-pipeline-qe-orchestrator")

// The skill will guide you through:
// 1. Commit phase: shift-left testing, TDD
// 2. Build phase: full regression, mutation testing
// 3. Integration: API, performance, security testing
// 4. Staging: chaos testing, visual regression
// 5. Production: staged rollout, monitoring

Configuration

Pipeline Phase Mapping

Customize phase names to match your pipeline:

const pipelinePhases = {
  commit: "pre-merge",
  build: "ci-build",
  integration: "test-env",
  staging: "uat",
  production: "prod"
};

Quality Gate Thresholds

Adjust thresholds per phase:

{
  "commit": { "coverage": 80, "max_violations": 0 },
  "build": { "coverage": 90, "mutation_score": 70 },
  "integration": { "p95_ms": 200, "security_critical": 0 },
  "staging": { "readiness_score": 85 },
  "production": { "error_rate": 0.001 }
}

Best Practices

1. Start with Quick Start

// Get recommendations first
Skill("cicd-pipeline-qe-orchestrator")

2. Adapt to Your Context

// Use context-driven testing skill
Skill("context-driven-testing")

3. Measure and Improve

// Track quality metrics
Task("Quality Trends", "Analyze quality improvements", "qe-quality-analyzer")

4. Learn from Production

// Convert incidents to tests
Task("Production Intelligence", "Turn incidents into test scenarios", "qe-production-intelligence")

Troubleshooting

See main SKILL.md Troubleshooting section for:

• Too many tests running (OOM)
• Pipeline takes too long
• Quality gates failing

Resources

• Main Skill Documentation
• Microservice Pipeline Workflow
• Monolith Pipeline Workflow
• Mobile Pipeline Workflow
• All 61 QE Skills Reference
• All 50 QE Agents Reference

Contributing

To add new pipeline workflows: 1. Create workflow in resources/workflows/[name]-pipeline.md 2. Follow existing template structure 3. Include phase-by-phase breakdown 4. Add skill and agent selections 5. Define quality gates 6. Provide complete code examples

License

Part of the Agentic QE Fleet - MIT License

---

Created: 2025-11-13 Version: 1.0.0 Integrations: 61 QE Skills, 50 QE Agents, All CI/CD platforms

Microservice CI/CD Pipeline Workflow

Complete quality orchestration workflow for microservice architectures.

Pipeline Configuration

Service Type: Microservice (REST API) Tech Stack: Node.js, Express, PostgreSQL Deployment: Kubernetes, Docker Frequency: Multiple deploys per day

---

Phase 1: Commit (Pre-Merge)

Quality Strategy

• Fast feedback (<5 minutes)
• Unit tests + static analysis
• API contract validation

Agent Orchestration

// Parallel execution for fast feedback
Task("Unit Tests", "Generate and run unit tests for changed services", "qe-test-generator")
Task("Contract Validation", "Validate service contracts haven't broken", "qe-api-contract-validator")
Task("Static Analysis", "Run static analysis and linting", "code-review-swarm")

Quality Gates

• [ ] Unit coverage > 80% on changed files
• [ ] No API contract breaks
• [ ] No critical static analysis violations
• [ ] Execution time < 5 minutes

---

Phase 2: Build (Post-Merge)

Quality Strategy

• Integration testing between services
• Contract testing with consumers
• Test data generation

Agent Orchestration

// Sequential with memory coordination
Task("Integration Tests", "Run integration tests and store results", "qe-test-executor")
Task("Coverage Analysis", "Analyze coverage from integration tests", "qe-coverage-analyzer")
Task("Contract Testing", "Run Pact consumer-driven contract tests", "qe-api-contract-validator")
Task("Data Generation", "Generate realistic test data for downstream services", "qe-test-data-architect")

Quality Gates

• [ ] All integration tests passing
• [ ] Coverage > 85% including integration
• [ ] All consumer contracts validated
• [ ] Test data generated successfully

---

Phase 3: Integration Environment

Quality Strategy

• Performance testing under load
• Security scanning (SAST/DAST)
• Chaos testing for resilience

Agent Orchestration

// Parallel execution for comprehensive validation
Task("Load Testing", "Test with 1000 concurrent requests", "qe-performance-tester")
Task("Security Scan", "Run SAST/DAST security checks", "qe-security-scanner")
Task("Chaos Testing", "Inject failures to test resilience", "qe-chaos-engineer")

Quality Gates

• [ ] p95 latency < 100ms
• [ ] p99 latency < 500ms
• [ ] No critical security vulnerabilities
• [ ] Service recovers from injected failures

---

Phase 4: Staging

Quality Strategy

• End-to-end testing across services
• Visual regression for admin UI (if applicable)
• Deployment readiness assessment

Agent Orchestration

// Staging validation
Task("E2E Tests", "Run end-to-end user journeys", "qe-test-executor")
Task("Visual Testing", "Check admin UI for regressions", "qe-visual-tester")
Task("Deployment Check", "Assess production readiness", "qe-deployment-readiness")

Quality Gates

• [ ] All E2E scenarios passing
• [ ] No visual regressions
• [ ] Deployment readiness score > 90%
• [ ] Rollback plan validated

---

Phase 5: Production

Quality Strategy

• Canary deployment with synthetic monitoring
• Production intelligence collection
• Real-time quality metrics

Agent Orchestration

// Production monitoring
Task("Production Intelligence", "Monitor canary and collect metrics", "qe-production-intelligence")
Task("Quality Analysis", "Track production quality metrics", "qe-quality-analyzer")

Quality Gates (Canary)

• [ ] Error rate < 0.1%
• [ ] Latency within 5% of baseline
• [ ] No increase in 5xx errors
• [ ] Synthetic monitors passing

---

Skill Integration

Skills Used by Phase

Commit Phase:

• shift-left-testing
• tdd-london-chicago
• api-testing-patterns

Build Phase:

• contract-testing
• test-automation-strategy
• test-data-management

Integration Phase:

• performance-testing
• security-testing
• chaos-engineering-resilience

Staging Phase:

• shift-right-testing
• visual-testing-advanced

Production Phase:

• shift-right-testing
• quality-metrics

---

Complete Pipeline Code

// Full microservice pipeline orchestration

// PHASE 1: Commit
const commitAgents = [
  Task("Unit Tests", "Generate tests for UserService", "qe-test-generator"),
  Task("Contract Validation", "Check API contracts", "qe-api-contract-validator"),
  Task("Code Review", "Automated code review", "code-review-swarm")
];

// Wait for commit gates to pass...

// PHASE 2: Build
const buildAgents = [
  Task("Integration Tests", "Run service integration tests", "qe-test-executor"),
  Task("Coverage Check", "Analyze integration coverage", "qe-coverage-analyzer"),
  Task("Pact Tests", "Validate consumer contracts", "qe-api-contract-validator")
];

// Wait for build gates to pass...

// PHASE 3: Integration
const integrationAgents = [
  Task("Load Test", "1000 concurrent users", "qe-performance-tester"),
  Task("Security Scan", "SAST/DAST checks", "qe-security-scanner"),
  Task("Chaos Test", "Inject network failures", "qe-chaos-engineer")
];

// Wait for integration gates to pass...

// PHASE 4: Staging
const stagingAgents = [
  Task("E2E Tests", "User journey validation", "qe-test-executor"),
  Task("Visual Tests", "UI regression check", "qe-visual-tester"),
  Task("Ready Check", "Deployment assessment", "qe-deployment-readiness")
];

// Wait for staging gates to pass...

// PHASE 5: Production (Canary)
const productionAgents = [
  Task("Monitor Canary", "Collect production metrics", "qe-production-intelligence"),
  Task("Quality Metrics", "Track quality trends", "qe-quality-analyzer")
];

---

Timing Budget

---

Rollback Strategy

If any phase fails:

1. Commit/Build: Block merge, developer fixes 2. Integration: Auto-rollback, investigate 3. Staging: Block deployment, team review 4. Production: Immediate rollback, incident created

---

Use Cases: REST APIs, GraphQL services, Event-driven services Team Size: 2-5 developers per service Deploy Frequency: 5-20 deploys/day

Mobile App CI/CD Pipeline Workflow

Complete quality orchestration workflow for mobile applications (iOS and Android).

Pipeline Configuration

Service Type: Native Mobile Application Tech Stack: React Native (iOS + Android) Deployment: App Store, Google Play Frequency: Bi-weekly releases

---

Phase 1: Commit (Pre-Merge)

Quality Strategy

• Unit tests for business logic
• Component snapshot tests
• Fast feedback (<5 minutes)

Agent Orchestration

// Fast mobile-specific validation
Task("Unit Tests", "Test business logic and utilities", "qe-test-generator")
Task("Snapshot Tests", "Validate component snapshots", "qe-test-executor")
Task("Code Review", "Mobile-specific code review", "code-review-swarm")

Quality Gates

• [ ] Unit tests passing
• [ ] No snapshot failures
• [ ] No critical code review issues
• [ ] Execution time < 5 minutes

---

Phase 2: Build (iOS + Android)

Quality Strategy

• Platform-specific build validation
• Integration tests on simulators/emulators
• Test data generation for offline testing

Agent Orchestration

// Parallel builds and tests
Task("iOS Build", "Build and test on iOS simulator", "qe-test-executor")
Task("Android Build", "Build and test on Android emulator", "qe-test-executor")
Task("Integration Tests", "Run E2E tests on both platforms", "qe-test-executor")
Task("Test Data", "Generate offline test data", "qe-test-data-architect")

Quality Gates

• [ ] iOS build successful
• [ ] Android build successful
• [ ] Integration tests passing (both platforms)
• [ ] No platform-specific regressions

---

Phase 3: Device Testing

Quality Strategy

• Real device testing (multiple models)
• Performance on low-end devices
• Compatibility across OS versions
• Visual regression testing

Agent Orchestration

// Device farm testing
Task("Device Testing", "Test on 20+ real devices (BrowserStack/Firebase)", "qe-test-executor")
Task("Performance Test", "Test on low-end devices", "qe-performance-tester")
Task("Visual Testing", "Visual regression across devices", "qe-visual-tester")
Task("Compatibility", "Test iOS 14-17, Android 10-14", "qe-test-executor")

Skills for Mobile Testing

// Invoke mobile testing skill
Skill("mobile-testing")  // Gestures, sensors, permissions, fragmentation

Quality Gates

• [ ] All device tests passing
• [ ] Performance acceptable on low-end devices (60fps)
• [ ] No visual regressions
• [ ] Tested on 90% of user devices (analytics-based)

---

Phase 4: Beta Testing

Quality Strategy

• Internal beta (TestFlight/Internal Testing)
• Crash analytics monitoring
• Accessibility validation
• Localization testing

Agent Orchestration

// Beta validation
Task("Crash Analysis", "Monitor crash reports from beta", "qe-production-intelligence")
Task("Accessibility", "WCAG compliance for mobile", "qe-visual-tester")
Task("Localization", "Test 10+ languages", "qe-test-executor")

Skills for Beta Testing

Skill("accessibility-testing")   // Screen readers, voice control
Skill("localization-testing")    // i18n, RTL languages

Quality Gates

• [ ] Crash-free rate > 99.5%
• [ ] Accessibility score > 90%
• [ ] All target languages validated
• [ ] Beta user feedback positive

---

Phase 5: Production Release

Quality Strategy

• Staged rollout (1% → 10% → 50% → 100%)
• App store optimization (screenshots, metadata)
• Production monitoring
• Review response monitoring

Agent Orchestration

// Production monitoring
Task("Rollout Monitoring", "Monitor staged rollout metrics", "qe-production-intelligence")
Task("Quality Metrics", "Track production quality", "qe-quality-analyzer")

Quality Gates (Per Stage)

• [ ] Crash-free rate maintained
• [ ] ANR rate < 0.1% (Android)
• [ ] App Store rating > 4.5 stars
• [ ] No increase in 1-star reviews

---

Skill Integration

Skills Used by Phase

Commit Phase:

• shift-left-testing
• tdd-london-chicago

Build Phase:

• test-automation-strategy
• test-data-management

Device Testing Phase:

• mobile-testing ⭐ (primary)
• compatibility-testing
• visual-testing-advanced
• performance-testing

Beta Testing Phase:

• accessibility-testing
• localization-testing
• exploratory-testing-advanced

Production Phase:

• shift-right-testing
• quality-metrics

---

Complete Pipeline Code

// Full mobile pipeline orchestration

// PHASE 1: Commit
Task("Unit Tests", "Business logic tests", "qe-test-generator")
Task("Snapshot Tests", "Component snapshots", "qe-test-executor")

// PHASE 2: Build (Parallel iOS + Android)
Task("iOS Build", "Build and test iOS", "qe-test-executor")
Task("Android Build", "Build and test Android", "qe-test-executor")
Task("Integration Tests", "E2E on both platforms", "qe-test-executor")

// PHASE 3: Device Testing
Task("Device Farm", "Test on 20+ devices", "qe-test-executor")
Task("Performance", "Low-end device testing", "qe-performance-tester")
Task("Visual Testing", "Cross-device visuals", "qe-visual-tester")

// Apply mobile testing skill
Skill("mobile-testing")

// PHASE 4: Beta
Task("Crash Monitoring", "Monitor beta crashes", "qe-production-intelligence")
Task("Accessibility", "Mobile a11y validation", "qe-visual-tester")
Task("Localization", "Multi-language testing", "qe-test-executor")

// Apply accessibility and localization skills
Skill("accessibility-testing")
Skill("localization-testing")

// PHASE 5: Production (Staged Rollout)
Task("Rollout Monitor", "Track staged rollout", "qe-production-intelligence")
Task("Quality Metrics", "Production quality tracking", "qe-quality-analyzer")

---

Timing Budget

---

Device Coverage Strategy

Minimum Device Coverage

iOS:

• iPhone SE (low-end)
• iPhone 12/13 (mid-range)
• iPhone 15 Pro (high-end)
• iPad (tablet)

Android:

• Samsung Galaxy A series (low-end)
• Google Pixel (mid-range)
• Samsung Galaxy S series (high-end)
• Various tablets

OS Version Coverage

iOS: Last 3 versions (iOS 15, 16, 17) Android: Last 4 versions (Android 11, 12, 13, 14)

---

Performance Benchmarks

Target Metrics

Testing

Task("Performance Benchmarks",
     "Test cold/hot start, frame rate, memory on low-end devices",
     "qe-performance-tester")

---

Accessibility Requirements

WCAG Mobile Criteria

• [ ] Touch target size (44x44 minimum)
• [ ] Screen reader support (TalkBack/VoiceOver)
• [ ] Color contrast (4.5:1 minimum)
• [ ] Keyboard navigation (external keyboard)
• [ ] Gesture alternatives
• [ ] Orientation support

Testing

Task("Mobile Accessibility",
     "Validate WCAG mobile criteria with TalkBack and VoiceOver",
     "qe-visual-tester")

Skill("accessibility-testing")

---

Localization Coverage

Priority Languages

1. English (en) 2. Spanish (es) 3. French (fr) 4. German (de) 5. Chinese Simplified (zh-CN) 6. Japanese (ja) 7. Arabic (ar) - RTL testing

Testing

Task("Localization Testing",
     "Test all 7 languages including RTL for Arabic",
     "qe-test-executor")

Skill("localization-testing")

---

Staged Rollout Strategy

Rollout Phases

Phase 1 (1%): Internal team + power users (24 hours) Phase 2 (10%): Early adopters (48 hours) Phase 3 (50%): Broader audience (48 hours) Phase 4 (100%): All users

Monitoring Per Phase

// Monitor each rollout phase
Task("Phase 1 Monitoring", "Track 1% rollout metrics", "qe-production-intelligence")
// Check gates, then proceed to next phase
Task("Phase 2 Monitoring", "Track 10% rollout metrics", "qe-production-intelligence")
// Repeat for each phase...

Rollback Triggers

• Crash rate > 1%
• ANR rate > 0.5% (Android)
• App rating drops below 4.0
• Critical bug reported by > 10 users

---

App Store Optimization

Pre-Release Checklist

• [ ] App store screenshots (all device sizes)
• [ ] App preview videos
• [ ] Metadata in all languages
• [ ] Privacy policy updated
• [ ] What's New section written
• [ ] Keywords optimized

Visual Testing

Task("ASO Visual Check",
     "Validate app store screenshots and previews",
     "qe-visual-tester")

---

Use Cases: Consumer apps, Enterprise mobile apps, Mobile games Team Size: 5-15 developers Deploy Frequency: Bi-weekly releases Platforms: iOS (App Store), Android (Google Play) Testing: Device farms (BrowserStack, Firebase Test Lab)

Monolith CI/CD Pipeline Workflow

Complete quality orchestration workflow for monolithic applications.

Pipeline Configuration

Service Type: Monolithic Web Application Tech Stack: Full-stack (Frontend + Backend) Deployment: Traditional servers, VM-based Frequency: Weekly releases

---

Phase 1: Commit (Pre-Merge)

Quality Strategy

• Fast feedback on changed modules
• Component-level testing
• Risk-based test selection

Agent Orchestration

// Smart test selection for large codebase
Task("Risk Analysis", "Identify affected modules and tests", "qe-regression-risk-analyzer")
Task("Targeted Tests", "Run minimal test suite based on changes", "qe-test-executor")
Task("Flaky Detection", "Check for flaky tests in suite", "qe-flaky-test-hunter")

Quality Gates

• [ ] Affected modules tested (100% coverage)
• [ ] No flaky tests in selection
• [ ] No breaking changes to public APIs
• [ ] Execution time < 10 minutes

---

Phase 2: Build (Full Suite)

Quality Strategy

• Comprehensive regression testing
• Full coverage analysis
• Mutation testing for critical paths

Agent Orchestration

// Full regression suite (batched execution)
Task("Full Regression", "Run complete test suite in batches", "qe-test-executor")
Task("Coverage Analysis", "Analyze coverage across all modules", "qe-coverage-analyzer")
Task("Mutation Testing", "Validate test quality on critical code", "qe-test-executor")

Quality Gates

• [ ] All 1000+ tests passing
• [ ] Coverage > 85% overall
• [ ] Coverage > 95% on critical paths
• [ ] Mutation score > 75%

---

Phase 3: Integration / Test Environment

Quality Strategy

• Database migration testing
• Performance baseline validation
• Security compliance scanning
• Accessibility validation

Agent Orchestration

// Comprehensive validation
Task("DB Migration", "Validate database schema changes", "qe-test-executor")
Task("Performance Baseline", "Establish performance benchmarks", "qe-performance-tester")
Task("Security Compliance", "OWASP Top 10 + compliance checks", "qe-security-scanner")
Task("Accessibility", "WCAG 2.2 validation", "qe-visual-tester")

Quality Gates

• [ ] Database migrations successful
• [ ] Performance within 10% of baseline
• [ ] No critical/high security vulnerabilities
• [ ] WCAG AA compliance achieved

---

Phase 4: UAT / Staging

Quality Strategy

• Exploratory testing sessions
• Visual regression across browsers
• Mobile compatibility
• User acceptance criteria validation

Agent Orchestration

// User acceptance and compatibility
Task("Visual Regression", "Test across Chrome, Firefox, Safari, Edge", "qe-visual-tester")
Task("Mobile Testing", "iOS and Android compatibility", "qe-visual-tester")
Task("Deployment Readiness", "Pre-production assessment", "qe-deployment-readiness")

Skills for Manual Testing

// Invoke skills for exploratory testing guidance
Skill("exploratory-testing-advanced")  // SBTM session planning
Skill("context-driven-testing")        // Adapt testing to context

Quality Gates

• [ ] Visual tests passing (4 browsers)
• [ ] Mobile responsive (iOS/Android)
• [ ] UAT sign-off received
• [ ] Deployment checklist complete

---

Phase 5: Production

Quality Strategy

• Blue-green deployment
• Smoke tests in production
• Compliance validation
• Production monitoring

Agent Orchestration

// Production validation
Task("Smoke Tests", "Run critical path smoke tests", "qe-test-executor")
Task("Compliance Check", "GDPR, HIPAA, SOC2 validation", "qe-quality-gate")
Task("Production Intelligence", "Monitor first hour metrics", "qe-production-intelligence")

Quality Gates

• [ ] All smoke tests passing
• [ ] Compliance checks passed
• [ ] Error rate < 0.5%
• [ ] No user-reported critical bugs (first 24h)

---

Skill Integration

Skills Used by Phase

Commit Phase:

• shift-left-testing
• risk-based-testing
• regression-testing

Build Phase:

• test-automation-strategy
• mutation-testing
• refactoring-patterns

Integration Phase:

• database-testing
• performance-testing
• security-testing
• accessibility-testing

UAT/Staging Phase:

• exploratory-testing-advanced
• context-driven-testing
• compatibility-testing
• visual-testing-advanced

Production Phase:

• shift-right-testing
• compliance-testing
• quality-metrics

---

Complete Pipeline Code

// Full monolith pipeline orchestration

// PHASE 1: Commit (Smart Selection)
Task("Risk Analysis", "Select minimal test suite for changes", "qe-regression-risk-analyzer")
Task("Targeted Testing", "Run selected tests", "qe-test-executor")

// PHASE 2: Build (Full Suite)
Task("Full Regression", "Run all 1000+ tests in batches", "qe-test-executor")
Task("Coverage Analysis", "Analyze full coverage", "qe-coverage-analyzer")
Task("Mutation Testing", "Test quality validation", "qe-test-executor")

// PHASE 3: Integration
Task("DB Migrations", "Validate schema changes", "qe-test-executor")
Task("Performance Test", "Baseline performance validation", "qe-performance-tester")
Task("Security Scan", "OWASP + compliance scanning", "qe-security-scanner")
Task("Accessibility", "WCAG 2.2 validation", "qe-visual-tester")

// PHASE 4: UAT/Staging
Task("Visual Regression", "Cross-browser testing", "qe-visual-tester")
Task("Mobile Testing", "iOS/Android compatibility", "qe-visual-tester")
Task("Readiness Check", "Deployment assessment", "qe-deployment-readiness")

// Manual testing with skill guidance
Skill("exploratory-testing-advanced")

// PHASE 5: Production
Task("Smoke Tests", "Critical path validation", "qe-test-executor")
Task("Compliance", "Regulatory validation", "qe-quality-gate")
Task("Monitoring", "Production intelligence", "qe-production-intelligence")

---

Timing Budget

---

Weekly Release Schedule

Monday: Freeze features, start testing Tuesday-Wednesday: Integration + UAT Thursday: Staging validation Friday: Production deployment (morning) Weekend: Monitor production

---

Database Migration Strategy

Pre-Deploy Validation

// Validate migrations before deployment
Task("Schema Validation", "Check migrations are reversible", "qe-test-executor")
Task("Data Integrity", "Validate data after migration", "qe-test-executor")

Post-Deploy Verification

// Verify migrations in production
Task("Production Validation", "Check schema and data integrity", "qe-production-intelligence")

---

Rollback Strategy

Build Failure: Fix and rebuild Integration Failure: Investigate, may delay release UAT Failure: Block release, fix critical issues Production Issues: Blue-green rollback, investigate

---

Use Cases: E-commerce, CMS, Enterprise web apps Team Size: 10-50 developers Deploy Frequency: Weekly releases Database: PostgreSQL, MySQL with migrations