Skip to main content
skill CX Codex

qe-chaos-resilience — Claude Code skill: chaos & resilience testing

qe-chaos-resilience — a skill for Claude Code, Codex, Cursor and other agents that injects controlled faults into distributed systems and checks recovery behavior. Runs during circuit breaker, failover, and retry logic validation.

MIT 123 installs ★ 533 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add proffesor-for-testing/agentic-qe --skill qe-chaos-resilience -a claude-code
Open on GitHub

What qe-chaos-resilience does

The skill equips the agent with aqe chaos run, aqe chaos load, aqe chaos stress, and aqe chaos circuit-breaker commands, delegating execution to dedicated sub-agents: qe-chaos-engineer, qe-load-tester, and qe-resilience-tester.

Six fault types are covered: network latency, packet loss, CPU stress, memory pressure, disk fill, and process kill. Load scenarios follow a ramp-up / steady-state / ramp-down profile, and stress tests step through user counts to locate the breaking point. After each experiment the agent produces a report with before/during/after metric snapshots, recovery time, and severity-rated findings.

Safety controls cap blast radius at 10% of affected pods and trigger automatic rollback when error rate exceeds 50% or p99 latency goes above 10 seconds. Environments tagged production-critical are excluded, and production runs require two approvals — so the skill will not fire against live critical systems without explicit sign-off.

What it helps with

  • verify that a circuit breaker trips under 500ms network latency
  • run a peak-traffic load test against an SLA at 5000 concurrent users
  • find the breaking point of /api/checkout with step-increase stress testing
  • confirm automatic recovery from pod termination within 30 seconds
  • validate data integrity across a database-failover scenario

Example prompts for the agent

  • Run a chaos experiment on api-service: inject 500ms latency and report recovery time
  • Execute the peak-traffic load test, ramp to 10,000 users over 5 minutes, hold for 30 minutes, compare results against SLAs
  • Test the circuit breaker for payment-service and generate a full chaos report with severity findings

How to install qe-chaos-resilience

1Skills CLI (Vercel)

npx skills add proffesor-for-testing/agentic-qe --skill qe-chaos-resilience -a claude-code

2Manually: put the files in place

~/.claude/skills/qe-chaos-resilience/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/qe-chaos-resilience/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about qe-chaos-resilience

How do I install qe-chaos-resilience in Claude Code?

Run npx skills add proffesor-for-testing/agentic-qe --skill qe-chaos-resilience -a claude-code. The skill file will be placed at ~/.claude/skills/qe-chaos-resilience/SKILL.md.

What does qe-chaos-resilience do?

It teaches the agent to run fault injection experiments, load and stress tests, and recovery validation for distributed systems. Each experiment produces a structured report with metric snapshots, recovery time, and severity-rated recommendations.

Does the skill protect production environments?

Environments marked production-critical are excluded from all experiments. Any other production target requires two approvals before the agent proceeds, and automatic rollback fires when error rate tops 50% or p99 latency exceeds 10 seconds.

Source text

SKILL.md · MIT
---
name: "qe-chaos-resilience"
description: "Injects controlled faults (network partition, latency, process kill, disk pressure) into distributed systems and validates recovery behavior. Use when testing circuit breakers, failover paths, retry logic, or building confidence in system resilience through chaos engineering."
trust_tier: 3
validation:
  schema_path: schemas/output.json
  validator_path: scripts/validate-config.json
  eval_path: evals/qe-chaos-resilience.yaml
---

# QE Chaos Resilience

## Purpose

Guide the use of v3's chaos engineering capabilities including controlled fault injection, load/stress testing, resilience validation, and disaster recovery testing.

## Activation

- When testing system resilience
- When performing chaos experiments
- When load/stress testing
- When validating disaster recovery
- When testing circuit breakers

## Quick Start

```bash
# Run chaos experiment
aqe chaos run --experiment network-latency --target api-service

# Load test
aqe chaos load --scenario peak-traffic --duration 30m

# Stress test to breaking point
aqe chaos stress --endpoint /api/users --max-users 10000

# Test circuit breaker
aqe chaos circuit-breaker --service payment-service
```

## Agent Workflow

```typescript
// Chaos experiment
Task("Run chaos experiment", `
  Execute controlled chaos on api-service:
  - Inject 500ms network latency
  - Monitor service health metrics
  - Verify circuit breaker activation
  - Measure recovery time
  - Document findings
`, "qe-chaos-engineer")

// Load testing
Task("Performance load test", `
  Run load test simulating Black Friday traffic:
  - Ramp up to 10,000 concurrent users
  - Maintain load for 30 minutes
  - Monitor response times and error rates
  - Identify bottlenecks
  - Compare against SLAs
`, "qe-load-tester")
```

## Chaos Experiments

### 1. Fault Injection

