Risk Based Testing

Name: Risk Based Testing
Author: proffesor-for-testing

proffesor-for-testing/agentic-qe

104 installs
433 repo stars
Updated August 4, 2026
proffesor-for-testing/agentic-qe

risk-based-testing is a Claude Code skill for testing & qa.

About

risk-based-testing is a Claude Code skill for testing & qa. It helps solo builders move faster with AI-assisted development.

risk-based-testing
Testing & QA
AI-coding skill

Risk Based Testing by the numbers

104 all-time installs (skills.sh)
+3 installs in the week ending Aug 4, 2026 (Skillselion tracking)
Ranked #985 of 2,153 Testing & QA 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 risk-based-testing

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/proffesor-for-testing/agentic-qe/risk-based-testing.svg)](https://skillselion.com/skills/proffesor-for-testing/agentic-qe/risk-based-testing)

Installs	104
repo stars	★ 433
Last updated	August 4, 2026
Repository	proffesor-for-testing/agentic-qe ↗

How do I helps with testing & qa tasks.?

Helps with testing & qa tasks.

Who is it for?

Best when you're working on testing & qa and need structured help with risk based testing.

Skip if: Teams with no testing & qa needs, or anyone wanting a generic chat assistant without this specific workflow.

When should I use this skill?

When you need to helps with testing & qa tasks., or when risk-based-testing is a claude code skill for testing & qa.

What you get

Structured output aligned to risk-based-testing: risk-based-testing, Testing & QA.

Files

SKILL.mdMarkdownGitHub ↗

Risk-Based Testing

<default_to_action> When planning tests or allocating testing resources: 1. IDENTIFY risks per component (use 1-5 scale for probability and impact) 2. PRIORITIZE: Critical (20+) → High (12-19) → Medium (6-11) → Low (1-5) 3. ALLOCATE effort: 60% critical, 25% high, 10% medium, 5% low 4. REASSESS continuously: Production incidents raise risk; stable code lowers it </default_to_action>

Quick Reference Card

When to Use

Planning sprint/release test strategy
Deciding what to automate first
Allocating limited testing time
Justifying test coverage decisions

Effort Allocation by Risk Score

Score	Priority	Effort	Action
20-25	Critical	60%	Comprehensive testing, multiple techniques
12-19	High	25%	Thorough testing, automation priority
6-11	Medium	10%	Standard testing, basic automation
1-5	Low	5%	Smoke test, exploratory only

---

Apply Test Depth by Risk

await Task("Risk-Based Test Generation", {
  critical: {
    features: ['checkout', 'payment'],
    depth: 'comprehensive',
    techniques: ['unit', 'integration', 'e2e', 'performance', 'security']
  },
  high: {
    features: ['auth', 'user-profile'],
    depth: 'thorough',
    techniques: ['unit', 'integration', 'e2e']
  },
  medium: {
    features: ['search', 'notifications'],
    depth: 'standard',
    techniques: ['unit', 'integration']
  },
  low: {
    features: ['admin-panel', 'settings'],
    depth: 'smoke',
    techniques: ['smoke-tests']
  }
}, "qe-test-generator");

Step 3: Reassess Dynamically

// Production incident increases risk
await Task("Update Risk Score", {
  feature: 'search',
  event: 'production-incident',
  previousRisk: 9,
  newProbability: 5,  // Increased due to incident
  newRisk: 15         // Now HIGH priority
}, "qe-regression-risk-analyzer");

---

ML-Enhanced Risk Analysis

// Agent predicts risk using historical data
const riskAnalysis = await Task("ML Risk Analysis", {
  codeChanges: changedFiles,
  historicalBugs: bugDatabase,
  prediction: {
    model: 'gradient-boosting',
    factors: ['complexity', 'change-frequency', 'author-experience', 'file-age']
  }
}, "qe-regression-risk-analyzer");

// Output: 95% accuracy risk prediction per file

---

Agent Coordination Hints

Memory Namespace

aqe/risk-based/
├── risk-scores/*        - Current risk assessments
├── historical-bugs/*    - Bug patterns by area
├── production-data/*    - Incident data for risk
└── coverage-map/*       - Test depth by risk level

Fleet Coordination

const riskFleet = await FleetManager.coordinate({
  strategy: 'risk-based-testing',
  agents: [
    'qe-regression-risk-analyzer',  // Risk scoring
    'qe-test-generator',            // Risk-appropriate tests
    'qe-production-intelligence',   // Production feedback
    'qe-quality-gate'               // Risk-based gates
  ],
  topology: 'sequential'
});

---

Integration with CI/CD

# Risk-based test selection in pipeline
- name: Risk Analysis
  run: aqe risk-analyze --changes ${{ github.event.pull_request.files }}

- name: Run Critical Tests
  if: risk.critical > 0
  run: npm run test:critical

- name: Run High Tests
  if: risk.high > 0
  run: npm run test:high

- name: Skip Low Risk
  if: risk.low_only
  run: npm run test:smoke

---

Related Skills

agentic-quality-engineering - Risk-aware agents
context-driven-testing - Context affects risk
regression-testing - Risk-based regression selection
shift-right-testing - Production informs risk

---

Remember

With Agents: Agents calculate risk using ML on historical data, select risk-appropriate tests, and adjust scores from production feedback. Use agents to maintain dynamic risk profiles at scale.

skill: risk-based-testing
version: 1.0.0
description: >
  Evaluation suite for risk-based testing strategy.
  Tests risk scoring, test prioritization, and coverage optimization.

models_to_test:
  - claude-sonnet-4-6    # Primary (high accuracy expected)
  - claude-haiku-4-5     # Fast model (minimum quality floor)

mcp_integration:
  enabled: true
  namespace: skill-validation
  query_patterns: true
  track_outcomes: true
  store_patterns: true
  target_agents:
    - qe-learning-coordinator

learning:
  store_success_patterns: true
  pattern_ttl_days: 90

result_format:
  json_output: true
  include_timing: true
  include_token_usage: true

setup:
  required_tools:
    - jq

test_cases:

  - id: tc001_risk_scoring
    description: "Score and prioritize risks"
    category: risk_assessment
    priority: critical

    input:
      components:
        - { name: "payment_processor", criticality: "critical", change_frequency: "low" }
        - { name: "notification_service", criticality: "low", change_frequency: "high" }

    expected_output:
      must_contain:
        - "risk"
        - "score"
        - "priority"

    validation:
      schema_check: true
      keyword_match_threshold: 0.8

  - id: tc002_test_prioritization
    description: "Prioritize tests based on risk"
    category: prioritization
    priority: high

    input:
      available_tests: 500
      time_budget_hours: 2
      risk_scores: { "critical": 10, "high": 5, "medium": 2 }

    expected_output:
      must_contain:
        - "prioritize"
        - "test"
        - "critical"

    validation:
      schema_check: true

  - id: tc003_coverage_optimization
    description: "Optimize test coverage for risk mitigation"
    category: coverage
    priority: high

    input:
      high_risk_areas: ["authentication", "payment", "data_export"]
      current_coverage_percent: 65

    expected_output:
      must_contain:
        - "coverage"
        - "optimize"

    validation:
      schema_check: true

  - id: tc004_regression_risk
    description: "Identify regression risk from changes"
    category: regression
    priority: medium

    input:
      changed_files:
        - "auth/login.js"
        - "auth/session.js"
      dependent_modules: ["dashboard", "profile", "settings"]

    expected_output:
      must_contain:
        - "regression"
        - "risk"

    validation:
      schema_check: true

  - id: tc005_risk_mitigation_strategy
    description: "Generate risk mitigation testing strategy"
    category: strategy
    priority: medium

    input:
      identified_risks:
        - "SQL injection in search"
        - "XSS in user input"
        - "CSRF on form submission"

    expected_output:
      must_contain:
        - "strategy"
        - "mitigation"

    validation:
      schema_check: true
      allow_partial: true

success_criteria:
  pass_rate: 0.9
  critical_pass_rate: 1.0
  avg_reasoning_quality: 0.75
  max_execution_time_ms: 300000

metadata:
  author: "qe-risk-assessor"
  created: "2026-02-02"
  coverage_target: >
    Risk-based testing with 5 test cases covering risk scoring,
    test prioritization, coverage optimization, regression risk, and mitigation strategies.

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://agentic-qe.dev/schemas/risk-based-testing-output.json",
  "title": "AQE Risk-Based Testing Skill Output Schema",
  "description": "Schema for risk-based-testing skill output validation. Extends the base skill-output template with risk matrix, prioritization, and test allocation.",
  "type": "object",
  "required": ["skillName", "version", "timestamp", "status", "trustTier", "output"],
  "properties": {
    "skillName": {
      "type": "string",
      "const": "risk-based-testing",
      "description": "Must be 'risk-based-testing'"
    },
    "version": {
      "type": "string",
      "pattern": "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9]+)?$"
    },
    "timestamp": {
      "type": "string",
      "format": "date-time"
    },
    "status": {
      "type": "string",
      "enum": ["success", "partial", "failed", "skipped"]
    },
    "trustTier": {
      "type": "integer",
      "const": 3
    },
    "output": {
      "type": "object",
      "required": ["summary", "riskMatrix", "prioritization", "findings", "recommendations"],
      "properties": {
        "summary": {
          "type": "string",
          "minLength": 50,
          "maxLength": 2000,
          "description": "Human-readable summary of risk assessment"
        },
        "score": {
          "$ref": "#/$defs/riskScore"
        },
        "riskMatrix": {
          "$ref": "#/$defs/riskMatrix",
          "description": "Complete risk assessment matrix"
        },
        "prioritization": {
          "$ref": "#/$defs/prioritization",
          "description": "Test prioritization based on risk"
        },
        "testAllocation": {
          "$ref": "#/$defs/testAllocation",
          "description": "Recommended test effort allocation"
        },
        "findings": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/riskFinding"
          },
          "maxItems": 200
        },
        "recommendations": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/riskRecommendation"
          },
          "maxItems": 50
        },
        "mlAnalysis": {
          "$ref": "#/$defs/mlRiskAnalysis",
          "description": "ML-enhanced risk prediction"
        },
        "metrics": {
          "$ref": "#/$defs/riskMetrics"
        },
        "artifacts": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/artifact"
          },
          "maxItems": 50
        }
      }
    },
    "metadata": {
      "$ref": "#/$defs/metadata"
    },
    "validation": {
      "$ref": "#/$defs/validationResult"
    },
    "learning": {
      "$ref": "#/$defs/learningData"
    }
  },
  "$defs": {
    "riskScore": {
      "type": "object",
      "required": ["value", "max"],
      "properties": {
        "value": {
          "type": "number",
          "minimum": 0,
          "maximum": 100,
          "description": "Overall risk mitigation score (100=all risks addressed)"
        },
        "max": {
          "type": "number",
          "const": 100
        },
        "grade": {
          "type": "string",
          "pattern": "^[A-F][+-]?$"
        },
        "riskPosture": {
          "type": "string",
          "enum": ["critical", "high", "moderate", "low", "minimal"],
          "description": "Overall risk posture"
        }
      }
    },
    "riskMatrix": {
      "type": "object",
      "required": ["items"],
      "properties": {
        "items": {
          "type": "array",
          "items": {
            "type": "object",
            "required": ["id", "feature", "probability", "impact", "riskScore", "priority"],
            "properties": {
              "id": {
                "type": "string",
                "pattern": "^RISK-\\d{3,6}$"
              },
              "feature": {
                "type": "string",
                "description": "Feature or component name"
              },
              "description": {
                "type": "string",
                "description": "Risk description"
              },
              "probability": {
                "type": "integer",
                "minimum": 1,
                "maximum": 5,
                "description": "Probability of defect (1-5)"
              },
              "impact": {
                "type": "integer",
                "minimum": 1,
                "maximum": 5,
                "description": "Business impact if defect occurs (1-5)"
              },
              "riskScore": {
                "type": "integer",
                "minimum": 1,
                "maximum": 25,
                "description": "Calculated risk score (probability x impact)"
              },
              "priority": {
                "type": "string",
                "enum": ["critical", "high", "medium", "low"],
                "description": "Testing priority based on risk"
              },
              "probabilityFactors": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "factor": {
                      "type": "string",
                      "enum": ["complexity", "change-rate", "developer-experience", "technical-debt", "dependencies", "age"]
                    },
                    "score": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 5
                    },
                    "evidence": {
                      "type": "string"
                    }
                  }
                },
                "description": "Factors contributing to probability"
              },
              "impactFactors": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "factor": {
                      "type": "string",
                      "enum": ["users-affected", "revenue", "safety", "reputation", "regulatory", "data-loss"]
                    },
                    "score": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 5
                    },
                    "evidence": {
                      "type": "string"
                    }
                  }
                },
                "description": "Factors contributing to impact"
              },
              "mitigations": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Risk mitigation strategies"
              },
              "testingStrategy": {
                "type": "string",
                "enum": ["comprehensive", "thorough", "standard", "smoke"],
                "description": "Recommended testing depth"
              }
            }
          }
        },
        "criticalCount": {
          "type": "integer",
          "description": "Number of critical-priority risks"
        },
        "highCount": {
          "type": "integer",
          "description": "Number of high-priority risks"
        },
        "mediumCount": {
          "type": "integer",
          "description": "Number of medium-priority risks"
        },
        "lowCount": {
          "type": "integer",
          "description": "Number of low-priority risks"
        }
      }
    },
    "prioritization": {
      "type": "object",
      "properties": {
        "critical": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Features requiring comprehensive testing"
        },
        "high": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Features requiring thorough testing"
        },
        "medium": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Features requiring standard testing"
        },
        "low": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Features requiring smoke testing"
        },
        "testOrder": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "order": { "type": "integer" },
              "feature": { "type": "string" },
              "rationale": { "type": "string" }
            }
          },
          "description": "Recommended test execution order"
        }
      }
    },
    "testAllocation": {
      "type": "object",
      "properties": {
        "totalEffort": {
          "type": "string",
          "description": "Total estimated testing effort"
        },
        "criticalAllocation": {
          "type": "object",
          "properties": {
            "percentage": { "type": "number" },
            "techniques": { "type": "array", "items": { "type": "string" } },
            "estimatedTime": { "type": "string" }
          }
        },
        "highAllocation": {
          "type": "object",
          "properties": {
            "percentage": { "type": "number" },
            "techniques": { "type": "array", "items": { "type": "string" } },
            "estimatedTime": { "type": "string" }
          }
        },
        "mediumAllocation": {
          "type": "object",
          "properties": {
            "percentage": { "type": "number" },
            "techniques": { "type": "array", "items": { "type": "string" } },
            "estimatedTime": { "type": "string" }
          }
        },
        "lowAllocation": {
          "type": "object",
          "properties": {
            "percentage": { "type": "number" },
            "techniques": { "type": "array", "items": { "type": "string" } },
            "estimatedTime": { "type": "string" }
          }
        },
        "recommendedDistribution": {
          "type": "object",
          "properties": {
            "critical": { "type": "number", "default": 60 },
            "high": { "type": "number", "default": 25 },
            "medium": { "type": "number", "default": 10 },
            "low": { "type": "number", "default": 5 }
          },
          "description": "Recommended effort distribution percentages"
        }
      }
    },
    "riskFinding": {
      "type": "object",
      "required": ["id", "title", "type", "severity"],
      "properties": {
        "id": {
          "type": "string",
          "pattern": "^RBT-\\d{3,6}$"
        },
        "title": {
          "type": "string",
          "minLength": 10,
          "maxLength": 200
        },
        "description": { "type": "string" },
        "type": {
          "type": "string",
          "enum": ["unmitigated-risk", "coverage-gap", "incorrect-priority", "missing-assessment", "outdated-risk", "opportunity"]
        },
        "severity": {
          "type": "string",
          "enum": ["critical", "high", "medium", "low", "info"]
        },
        "affectedRisk": {
          "type": "string",
          "description": "Which risk item this finding affects"
        }
      }
    },
    "riskRecommendation": {
      "type": "object",
      "required": ["id", "title", "priority", "riskReduction"],
      "properties": {
        "id": {
          "type": "string",
          "pattern": "^REC-\\d{3,6}$"
        },
        "title": { "type": "string" },
        "description": { "type": "string" },
        "priority": {
          "type": "string",
          "enum": ["critical", "high", "medium", "low"]
        },
        "riskReduction": {
          "type": "number",
          "minimum": 0,
          "maximum": 100,
          "description": "Expected percentage reduction in risk"
        },
        "effort": {
          "type": "string",
          "enum": ["trivial", "low", "medium", "high", "major"]
        },
        "affectedRisks": {
          "type": "array",
          "items": { "type": "string" },
          "description": "Risk IDs this addresses"
        }
      }
    },
    "mlRiskAnalysis": {
      "type": "object",
      "properties": {
        "model": {
          "type": "string",
          "description": "ML model used"
        },
        "accuracy": {
          "type": "number",
          "minimum": 0,
          "maximum": 100,
          "description": "Model accuracy percentage"
        },
        "predictions": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "feature": { "type": "string" },
              "predictedRisk": { "type": "number" },
              "confidence": { "type": "number" },
              "factors": { "type": "array", "items": { "type": "string" } }
            }
          }
        },
        "historicalCorrelation": {
          "type": "number",
          "description": "How well predictions match historical bugs"
        }
      }
    },
    "riskMetrics": {
      "type": "object",
      "properties": {
        "totalRisks": { "type": "integer" },
        "averageRiskScore": { "type": "number" },
        "maxRiskScore": { "type": "integer" },
        "coverageByPriority": {
          "type": "object",
          "properties": {
            "critical": { "type": "number" },
            "high": { "type": "number" },
            "medium": { "type": "number" },
            "low": { "type": "number" }
          }
        },
        "riskReductionTarget": { "type": "number" }
      }
    },
    "artifact": {
      "type": "object",
      "required": ["type", "path"],
      "properties": {
        "type": { "type": "string" },
        "path": { "type": "string" },
        "format": { "type": "string" },
        "description": { "type": "string" }
      }
    },
    "metadata": {
      "type": "object",
      "properties": {
        "executionTimeMs": { "type": "integer" },
        "agentId": { "type": "string" },
        "modelUsed": { "type": "string" },
        "environment": { "type": "string" }
      }
    },
    "validationResult": {
      "type": "object",
      "properties": {
        "schemaValid": { "type": "boolean" },
        "contentValid": { "type": "boolean" },
        "confidence": { "type": "number" }
      }
    },
    "learningData": {
      "type": "object",
      "properties": {
        "patternsDetected": { "type": "array", "items": { "type": "string" } },
        "reward": { "type": "number" }
      }
    }
  }
}

{
  "skillName": "risk-based-testing",
  "skillVersion": "1.0.0",
  "requiredTools": [
    "jq"
  ],
  "optionalTools": [],
  "schemaPath": "schemas/output.json",
  "requiredFields": [
    "skillName",
    "status",
    "output"
  ],
  "requiredNonEmptyFields": [],
  "mustContainTerms": [],
  "mustNotContainTerms": [],
  "enumValidations": {
    ".status": [
      "success",
      "partial",
      "failed",
      "skipped"
    ]
  }
}