Chaos Engineering Resilience
- 110 installs
- 433 repo stars
- Updated August 4, 2026
- proffesor-for-testing/agentic-qe
chaos-engineering-resilience is a Claude Code skill for ai & agent building.
About
chaos-engineering-resilience is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted development.
- chaos-engineering-resilience
- AI & Agent Building
- AI-coding skill
Chaos Engineering Resilience by the numbers
- 110 all-time installs (skills.sh)
- +6 installs in the week ending Aug 4, 2026 (Skillselion tracking)
- Ranked #4,062 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
- Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/proffesor-for-testing/agentic-qe --skill chaos-engineering-resilienceAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 110 |
|---|---|
| repo stars | ★ 433 |
| Last updated | August 4, 2026 |
| Repository | proffesor-for-testing/agentic-qe ↗ |
How do I helps with ai & agent building tasks.?
Helps with ai & agent building tasks.
Who is it for?
Best when you're working on ai & agent building and need structured help with chaos engineering resilience.
Skip if: Teams with no ai & agent building needs, or anyone wanting a generic chat assistant without this specific workflow.
When should I use this skill?
When you need to helps with ai & agent building tasks., or when chaos-engineering-resilience is a claude code skill for ai & agent building.
What you get
Structured output aligned to chaos-engineering-resilience: chaos-engineering-resilience, AI & Agent Building.
Files
Chaos Engineering & Resilience Testing
<default_to_action> When testing system resilience or injecting failures: 1. DEFINE steady state (normal metrics: error rate, latency, throughput) 2. HYPOTHESIZE system continues in steady state during failure 3. INJECT real-world failures (network, instance, disk, CPU) 4. OBSERVE and measure deviation from steady state 5. FIX weaknesses discovered, document runbooks, repeat
Quick Chaos Steps:
- Start small: Dev → Staging → 1% prod → gradual rollout
- Define clear rollback triggers (error_rate > 5%)
- Measure blast radius, never exceed planned scope
- Document findings → runbooks → improved resilience
Critical Success Factors:
- Controlled experiments with automatic rollback
- Steady state must be measurable
- Start in non-production, graduate to production
</default_to_action>
Quick Reference Card
When to Use
- Distributed systems validation
- Disaster recovery testing
- Building confidence in fault tolerance
- Pre-production resilience verification
Failure Types to Inject
| Category | Failures | Tools |
|---|---|---|
| Network | Latency, packet loss, partition | tc, toxiproxy |
| Infrastructure | Instance kill, disk failure, CPU | Chaos Monkey |
| Application | Exceptions, slow responses, leaks | Gremlin, LitmusChaos |
| Dependencies | Service outage, timeout | WireMock |
Blast Radius Progression
Dev (safe) → Staging → 1% prod → 10% → 50% → 100%
↓ ↓ ↓ ↓
Learn Validate Careful Full confidenceSteady State Metrics
| Metric | Normal | Alert Threshold |
|---|---|---|
| Error rate | < 0.1% | > 1% |
| p99 latency | < 200ms | > 500ms |
| Throughput | baseline | -20% |
---
Chaos Experiment Structure
// Chaos experiment definition
const experiment = {
name: 'Database latency injection',
hypothesis: 'System handles 500ms DB latency gracefully',
steadyState: {
errorRate: '< 0.1%',
p99Latency: '< 300ms'
},
method: {
type: 'network-latency',
target: 'database',
delay: '500ms',
duration: '5m'
},
rollback: {
automatic: true,
trigger: 'errorRate > 5%'
}
};---
Agent-Driven Chaos
// qe-chaos-engineer runs controlled experiments
await Task("Chaos Experiment", {
target: 'payment-service',
failure: 'terminate-random-instance',
blastRadius: '10%',
duration: '5m',
steadyStateHypothesis: {
metric: 'success-rate',
threshold: 0.99
},
autoRollback: true
}, "qe-chaos-engineer");
// Validates:
// - System recovers automatically
// - Error rate stays within threshold
// - No data loss
// - Alerts triggered appropriately---
Agent Coordination Hints
Memory Namespace
aqe/chaos-engineering/
├── experiments/* - Experiment definitions & results
├── steady-states/* - Baseline measurements
├── runbooks/* - Generated recovery procedures
└── blast-radius/* - Impact analysisFleet Coordination
const chaosFleet = await FleetManager.coordinate({
strategy: 'chaos-engineering',
agents: [
'qe-chaos-engineer', // Experiment execution
'qe-performance-tester', // Baseline metrics
'qe-production-intelligence' // Production monitoring
],
topology: 'sequential'
});---
Related Skills
- shift-right-testing - Production testing
- performance-testing - Load testing
- test-environment-management - Environment stability
---
Remember
Break things on purpose to prevent unplanned outages. Find weaknesses before users do. Define steady state, inject failures, measure impact, fix weaknesses, create runbooks. Start small, increase blast radius gradually.
With Agents: qe-chaos-engineer automates chaos experiments with blast radius control, automatic rollback, and comprehensive resilience validation. Generates runbooks from experiment results.
# =============================================================================
# AQE Skill Evaluation Test Suite: Chaos Engineering Resilience v1.0.0
# =============================================================================
#
# Comprehensive evaluation suite for the chaos-engineering-resilience skill
# per ADR-056. Tests fault injection, steady-state validation, blast radius
# control, recovery time measurement, and resilience scoring.
#
# Schema: .claude/skills/.validation/schemas/skill-eval.schema.json
# Validator: .claude/skills/chaos-engineering-resilience/scripts/validate-config.json
#
# Coverage:
# - Network chaos (latency, packet loss, partition)
# - Resource chaos (CPU stress, memory exhaust, disk fill)
# - Infrastructure chaos (pod kill, node drain, zone failure)
# - Application chaos (exception injection, deadlocks)
# - Byzantine fault tolerance (malicious nodes, split-brain)
# - Spike and ramp-up load testing
# - Negative tests (safety controls validation)
#
# =============================================================================
skill: chaos-engineering-resilience
version: 1.0.0
description: >
Comprehensive evaluation suite for the chaos-engineering-resilience skill.
Tests fault injection types, steady-state hypothesis validation, blast
radius controls, recovery time measurement, Byzantine fault tolerance,
and resilience scoring. Supports multi-model testing and integrates with
ReasoningBank for continuous improvement.
# =============================================================================
# Multi-Model Configuration
# =============================================================================
models_to_test:
- claude-opus-4-8 # Capability ceiling (high-stakes skill)
- claude-sonnet-4-6 # Primary (high accuracy expected)
- claude-haiku-4-5 # Fast model (minimum quality floor)
# =============================================================================
# MCP Integration Configuration
# =============================================================================
mcp_integration:
enabled: true
namespace: skill-validation
# Query existing chaos patterns before running evals
query_patterns: true
# Track each test outcome for learning feedback loop
track_outcomes: true
# Store successful patterns after evals complete
store_patterns: true
# Share learning with fleet coordinator agents
share_learning: true
# Update quality gate with validation metrics
update_quality_gate: true
# Target agents for learning distribution
target_agents:
- qe-learning-coordinator
- qe-queen-coordinator
- qe-chaos-engineer
- qe-performance-tester
# =============================================================================
# ReasoningBank Learning Configuration
# =============================================================================
learning:
store_success_patterns: true
store_failure_patterns: true
pattern_ttl_days: 90
min_confidence_to_store: 0.7
cross_model_comparison: true
# =============================================================================
# Result Format Configuration
# =============================================================================
result_format:
json_output: true
markdown_report: true
include_raw_output: false
include_timing: true
include_token_usage: true
# =============================================================================
# Environment Setup
# =============================================================================
setup:
required_tools:
- jq # JSON parsing (required)
environment_variables:
CHAOS_ENABLED: "true"
BLAST_RADIUS_LIMIT: "single-service"
SAFETY_CONTROLS: "enabled"
fixtures:
- name: kubernetes_deployment
path: fixtures/kubernetes-deployment.yaml
content: |
apiVersion: apps/v1
kind: Deployment
metadata:
name: user-service
namespace: production
spec:
replicas: 3
selector:
matchLabels:
app: user-service
template:
metadata:
labels:
app: user-service
spec:
containers:
- name: user-service
image: user-service:v1.2.3
resources:
limits:
cpu: "500m"
memory: "512Mi"
# =============================================================================
# TEST CASES
# =============================================================================
test_cases:
# ---------------------------------------------------------------------------
# CATEGORY: Network Chaos
# ---------------------------------------------------------------------------
- id: tc001_network_latency_injection
description: "Test network latency injection and system tolerance"
category: network
priority: critical
input:
scenario: |
Target: user-service in production
Inject: 500ms latency with 100ms jitter
Duration: 10 minutes
Blast radius: 50% of pods
Steady-state: error_rate < 1%, p99 < 300ms
context:
environment: staging
kubernetes: true
service_mesh: istio
expected_output:
must_contain:
- "latency"
- "steady-state"
- "recovery"
- "experiment"
must_not_contain:
- "no impact"
- "skipped"
must_match_regex:
- "CHAOS-\\d{3,6}"
- "network|latency"
experiment_result: ["passed", "partial"]
experiment_count:
min: 1
max: 5
weakness_count:
max: 5
validation:
schema_check: true
keyword_match_threshold: 0.8
reasoning_quality_min: 0.7
timeout_ms: 60000
- id: tc002_network_partition_zones
description: "Test network partition between availability zones"
category: network
priority: critical
input:
scenario: |
Target: Cross-zone communication between zone-a and zone-b
Inject: Full network partition
Duration: 15 minutes
Blast radius: All cross-zone traffic
Steady-state: availability > 99%, database failover < 5s
context:
environment: staging
multi_zone: true
expected_output:
must_contain:
- "partition"
- "zone"
- "failover"
- "availability"
must_match_regex:
- "CHAOS-\\d{3,6}"
- "zone|partition"
experiment_result: ["passed", "partial", "failed"]
validation:
schema_check: true
keyword_match_threshold: 0.7
- id: tc003_packet_loss_simulation
description: "Test packet loss simulation and retry handling"
category: network
priority: high
input:
scenario: |
Target: payment-service
Inject: 10% packet loss with 50% correlation
Duration: 5 minutes
Steady-state: success_rate > 99%
context:
environment: staging
expected_output:
must_contain:
- "packet"
- "loss"
- "retry"
must_match_regex:
- "CHAOS-\\d{3,6}"
validation:
schema_check: true
keyword_match_threshold: 0.7
# ---------------------------------------------------------------------------
# CATEGORY: Resource Chaos
# ---------------------------------------------------------------------------
- id: tc004_cpu_stress_test
description: "Test CPU stress and auto-scaling response"
category: resource
priority: high
input:
scenario: |
Target: compute-service pods
Inject: 90% CPU load for 10 minutes
Blast radius: 2 pods out of 6
Steady-state: response_time_p99 < 500ms
Expected: Auto-scaling triggers new pods
context:
environment: staging
auto_scaling: true
expected_output:
must_contain:
- "CPU"
- "stress"
- "scaling"
must_match_regex:
- "CHAOS-\\d{3,6}"
- "resource|cpu"
experiment_result: ["passed", "partial"]
validation:
schema_check: true
keyword_match_threshold: 0.7
- id: tc005_memory_exhaustion
description: "Test memory exhaustion and OOM behavior"
category: resource
priority: critical
input:
scenario: |
Target: data-processor service
Inject: Fill 90% of container memory
Duration: 8 minutes
Steady-state: No OOM kills, graceful degradation
Blast radius: 1 pod
context:
environment: staging
memory_limits: true
expected_output:
must_contain:
- "memory"
- "OOM"
- "graceful"
must_match_regex:
- "CHAOS-\\d{3,6}"
validation:
schema_check: true
keyword_match_threshold: 0.7
- id: tc006_disk_iops_limit
description: "Test disk IOPS throttling impact on database"
category: resource
priority: high
input:
scenario: |
Target: database service
Inject: Limit IOPS to 100 (from baseline 1000)
Duration: 5 minutes
Steady-state: query_latency_p99 < 200ms
Blast radius: Single database pod
context:
environment: staging
database: postgresql
expected_output:
must_contain:
- "disk"
- "IOPS"
- "database"
- "latency"
must_match_regex:
- "CHAOS-\\d{3,6}"
validation:
schema_check: true
keyword_match_threshold: 0.7
# ---------------------------------------------------------------------------
# CATEGORY: Infrastructure Chaos
# ---------------------------------------------------------------------------
- id: tc007_pod_termination
description: "Test pod termination and restart behavior"
category: infrastructure
priority: critical
input:
scenario: |
Target: api-gateway pods
Inject: Terminate 50% of pods randomly
Duration: Instant, observe recovery
Steady-state: availability > 99.9%
Expected: Kubernetes restarts pods, no user impact
context:
environment: staging
replicas: 6
expected_output:
must_contain:
- "pod"
- "terminate"
- "restart"
- "recovery"
must_match_regex:
- "CHAOS-\\d{3,6}"
- "infrastructure|pod"
experiment_result: ["passed", "partial"]
recovery_time:
max_ms: 30000
validation:
schema_check: true
keyword_match_threshold: 0.8
- id: tc008_node_drain_simulation
description: "Test node drain and workload redistribution"
category: infrastructure
priority: high
input:
scenario: |
Target: Worker node hosting critical services
Inject: Drain node (cordon + evict pods)
Duration: Until redistribution complete
Steady-state: All services remain available
Blast radius: 1 node
context:
environment: staging
node_count: 5
expected_output:
must_contain:
- "node"
- "drain"
- "redistribute"
- "evict"
must_match_regex:
- "CHAOS-\\d{3,6}"
validation:
schema_check: true
keyword_match_threshold: 0.7
# ---------------------------------------------------------------------------
# CATEGORY: Application Chaos
# ---------------------------------------------------------------------------
- id: tc009_exception_injection
description: "Test exception injection and error handling"
category: application
priority: high
input:
scenario: |
Target: order-service
Inject: RuntimeException on 10% of requests
Duration: 5 minutes
Steady-state: error_rate < 5%, circuit_breaker triggers
Expected: Circuit breaker protects downstream services
context:
environment: staging
circuit_breaker: true
expected_output:
must_contain:
- "exception"
- "circuit breaker"
- "error"
must_match_regex:
- "CHAOS-\\d{3,6}"
- "application|exception"
validation:
schema_check: true
keyword_match_threshold: 0.7
- id: tc010_connection_pool_exhaust
description: "Test database connection pool exhaustion"
category: application
priority: high
input:
scenario: |
Target: user-service database connections
Inject: Exhaust connection pool (hold connections)
Duration: 3 minutes
Steady-state: Service remains responsive with queue
Expected: Connection timeout and retry behavior
context:
environment: staging
pool_size: 50
expected_output:
must_contain:
- "connection"
- "pool"
- "exhaust"
- "timeout"
must_match_regex:
- "CHAOS-\\d{3,6}"
validation:
schema_check: true
keyword_match_threshold: 0.7
# ---------------------------------------------------------------------------
# CATEGORY: Byzantine Fault Tolerance
# ---------------------------------------------------------------------------
- id: tc011_byzantine_malicious_node
description: "Test Byzantine fault tolerance with malicious node"
category: byzantine
priority: critical
input:
scenario: |
Target: Consensus cluster (7 nodes, f=2 tolerance)
Inject: 1 node sends incorrect values to subset of nodes
Duration: 10 minutes
Steady-state: Consensus reached with correct values
Expected: System tolerates 1 Byzantine node (f < n/3)
context:
environment: staging
consensus: pbft
nodes: 7
expected_output:
must_contain:
- "Byzantine"
- "consensus"
- "malicious"
- "tolerance"
must_match_regex:
- "CHAOS-\\d{3,6}"
- "byzantine|consensus"
experiment_result: ["passed"]
validation:
schema_check: true
keyword_match_threshold: 0.8
reasoning_quality_min: 0.8
- id: tc012_split_brain_scenario
description: "Test split-brain detection and resolution"
category: byzantine
priority: critical
input:
scenario: |
Target: Distributed database cluster
Inject: Network partition causing split-brain
Duration: 5 minutes
Steady-state: No conflicting writes accepted
Expected: Leader election resolves split-brain
context:
environment: staging
database: distributed
expected_output:
must_contain:
- "split-brain"
- "partition"
- "leader"
- "election"
must_match_regex:
- "CHAOS-\\d{3,6}"
- "split|brain|partition"
validation:
schema_check: true
keyword_match_threshold: 0.7
# ---------------------------------------------------------------------------
# CATEGORY: Load Testing (Spike/Ramp)
# ---------------------------------------------------------------------------
- id: tc013_spike_load_test
description: "Test sudden 10x load spike and auto-scaling"
category: load
priority: critical
input:
scenario: |
Target: api-gateway
Inject: Sudden spike from 100 req/s to 1000 req/s
Duration: 60 seconds spike, then observe recovery
Steady-state: error_rate < 5%, p99 < 500ms
Expected: Auto-scaling handles spike within 45s
context:
environment: staging
auto_scaling: true
expected_output:
must_contain:
- "spike"
- "load"
- "scaling"
- "recovery"
must_match_regex:
- "CHAOS-\\d{3,6}"
- "spike|load|ramp"
validation:
schema_check: true
keyword_match_threshold: 0.7
- id: tc014_ramp_up_capacity_test
description: "Test gradual ramp-up to find capacity limits"
category: load
priority: high
input:
scenario: |
Target: order-service
Inject: Ramp from 100 req/s to 1600 req/s (2x every 5 min)
Duration: 25 minutes total
Steady-state: Track degradation point
Expected: Identify max capacity before degradation
context:
environment: staging
expected_output:
must_contain:
- "ramp"
- "capacity"
- "throughput"
- "degradation"
must_match_regex:
- "CHAOS-\\d{3,6}"
validation:
schema_check: true
keyword_match_threshold: 0.7
# ---------------------------------------------------------------------------
# CATEGORY: Safety Controls
# ---------------------------------------------------------------------------
- id: tc015_blast_radius_enforcement
description: "Verify blast radius limits are enforced"
category: safety
priority: critical
input:
scenario: |
Target: All services (attempt wide blast radius)
Inject: Attempt to affect 100% of pods
Blast radius limit: single-service
Expected: Experiment blocked or limited by safety controls
context:
environment: staging
safety_controls: true
expected_output:
must_contain:
- "blast radius"
- "safety"
- "limit"
must_not_contain:
- "100% affected"
- "all services"
must_match_regex:
- "CHAOS-\\d{3,6}|WEAK-\\d{3,6}"
validation:
schema_check: true
keyword_match_threshold: 0.7
- id: tc016_emergency_stop_validation
description: "Verify emergency stop triggers on threshold breach"
category: safety
priority: critical
input:
scenario: |
Target: payment-service
Inject: Network latency that causes error_rate > 10%
Emergency stop trigger: error_rate > 5%
Expected: Experiment stopped, rollback executed
context:
environment: staging
emergency_stop: true
expected_output:
must_contain:
- "emergency"
- "stop"
- "rollback"
- "threshold"
must_match_regex:
- "CHAOS-\\d{3,6}"
- "rollback|emergency"
validation:
schema_check: true
keyword_match_threshold: 0.8
# ---------------------------------------------------------------------------
# CATEGORY: Negative Tests
# ---------------------------------------------------------------------------
- id: tc017_resilient_system_validation
description: "Verify resilient system passes chaos experiments"
category: negative
priority: high
input:
scenario: |
Target: Well-architected microservice with:
- Circuit breakers (Hystrix)
- Retry policies (exponential backoff)
- Health checks and auto-restart
- Multi-zone deployment
- Auto-scaling enabled
Inject: Multiple chaos types (latency, pod kill, CPU stress)
Expected: System remains resilient, no critical weaknesses
context:
environment: staging
resilience_patterns: all
expected_output:
must_contain:
- "resilient"
- "passed"
- "circuit breaker"
must_not_contain:
- "critical weakness"
- "system failure"
experiment_result: ["passed"]
weakness_count:
max: 2 # Allow minor observations
validation:
schema_check: true
keyword_match_threshold: 0.6
allow_partial: true
- id: tc018_steady_state_validation
description: "Verify steady-state hypothesis is validated pre/post"
category: validation
priority: critical
input:
scenario: |
Target: inventory-service
Inject: 200ms latency injection
Steady-state hypothesis:
- error_rate < 0.1%
- latency_p99 < 300ms
- throughput > 800 req/s
Expected: Pre and post validation of steady-state
context:
environment: staging
expected_output:
must_contain:
- "steady-state"
- "hypothesis"
- "before"
- "after"
- "validated"
must_match_regex:
- "CHAOS-\\d{3,6}"
validation:
schema_check: true
keyword_match_threshold: 0.8
# =============================================================================
# SUCCESS CRITERIA
# =============================================================================
success_criteria:
# Overall pass rate (90% of tests must pass)
pass_rate: 0.9
# Critical tests must ALL pass (100%)
critical_pass_rate: 1.0
# Average reasoning quality score
avg_reasoning_quality: 0.75
# Maximum suite execution time (10 minutes)
max_execution_time_ms: 600000
# Maximum variance between model results (15%)
cross_model_variance: 0.15
# =============================================================================
# METADATA
# =============================================================================
metadata:
author: "qe-chaos-engineer"
created: "2026-02-02"
last_updated: "2026-02-02"
coverage_target: >
Chaos Engineering Coverage: Network chaos (latency, partition, packet loss),
Resource chaos (CPU, memory, disk), Infrastructure chaos (pod/node/zone failure),
Application chaos (exceptions, deadlocks), Byzantine fault tolerance (malicious
nodes, split-brain), Load testing (spike, ramp-up), Safety controls (blast
radius, emergency stop). 18 test cases with 90% pass rate requirement and
100% critical pass rate for safety-related tests.
{
"$schema": "http://json-schema.org/draft-07/schema#",
"$id": "https://agentic-qe.dev/schemas/chaos-engineering-resilience-output.json",
"title": "AQE Chaos Engineering Resilience Skill Output Schema",
"description": "Schema for chaos-engineering-resilience skill output validation. Extends the base skill-output template with chaos experiment types, fault injection structures, steady-state hypothesis, blast radius controls, and tool-specific outputs (Chaos Monkey, Litmus, Gremlin).",
"type": "object",
"required": ["skillName", "version", "timestamp", "status", "trustTier", "output"],
"properties": {
"skillName": {
"type": "string",
"const": "chaos-engineering-resilience",
"description": "Must be 'chaos-engineering-resilience'"
},
"version": {
"type": "string",
"pattern": "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9]+)?$",
"description": "Semantic version of the skill"
},
"timestamp": {
"type": "string",
"type": "string",
"description": "ISO 8601 timestamp of output generation"
},
"status": {
"type": "string",
"enum": ["success", "partial", "failed", "skipped"],
"description": "Overall execution status"
},
"trustTier": {
"type": "integer",
"const": 3,
"description": "Trust tier 3 indicates full validation with eval suite"
},
"output": {
"type": "object",
"required": ["summary", "experiments", "resilienceScore"],
"properties": {
"summary": {
"type": "string",
"minLength": 50,
"maxLength": 2000,
"description": "Human-readable summary of chaos experiment results"
},
"resilienceScore": {
"$ref": "#/$defs/resilienceScore",
"description": "Overall resilience score"
},
"experiments": {
"type": "array",
"items": {
"$ref": "#/$defs/chaosExperiment"
},
"minItems": 1,
"maxItems": 100,
"description": "List of chaos experiments executed"
},
"weaknesses": {
"type": "array",
"items": {
"$ref": "#/$defs/weakness"
},
"maxItems": 50,
"description": "Discovered system weaknesses"
},
"recommendations": {
"type": "array",
"items": {
"$ref": "#/$defs/recommendation"
},
"maxItems": 100,
"description": "Resilience improvement recommendations"
},
"metrics": {
"$ref": "#/$defs/chaosMetrics",
"description": "Chaos experiment metrics and statistics"
},
"categories": {
"$ref": "#/$defs/chaosCategoryBreakdown",
"description": "Breakdown by chaos category"
},
"artifacts": {
"type": "array",
"items": {
"$ref": "#/$defs/artifact"
},
"maxItems": 50,
"description": "Generated reports and artifacts"
},
"timeline": {
"type": "array",
"items": {
"$ref": "#/$defs/timelineEvent"
},
"description": "Experiment execution timeline"
},
"experimentConfiguration": {
"$ref": "#/$defs/experimentConfiguration",
"description": "Configuration used for the chaos experiments"
}
}
},
"metadata": {
"$ref": "#/$defs/metadata"
},
"validation": {
"$ref": "#/$defs/validationResult"
},
"learning": {
"$ref": "#/$defs/learningData"
}
},
"$defs": {
"resilienceScore": {
"type": "object",
"required": ["value", "max"],
"properties": {
"value": {
"type": "number",
"minimum": 0,
"maximum": 100,
"description": "Resilience score (0=critical weaknesses, 100=fully resilient)"
},
"max": {
"type": "number",
"const": 100,
"description": "Maximum score is always 100"
},
"grade": {
"type": "string",
"pattern": "^[A-F][+-]?$",
"description": "Letter grade: A (90-100), B (80-89), C (70-79), D (60-69), F (<60)"
},
"trend": {
"type": "string",
"enum": ["improving", "stable", "declining", "unknown"],
"description": "Trend compared to previous experiments"
},
"riskLevel": {
"type": "string",
"enum": ["critical", "high", "medium", "low", "minimal"],
"description": "Overall risk level assessment"
}
}
},
"chaosExperiment": {
"type": "object",
"required": ["id", "name", "type", "result"],
"properties": {
"id": {
"type": "string",
"pattern": "^CHAOS-\\d{3,6}$",
"description": "Unique experiment identifier (e.g., CHAOS-001)"
},
"name": {
"type": "string",
"minLength": 5,
"maxLength": 200,
"description": "Experiment name describing the fault injection"
},
"description": {
"type": "string",
"maxLength": 2000,
"description": "Detailed description of the experiment"
},
"type": {
"type": "string",
"enum": ["network", "resource", "state", "application", "infrastructure", "byzantine"],
"description": "Chaos experiment type: network=latency/partition, resource=CPU/memory/disk, state=data corruption, application=exception/deadlock, infrastructure=pod/node/zone failure, byzantine=consensus/split-brain"
},
"subType": {
"type": "string",
"enum": [
"latency",
"packet-loss",
"partition",
"dns-failure",
"bandwidth-limit",
"cpu-stress",
"memory-exhaust",
"disk-fill",
"iops-limit",
"process-kill",
"pod-terminate",
"node-drain",
"zone-failure",
"service-crash",
"exception-inject",
"deadlock",
"thread-contention",
"connection-pool-exhaust",
"malicious-node",
"message-corruption",
"split-brain",
"equivocation",
"spike-load",
"ramp-load"
],
"description": "Specific fault injection subtype"
},
"target": {
"$ref": "#/$defs/experimentTarget",
"description": "Target of the chaos experiment"
},
"faultInjection": {
"$ref": "#/$defs/faultInjection",
"description": "Fault injection parameters"
},
"steadyStateHypothesis": {
"$ref": "#/$defs/steadyStateHypothesis",
"description": "Steady-state hypothesis for the experiment"
},
"blastRadius": {
"$ref": "#/$defs/blastRadius",
"description": "Blast radius controls"
},
"rollback": {
"$ref": "#/$defs/rollbackProcedure",
"description": "Rollback procedure"
},
"result": {
"type": "string",
"enum": ["passed", "failed", "partial", "expected-fail"],
"description": "Experiment result: passed=system resilient, failed=weakness found, partial=degraded but acceptable, expected-fail=known limitation validated"
},
"observations": {
"type": "array",
"items": {
"type": "string",
"maxLength": 500
},
"maxItems": 20,
"description": "Observations during the experiment"
},
"recoveryTime": {
"type": "object",
"properties": {
"actual": {
"type": "integer",
"minimum": 0,
"description": "Actual recovery time in milliseconds"
},
"sla": {
"type": "integer",
"minimum": 0,
"description": "SLA recovery time in milliseconds"
},
"withinSla": {
"type": "boolean",
"description": "Whether recovery was within SLA"
}
},
"description": "Recovery time metrics"
},
"duration": {
"type": "integer",
"minimum": 0,
"description": "Experiment duration in milliseconds"
},
"tool": {
"type": "string",
"enum": ["chaos-monkey", "litmus", "gremlin", "chaos-mesh", "pumba", "toxiproxy", "tc", "stress-ng", "kubectl", "custom"],
"description": "Chaos tool used for the experiment"
},
"confidence": {
"type": "number",
"minimum": 0,
"maximum": 1,
"description": "Confidence in experiment results (0.0-1.0)"
}
}
},
"experimentTarget": {
"type": "object",
"required": ["type", "name"],
"properties": {
"type": {
"type": "string",
"enum": ["service", "pod", "node", "zone", "cluster", "network", "database", "cache", "queue", "external-api"],
"description": "Target type"
},
"name": {
"type": "string",
"maxLength": 200,
"description": "Target name or identifier"
},
"namespace": {
"type": "string",
"maxLength": 100,
"description": "Kubernetes namespace if applicable"
},
"labels": {
"type": "object",
"additionalProperties": { "type": "string" },
"description": "Target selection labels"
},
"percentage": {
"type": "number",
"minimum": 0,
"maximum": 100,
"description": "Percentage of targets affected"
},
"count": {
"type": "integer",
"minimum": 1,
"description": "Number of target instances"
}
}
},
"faultInjection": {
"type": "object",
"properties": {
"latency": {
"type": "object",
"properties": {
"delay": {
"type": "string",
"pattern": "^\\d+m?s$",
"description": "Latency delay (e.g., 500ms, 2s)"
},
"jitter": {
"type": "string",
"pattern": "^\\d+m?s$",
"description": "Latency jitter"
},
"correlation": {
"type": "number",
"minimum": 0,
"maximum": 100,
"description": "Correlation percentage"
}
},
"description": "Network latency injection"
},
"packetLoss": {
"type": "object",
"properties": {
"percentage": {
"type": "number",
"minimum": 0,
"maximum": 100,
"description": "Packet loss percentage"
},
"correlation": {
"type": "number",
"minimum": 0,
"maximum": 100,
"description": "Correlation percentage"
}
},
"description": "Packet loss injection"
},
"partition": {
"type": "object",
"properties": {
"direction": {
"type": "string",
"enum": ["both", "to", "from"],
"description": "Partition direction"
},
"targets": {
"type": "array",
"items": { "type": "string" },
"description": "Targets to partition from"
}
},
"description": "Network partition"
},
"resource": {
"type": "object",
"properties": {
"cpu": {
"type": "object",
"properties": {
"load": {
"type": "number",
"minimum": 0,
"maximum": 100,
"description": "CPU load percentage"
},
"workers": {
"type": "integer",
"minimum": 1,
"description": "Number of stress workers"
}
}
},
"memory": {
"type": "object",
"properties": {
"size": {
"type": "string",
"pattern": "^\\d+[KMGT]?i?[Bb]?$",
"description": "Memory to consume (e.g., 500Mi, 2Gi)"
},
"percentage": {
"type": "number",
"minimum": 0,
"maximum": 100,
"description": "Percentage of available memory"
}
}
},
"disk": {
"type": "object",
"properties": {
"size": {
"type": "string",
"pattern": "^\\d+[KMGT]?i?[Bb]?$",
"description": "Disk space to fill"
},
"path": {
"type": "string",
"description": "Target path for disk fill"
},
"iopsLimit": {
"type": "integer",
"minimum": 0,
"description": "IOPS limit to impose"
}
}
}
},
"description": "Resource stress injection"
},
"process": {
"type": "object",
"properties": {
"action": {
"type": "string",
"enum": ["kill", "pause", "resume"],
"description": "Process action"
},
"signal": {
"type": "string",
"enum": ["SIGKILL", "SIGTERM", "SIGSTOP", "SIGCONT"],
"description": "Signal to send"
},
"pattern": {
"type": "string",
"description": "Process name pattern"
}
},
"description": "Process manipulation"
},
"exception": {
"type": "object",
"properties": {
"type": {
"type": "string",
"description": "Exception type to inject"
},
"message": {
"type": "string",
"description": "Exception message"
},
"probability": {
"type": "number",
"minimum": 0,
"maximum": 1,
"description": "Probability of injection (0.0-1.0)"
}
},
"description": "Application exception injection"
},
"byzantine": {
"type": "object",
"properties": {
"attackType": {
"type": "string",
"enum": ["malicious-data", "message-corruption", "equivocation", "sybil", "leader-manipulation"],
"description": "Byzantine attack type"
},
"affectedNodes": {
"type": "integer",
"minimum": 1,
"description": "Number of Byzantine nodes"
},
"totalNodes": {
"type": "integer",
"minimum": 1,
"description": "Total nodes in cluster"
},
"toleranceThreshold": {
"type": "string",
"pattern": "^f\\s*<\\s*n/[23]$",
"description": "Byzantine fault tolerance formula (e.g., f < n/3)"
}
},
"description": "Byzantine fault injection"
},
"load": {
"type": "object",
"properties": {
"pattern": {
"type": "string",
"enum": ["spike", "ramp", "constant", "wave"],
"description": "Load pattern type"
},
"baseline": {
"type": "number",
"minimum": 0,
"description": "Baseline requests per second"
},
"peak": {
"type": "number",
"minimum": 0,
"description": "Peak requests per second"
},
"rampDuration": {
"type": "integer",
"minimum": 0,
"description": "Ramp duration in milliseconds"
}
},
"description": "Load pattern injection"
}
},
"description": "Fault injection parameters"
},
"steadyStateHypothesis": {
"type": "object",
"required": ["metrics"],
"properties": {
"description": {
"type": "string",
"maxLength": 500,
"description": "Hypothesis description"
},
"metrics": {
"type": "array",
"items": {
"$ref": "#/$defs/steadyStateMetric"
},
"minItems": 1,
"maxItems": 20,
"description": "Metrics defining steady state"
},
"before": {
"type": "object",
"properties": {
"validated": {
"type": "boolean",
"description": "Was steady state validated before experiment"
},
"timestamp": {
"type": "string",
"type": "string",
"description": "When pre-validation occurred"
}
}
},
"after": {
"type": "object",
"properties": {
"validated": {
"type": "boolean",
"description": "Was steady state validated after experiment"
},
"timestamp": {
"type": "string",
"type": "string",
"description": "When post-validation occurred"
},
"recoveryDuration": {
"type": "integer",
"minimum": 0,
"description": "Time to return to steady state in ms"
}
}
}
},
"description": "Steady-state hypothesis definition"
},
"steadyStateMetric": {
"type": "object",
"required": ["name", "operator", "threshold"],
"properties": {
"name": {
"type": "string",
"enum": ["error-rate", "latency-p50", "latency-p95", "latency-p99", "throughput", "availability", "success-rate", "cpu-usage", "memory-usage", "queue-depth", "connection-count"],
"description": "Metric name"
},
"operator": {
"type": "string",
"enum": ["<", "<=", ">", ">=", "==", "!="],
"description": "Comparison operator"
},
"threshold": {
"description": "Threshold value"
},
"unit": {
"type": "string",
"enum": ["percent", "ms", "s", "rps", "count"],
"description": "Metric unit"
},
"actual": {
"description": "Actual measured value"
},
"passed": {
"type": "boolean",
"description": "Whether metric passed the threshold"
}
},
"description": "Individual steady-state metric"
},
"blastRadius": {
"type": "object",
"properties": {
"scope": {
"type": "string",
"enum": ["single-instance", "single-service", "multi-service", "zone", "region", "cluster"],
"description": "Blast radius scope"
},
"maxImpact": {
"type": "object",
"properties": {
"pods": {
"type": "integer",
"minimum": 0,
"description": "Maximum pods affected"
},
"services": {
"type": "integer",
"minimum": 0,
"description": "Maximum services affected"
},
"percentage": {
"type": "number",
"minimum": 0,
"maximum": 100,
"description": "Maximum percentage affected"
}
}
},
"safeguards": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200
},
"description": "Safety controls in place"
},
"emergencyStop": {
"type": "boolean",
"description": "Whether emergency stop is enabled"
}
},
"description": "Blast radius controls"
},
"rollbackProcedure": {
"type": "object",
"properties": {
"automatic": {
"type": "boolean",
"description": "Whether rollback is automatic"
},
"trigger": {
"type": "string",
"maxLength": 500,
"description": "Condition that triggers rollback"
},
"steps": {
"type": "array",
"items": {
"type": "string",
"maxLength": 500
},
"maxItems": 20,
"description": "Manual rollback steps"
},
"executed": {
"type": "boolean",
"description": "Whether rollback was executed"
},
"reason": {
"type": "string",
"maxLength": 500,
"description": "Reason for rollback if executed"
}
},
"description": "Rollback procedure"
},
"weakness": {
"type": "object",
"required": ["id", "title", "severity", "category"],
"properties": {
"id": {
"type": "string",
"pattern": "^WEAK-\\d{3,6}$",
"description": "Unique weakness identifier"
},
"title": {
"type": "string",
"minLength": 10,
"maxLength": 200,
"description": "Weakness title"
},
"description": {
"type": "string",
"maxLength": 2000,
"description": "Detailed description"
},
"severity": {
"type": "string",
"enum": ["critical", "high", "medium", "low"],
"description": "Weakness severity"
},
"category": {
"type": "string",
"enum": ["availability", "latency", "data-integrity", "security", "scalability", "recovery", "observability"],
"description": "Weakness category"
},
"discoveredBy": {
"type": "array",
"items": {
"type": "string",
"pattern": "^CHAOS-\\d{3,6}$"
},
"description": "Experiments that discovered this weakness"
},
"impact": {
"type": "string",
"maxLength": 1000,
"description": "Business impact of this weakness"
},
"remediation": {
"type": "string",
"maxLength": 2000,
"description": "Suggested remediation"
},
"runbook": {
"type": "string",
"maxLength": 5000,
"description": "Generated runbook for handling this weakness"
}
},
"description": "Discovered weakness"
},
"recommendation": {
"type": "object",
"required": ["id", "title", "priority"],
"properties": {
"id": {
"type": "string",
"pattern": "^REC-\\d{3,6}$",
"description": "Unique recommendation identifier"
},
"title": {
"type": "string",
"minLength": 10,
"maxLength": 200,
"description": "Recommendation title"
},
"description": {
"type": "string",
"maxLength": 2000,
"description": "Detailed recommendation"
},
"priority": {
"type": "string",
"enum": ["critical", "high", "medium", "low"],
"description": "Implementation priority"
},
"effort": {
"type": "string",
"enum": ["trivial", "low", "medium", "high", "major"],
"description": "Estimated effort"
},
"impact": {
"type": "integer",
"minimum": 1,
"maximum": 10,
"description": "Expected resilience impact (1-10)"
},
"category": {
"type": "string",
"enum": ["circuit-breaker", "retry-policy", "timeout-config", "resource-limit", "auto-scaling", "redundancy", "monitoring", "recovery-automation"],
"description": "Recommendation category"
},
"relatedWeaknesses": {
"type": "array",
"items": {
"type": "string",
"pattern": "^WEAK-\\d{3,6}$"
},
"description": "IDs of related weaknesses"
},
"codeExample": {
"type": "string",
"maxLength": 5000,
"description": "Code example for implementation"
},
"resources": {
"type": "array",
"items": {
"type": "object",
"required": ["title", "url"],
"properties": {
"title": { "type": "string" },
"url": { "type": "string" }
}
},
"maxItems": 10,
"description": "External resources"
}
},
"description": "Resilience recommendation"
},
"chaosCategoryBreakdown": {
"type": "object",
"description": "Chaos experiment category breakdown",
"properties": {
"network": {
"$ref": "#/$defs/chaosCategoryScore",
"description": "Network chaos (latency, partition, packet loss)"
},
"resource": {
"$ref": "#/$defs/chaosCategoryScore",
"description": "Resource chaos (CPU, memory, disk)"
},
"state": {
"$ref": "#/$defs/chaosCategoryScore",
"description": "State chaos (data corruption, inconsistency)"
},
"application": {
"$ref": "#/$defs/chaosCategoryScore",
"description": "Application chaos (exceptions, deadlocks)"
},
"infrastructure": {
"$ref": "#/$defs/chaosCategoryScore",
"description": "Infrastructure chaos (pod/node/zone failure)"
},
"byzantine": {
"$ref": "#/$defs/chaosCategoryScore",
"description": "Byzantine faults (consensus, split-brain)"
}
},
"additionalProperties": false
},
"chaosCategoryScore": {
"type": "object",
"required": ["tested", "score"],
"properties": {
"tested": {
"type": "boolean",
"description": "Whether this category was tested"
},
"score": {
"type": "number",
"minimum": 0,
"maximum": 100,
"description": "Category resilience score (100 = fully resilient)"
},
"grade": {
"type": "string",
"pattern": "^[A-F][+-]?$",
"description": "Letter grade"
},
"experimentCount": {
"type": "integer",
"minimum": 0,
"description": "Number of experiments in this category"
},
"passedCount": {
"type": "integer",
"minimum": 0,
"description": "Number of passed experiments"
},
"failedCount": {
"type": "integer",
"minimum": 0,
"description": "Number of failed experiments"
},
"weaknessCount": {
"type": "integer",
"minimum": 0,
"description": "Weaknesses found in this category"
},
"status": {
"type": "string",
"enum": ["pass", "fail", "warn", "skip"],
"description": "Category status"
}
}
},
"chaosMetrics": {
"type": "object",
"properties": {
"totalExperiments": {
"type": "integer",
"minimum": 0,
"description": "Total chaos experiments executed"
},
"passedExperiments": {
"type": "integer",
"minimum": 0,
"description": "Experiments that passed"
},
"failedExperiments": {
"type": "integer",
"minimum": 0,
"description": "Experiments that failed (weaknesses found)"
},
"skippedExperiments": {
"type": "integer",
"minimum": 0,
"description": "Experiments skipped"
},
"weaknessesFound": {
"type": "integer",
"minimum": 0,
"description": "Total weaknesses discovered"
},
"criticalWeaknesses": {
"type": "integer",
"minimum": 0,
"description": "Critical severity weaknesses"
},
"servicesAffected": {
"type": "integer",
"minimum": 0,
"description": "Number of services affected"
},
"averageRecoveryTime": {
"type": "integer",
"minimum": 0,
"description": "Average recovery time in ms"
},
"maxRecoveryTime": {
"type": "integer",
"minimum": 0,
"description": "Maximum recovery time in ms"
},
"rollbacksTriggered": {
"type": "integer",
"minimum": 0,
"description": "Number of rollbacks triggered"
},
"safetyViolations": {
"type": "integer",
"minimum": 0,
"description": "Safety limit violations"
},
"totalDurationMs": {
"type": "integer",
"minimum": 0,
"description": "Total experiment duration"
},
"coverage": {
"type": "object",
"properties": {
"network": { "type": "boolean" },
"resource": { "type": "boolean" },
"state": { "type": "boolean" },
"application": { "type": "boolean" },
"infrastructure": { "type": "boolean" },
"byzantine": { "type": "boolean" }
},
"description": "Chaos category coverage"
}
}
},
"experimentConfiguration": {
"type": "object",
"properties": {
"target": {
"type": "string",
"description": "Primary target system or service"
},
"environment": {
"type": "string",
"enum": ["development", "staging", "production", "ci"],
"description": "Target environment"
},
"chaosTypes": {
"type": "array",
"items": {
"type": "string",
"enum": ["network", "resource", "state", "application", "infrastructure", "byzantine"]
},
"description": "Types of chaos tested"
},
"tools": {
"type": "array",
"items": {
"type": "string",
"enum": ["chaos-monkey", "litmus", "gremlin", "chaos-mesh", "pumba", "toxiproxy", "tc", "stress-ng", "kubectl", "custom"]
},
"description": "Chaos tools used"
},
"blastRadiusLimit": {
"type": "string",
"enum": ["single-instance", "single-service", "multi-service", "zone", "region", "cluster"],
"description": "Maximum blast radius allowed"
},
"duration": {
"type": "integer",
"minimum": 0,
"description": "Total experiment window in minutes"
},
"progressionStrategy": {
"type": "string",
"enum": ["gradual", "immediate", "adaptive"],
"description": "How experiments progress in intensity"
}
}
},
"artifact": {
"type": "object",
"required": ["type", "path"],
"properties": {
"type": {
"type": "string",
"enum": ["report", "runbook", "data", "log", "config", "diagram"],
"description": "Artifact type"
},
"path": {
"type": "string",
"maxLength": 500,
"description": "Path to artifact"
},
"format": {
"type": "string",
"enum": ["json", "yaml", "html", "md", "txt", "png", "svg"],
"description": "Artifact format"
},
"description": {
"type": "string",
"maxLength": 500,
"description": "Artifact description"
},
"sizeBytes": {
"type": "integer",
"minimum": 0,
"description": "File size"
}
}
},
"timelineEvent": {
"type": "object",
"required": ["timestamp", "event"],
"properties": {
"timestamp": {
"type": "string",
"type": "string",
"description": "Event timestamp"
},
"event": {
"type": "string",
"maxLength": 200,
"description": "Event description"
},
"type": {
"type": "string",
"enum": ["start", "checkpoint", "inject", "observe", "recover", "rollback", "complete", "warning", "error"],
"description": "Event type"
},
"experimentId": {
"type": "string",
"pattern": "^CHAOS-\\d{3,6}$",
"description": "Related experiment ID"
},
"durationMs": {
"type": "integer",
"minimum": 0,
"description": "Duration since previous event"
}
}
},
"metadata": {
"type": "object",
"properties": {
"executionTimeMs": {
"type": "integer",
"minimum": 0,
"maximum": 3600000,
"description": "Total execution time"
},
"toolsUsed": {
"type": "array",
"items": {
"type": "string",
"enum": ["chaos-monkey", "litmus", "gremlin", "chaos-mesh", "pumba", "toxiproxy", "tc", "stress-ng", "kubectl", "custom"]
},
"uniqueItems": true,
"description": "Chaos tools used"
},
"agentId": {
"type": "string",
"pattern": "^qe-[a-z][a-z0-9-]*$",
"description": "Agent ID (e.g., qe-chaos-engineer)"
},
"modelUsed": {
"type": "string",
"description": "LLM model used"
},
"inputHash": {
"type": "string",
"pattern": "^[a-f0-9]{64}$",
"description": "SHA-256 hash of input"
},
"targetPath": {
"type": "string",
"description": "Target system path"
},
"environment": {
"type": "string",
"enum": ["development", "staging", "production", "ci"],
"description": "Execution environment"
},
"retryCount": {
"type": "integer",
"minimum": 0,
"maximum": 10,
"description": "Number of retries"
}
}
},
"validationResult": {
"type": "object",
"properties": {
"schemaValid": {
"type": "boolean",
"description": "Passes schema validation"
},
"contentValid": {
"type": "boolean",
"description": "Passes content validation"
},
"confidence": {
"type": "number",
"minimum": 0,
"maximum": 1,
"description": "Confidence score"
},
"warnings": {
"type": "array",
"items": {
"type": "string",
"maxLength": 500
},
"maxItems": 20
},
"errors": {
"type": "array",
"items": {
"type": "string",
"maxLength": 500
},
"maxItems": 20
},
"validatorVersion": {
"type": "string",
"pattern": "^\\d+\\.\\d+\\.\\d+$"
}
}
},
"learningData": {
"type": "object",
"properties": {
"patternsDetected": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200
},
"maxItems": 20,
"description": "Chaos patterns detected"
},
"reward": {
"type": "number",
"minimum": 0,
"maximum": 1,
"description": "Reward signal (0.0-1.0)"
},
"feedbackLoop": {
"type": "object",
"properties": {
"previousRunId": {
"type": "string",
"type": "string"
},
"improvement": {
"type": "number",
"minimum": -1,
"maximum": 1
}
}
},
"newResiliencePatterns": {
"type": "array",
"items": {
"type": "object",
"properties": {
"pattern": { "type": "string" },
"category": { "type": "string" },
"confidence": { "type": "number" }
}
},
"description": "New resilience patterns learned"
}
}
}
}
}
{
"skillName": "chaos-engineering-resilience",
"skillVersion": "1.0.0",
"requiredTools": [
"jq"
],
"optionalTools": [
"chaos",
"litmus",
"gremlin",
"kubectl",
"node",
"ajv",
"jsonschema",
"python3"
],
"schemaPath": "schemas/output.json",
"requiredFields": [
"skillName",
"status",
"output",
"output.summary",
"output.experiments",
"output.resilienceScore"
],
"requiredNonEmptyFields": [
"output.summary"
],
"mustContainTerms": [
"chaos",
"experiment",
"resilience"
],
"mustNotContainTerms": [
"TODO",
"placeholder",
"FIXME"
],
"enumValidations": {
".status": [
"success",
"partial",
"failed",
"skipped"
]
}
}
Related skills
Setup Matt Pocock SkillsScaffold the per-repo configuration that Matt Pocock’s engineering agent skills rely on so they understand the issue tracker, triage labels, and domain documentation la495k196k
Lark AppsConnect Claude, Cursor or custom agents directly to Lark (Feishu) for messaging, document automation, approval workflows and enterprise data access.402k
CavemanSlash token usage by roughly 75% while keeping every technical detail intact when working with Claude Code, Cursor or similar agents.391k94.7k
Lark Skill MakerQuickly turn any Lark/Feishu OpenAPI call or multi-step workflow into a reusable agent skill with its own SKILL.md.386k16k
Running Claude Code Via Litellm CopilotRun Claude Code at a fraction of the cost by routing requests through LiteLLM to the GitHub Copilot Chat API.270k72
Codex PetGenerate a complete Codex Pet spritesheet and metadata from one reference image without needing an OpenAI key or Codex Pro.246k10FAQ
What does chaos-engineering-resilience do?
chaos-engineering-resilience is a Claude Code skill for ai & agent building.
When should I use chaos-engineering-resilience?
When you need to helps with ai & agent building tasks., or when chaos-engineering-resilience is a claude code skill for ai & agent building.
What are the main capabilities?
chaos-engineering-resilience; AI & Agent Building; AI-coding skill.
AI & Agent Buildingagents