```typescript
await chaosEngineer.injectFault({
  target: 'api-service',
  fault: {
    type: 'latency',
    parameters: {
      delay: '500ms',
      jitter: '100ms',
      percentage: 50
    }
  },
  duration: '5m',
  monitoring: {
    metrics: ['response_time', 'error_rate', 'throughput'],
    alerts: true
  },
  rollback: {
    automatic: true,
    trigger: 'error_rate > 10%'
  }
});
```

### 2. Load Testing

```typescript
await loadTester.execute({
  scenario: 'peak-traffic',
  profile: {
    rampUp: '5m',
    steadyState: '30m',
    rampDown: '5m'
  },
  users: {
    initial: 100,
    target: 5000,
    pattern: 'linear'
  },
  assertions: {
    p95_latency: '<500ms',
    error_rate: '<1%',
    throughput: '>1000rps'
  }
});
```

### 3. Stress Testing

```typescript
await loadTester.stressTest({
  endpoint: '/api/checkout',
  strategy: 'step-increase',
  steps: [100, 500, 1000, 2000, 5000],
  stepDuration: '5m',
  findBreakingPoint: true,
  monitoring: {
    resourceUtilization: true,
    databaseConnections: true,
    memoryUsage: true
  }
});
```

### 4. Resilience Validation

```typescript
await resilienceTester.validate({
  scenarios: [
    'database-failover',
    'cache-failure',
    'external-service-timeout',
    'pod-termination'
  ],
  expectations: {
    gracefulDegradation: true,
    automaticRecovery: true,
    dataIntegrity: true,
    recoveryTime: '<30s'
  }
});
```

## Fault Types

| Fault | Description | Use Case |
|-------|-------------|----------|
| Latency | Add network delay | Test timeouts |
| Packet Loss | Drop network packets | Test retry logic |
| CPU Stress | Consume CPU | Test resource limits |
| Memory Pressure | Consume memory | Test OOM handling |
| Disk Full | Fill disk space | Test disk errors |
| Process Kill | Terminate process | Test recovery |

## Chaos Report

```typescript
interface ChaosReport {
  experiment: {
    name: string;
    target: string;
    fault: FaultConfig;
    duration: number;
  };
  results: {
    hypothesis: string;
    validated: boolean;
    metrics: {
      before: MetricSnapshot;
      during: MetricSnapshot;
      after: MetricSnapshot;
    };
    events: ChaosEvent[];
    recovery: {
      detected: boolean;
      time: number;
      automatic: boolean;
    };
  };
  findings: {
    severity: 'critical' | 'high' | 'medium' | 'low';
    description: string;
    recommendation: string;
  }[];
  artifacts: {
    logs: string;
    metrics: string;
    traces: string;
  };
}
```

## Safety Controls

```yaml
safety:
  blast_radius:
    max_affected_pods: 1
    max_affected_percentage: 10

  abort_conditions:
    - error_rate > 50%
    - p99_latency > 10s
    - service_unavailable

  excluded_environments:
    - production-critical

  required_approvals:
    production: 2
    staging: 0
```

## SLA Validation

```typescript
await resilienceTester.validateSLA({
  slas: {
    availability: 99.9,
    p95_latency: 500,
    error_rate: 0.1
  },
  period: '30d',
  report: {
    breaches: true,
    trends: true,
    projections: true
  }
});
```

## Coordination

**Primary Agents**: qe-chaos-engineer, qe-load-tester, qe-resilience-tester
**Coordinator**: qe-chaos-coordinator
**Related Skills**: qe-performance, security-testing

© proffesor-for-testing · MIT · proffesor-for-testing/agentic-qe

Similar skills

All skills for Testing and QA →

From the same set73

The whole set →
xp-practices xp-practices — a skill for pair programming, continuous integration, TDD, and other extreme programming practices in AI coding. CX Codex +1 125installs context-driven-testing context-driven-testing adapts software testing strategies to specific project constraints, risks, and goals instead of blindly applying generic best practices. CX Codex +1 125installs n8n-integration-testing-patterns n8n-integration-testing-patterns is a Claude Code skill for testing API contracts, authentication flows, and rate limits in n8n integrations. CX Codex +1 124installs tdd-london-chicago tdd-london-chicago — a skill for choosing London or Chicago TDD, using mocks or real objects, and moving through the Red–Green–Refactor cycle. CX Codex +1 124installs consultancy-practices consultancy-practices is a Claude Code skill that applies software quality consulting practices: it identifies client pain, prioritizes work by impact and effort, and transfers knowledge. CX Codex +1 122installs mutation-testing Skill runs mutation testing: mutates code (operators, boundaries, logic), runs tests, and counts surviving mutants — weak spots in your test suite. CX Codex +1 122installs qe-code-intelligence qe-code-intelligence builds a semantic code index, dependency graphs and knowledge graphs. Helps understand unfamiliar codebases, trace call chains, and find code by meaning rather than keywords. CX Codex +1 122installs qe-test-execution qe-test-execution orchestrates Jest, Vitest, and Playwright suites using the aqe CLI with parallel workers, affected-test selection, and flaky test retries. CX Codex +1 122installs

Project sponsors

Companies that keep this analytics open