Imported from majiayu000/claude-skill-registry-data (quality/risk-profile-adolfoaranaes12-bmad-enhanced/SKILL.md). Install upstream with npx skills add majiayu000/claude-skill-registry-data --skill risk-profile-adolfoaranaes12-bmad-enhanced. Copyright stays with the author.

name: risk-profile description: Assess implementation risks using Probability × Impact (P×I) scoring methodology across 6 categories (Technical, Security, Performance, Data, Business, Operational). Scores risks (P×I: 1-9), develops mitigations for high-risk items (score ≥6), and prioritizes test scenarios (P0/P1/P2). Use before implementation or during quality review to identify and mitigate potential issues. version: 2.0 category: Quality acceptance: risks_identified: "All potential risks identified across 6 categories (Technical, Security, Performance, Data, Business, Operational) with 10-20 risks typical" risks_scored: "All risks scored using P×I methodology (Probability 1-3, Impact 1-3, Score 1-9) with reasoning documented" mitigations_developed: "Mitigation strategies developed for all high-risk items (score ≥6) with concrete actions and effort estimates" tests_prioritized: "Test scenarios prioritized by risk level (P0 for score ≥7, P1 for score 5-6, P2 for score 3-4)" inputs: task_id: required: true description: "Task identifier for risk assessment (e.g., 'task-006')" task_file: required: true description: "Path to task specification file" assessment_mode: required: false description: "Assessment timing (pre-implementation/during-development/post-implementation, auto-detected from task status)" outputs: total_risks: description: "Total number of risks identified" critical_risks_count: description: "Number of critical risks (score ≥7)" high_risks_count: description: "Number of high risks (score 6)" risk_profile_path: description: "Path to generated risk profile report" quality_gate_impact: description: "Predicted quality gate status (PASS/CONCERNS/FAIL)" p0_tests_count: description: "Number of P0 (critical) tests required" telemetry: emit: "skill.risk-profile.completed" track: - task_id - assessment_mode - total_risks - critical_risks_count - high_risks_count - medium_risks_count - low_risks_count - highest_risk_score - quality_gate_impact - p0_tests_count - p1_tests_count - assessment_duration_ms

Risk Profile Assessment

The risk-profile skill assesses implementation risks before or during development using the Probability × Impact (P×I) scoring methodology. This skill identifies potential issues early, enables risk-based test prioritization, and informs quality gate decisions. By systematically evaluating risks across 6 categories (Technical, Security, Performance, Data, Business, Operational), the skill produces a risk matrix with mitigation strategies and test priorities.

The P×I methodology scores each risk on a 1-9 scale (Probability 1-3 × Impact 1-3), enabling objective risk measurement and comparison. Critical risks (score ≥7) require immediate mitigation, high risks (score 6) require testing validation, medium risks (3-5) need monitoring, and low risks (1-2) require standard precautions. This scoring directly integrates with the quality gate: risks ≥9 trigger FAIL, risks ≥6 trigger CONCERNS, providing clear quality thresholds.

The skill is most powerful when used pre-implementation (after task spec creation, before coding begins), allowing developers to design mitigations into the implementation rather than retrofitting fixes later. The risk profile generates test priorities (P0/P1/P2) based on risk scores, ensuring the highest-risk areas receive comprehensive testing. The output integrates with test-design and quality-gate skills for comprehensive quality assessment.

When to Use This Skill

This skill should be used when:

• Risks need to be assessed before starting implementation (recommended timing)
• Potential issues need identification early in development cycle
• Test scenarios need to be prioritized by risk level
• Quality gate decisions need to be informed with risk data
• Mitigation strategies need to be developed for high-risk areas

This skill is particularly valuable:

• After task spec creation, before implementation begins (optimal timing)
• For complex or high-risk features (external APIs, security, data migrations)
• When planning comprehensive test strategy
• During quality review to validate risk mitigation

This skill should NOT be used when:

• Task is simple CRUD with no external dependencies (low value)
• Bug fix has clear root cause and straightforward solution
• Well-established patterns with no unknowns (minimal risk)

Prerequisites

Before running risk-profile, ensure you have:

1. Task specification file with clear objective, acceptance criteria, and context
2. Project configuration (.claude/config.yaml) with risk threshold setting
3. Understanding of implementation approach (what will be built, how, with what technologies)

Optimal timing:

• Pre-implementation: Task status "Draft" or "Approved" (best time for risk assessment)
• During development: Task status "InProgress" (validate mitigation effectiveness)
• Post-implementation: Task status "Review" (inform quality gate)

Sequential Risk Assessment Process

This skill executes through 7 sequential steps (Step 0-6). Each step must complete successfully before proceeding. The process systematically identifies risks, scores them with P×I methodology, develops mitigations, prioritizes tests, and generates a comprehensive risk profile report.

Step 0: Load Configuration and Task Context

Purpose: Load project configuration and task specification to understand what will be implemented and establish the risk assessment context.

Actions:

1. Load project configuration from .claude/config.yaml:
   • Extract quality.riskScoreThreshold (default: 6)
   • Extract quality.qualityLocation (default: .claude/quality)
2. Read task specification file:
   • Load objective and acceptance criteria
   • Load context (data models, APIs, components, constraints)
   • Load task breakdown (implementation steps)
3. Determine assessment mode from task status:
   • Pre-implementation: Status "Draft" or "Approved"
   • During development: Status "InProgress"
   • Post-implementation: Status "Review"
4. Understand implementation scope and complexity

Halt If:

• Configuration file missing or invalid
• Task file not found or unreadable
• Task too vague to assess risks

Output: Configuration loaded with risk threshold, task spec loaded with ID/title, assessment mode determined, implementation scope analyzed (tasks/systems/patterns)

See: references/templates.md#step-0-output for complete format

Step 1: Identify Risk Areas

Purpose: Brainstorm potential risks across all 6 risk categories by analyzing task complexity, technical context, acceptance criteria, and known issues.

Actions:

1. Analyze task complexity:
   • Count tasks/subtasks (>10 = higher complexity)
   • Count systems involved (>3 = higher integration risk)
   • Identify new patterns vs. established patterns
   • Identify unknown vs. familiar technologies
2. Review technical context:
   • Data models involved
   • External APIs/services
   • Authentication/authorization requirements
   • Database operations (migrations, complex queries)
   • UI components (if applicable)
3. Check acceptance criteria for risk signals:
   • Security requirements mentioned?
   • Performance targets specified?
   • Data migration needed?
   • Complex business logic?
   • User-facing changes (impact scope)?
4. Brainstorm potential risks in each category:
   • Technical: Integration challenges, unknown APIs, complexity
   • Security: Auth vulnerabilities, injection risks, data exposure
   • Performance: Response time, scalability, N+1 queries, resource usage
   • Data: Integrity issues, migration complexity, data loss potential
   • Business: User impact scope, revenue implications, compliance
   • Operational: Deployment complexity, monitoring gaps, rollback difficulty
5. Document 10-20 potential risks with initial categorization

Output: Risk areas identified with count per category (Technical/Security/Performance/Data/Business/Operational), complexity indicators (task count, system count, pattern type)

See: references/templates.md#step-1-output for complete format with examples

Step 2: Score Each Risk (P×I)

Purpose: Systematically score each identified risk using Probability × Impact methodology to enable objective risk comparison and prioritization.

Actions: For each identified risk:

1. Assess Probability (P: 1-3):
   • 1 (Low): Unlikely to occur (<20% chance) - good patterns, known approaches
   • 2 (Medium): May occur (20-60% chance) - some unknowns, moderate complexity
   • 3 (High): Likely to occur (>60% chance) - complex, many unknowns, new territory
2. Assess Impact (I: 1-3):
   • 1 (Low): Minor inconvenience, easy fix, low impact
   • 2 (Medium): Significant issue, moderate effort to fix, notable impact
   • 3 (High): Critical failure, major effort to fix, security/data loss/business impact
3. Calculate Risk Score:
   • Risk Score = P × I (1-9 scale)
4. Document reasoning:
   • Why this probability? (evidence, similar experiences, complexity factors)
   • Why this impact? (user impact, business impact, fix difficulty)
5. Sort risks by score (highest first for reporting)

Output: Risks scored with P×I methodology, score distribution (critical/high/medium/low counts), highest score, quality gate impact prediction

See: references/templates.md#step-2-output for complete format and scoring examples

Step 3: Develop Mitigation Strategies

Purpose: Create actionable mitigation strategies for all high-risk items (score ≥6) with concrete prevention, detection, and recovery actions.

Actions: For each high-risk item (prioritize critical risks first):

1. Identify mitigation approach:
   • Prevention: How to prevent risk from occurring? (design, patterns, validation)
   • Detection: How to detect if risk occurs? (tests, monitoring, logging)
   • Recovery: How to recover if risk occurs? (rollback, fallback, manual fix)
2. Specify concrete actions:
   • What specific code/design changes?
   • What tests to write? (test files, scenarios)
   • What monitoring to add? (metrics, alerts)
   • What documentation needed?
3. Assign to appropriate phase:
   • During Implementation: Handle when coding (architectural decisions, validation)
   • Testing: Validate through tests (unit, integration, E2E)
   • Deployment: Address in deployment process (migrations, feature flags)
   • Monitoring: Detect in production (alerts, dashboards)
4. Estimate effort:
   • Minimal (<1 hour)
   • Moderate (1-4 hours)
   • Significant (>4 hours)

Output: Mitigation strategies developed for all high-risk items, critical/high risks mitigation counts, total effort estimate, phase breakdown (implementation/testing/deployment/monitoring)

See: references/templates.md#step-3-output for complete format and mitigation examples

Step 4: Prioritize Test Scenarios

Purpose: Map risks to test priorities (P0/P1/P2) and identify must-have test scenarios for high-risk areas to ensure comprehensive validation.

Actions:

1. Map risks to test priorities:
   • P0 (Critical): Risks with score ≥7 (must have before merge)
   • P1 (High): Risks with score 5-6 (should have before merge)
   • P2 (Medium): Risks with score 3-4 (nice to have)
   • P3 (Low): Risks with score 1-2 (standard testing)
2. Identify must-have tests for high-risk areas:
   • Security risks → Security test scenarios (injection, auth bypass, data exposure)
   • Performance risks → Performance test scenarios (load tests, query analysis)
   • Data risks → Data integrity test scenarios (race conditions, migrations)
   • Integration risks → Integration test scenarios (external API failures)
3. Specify test scenarios for each P0/P1 risk:
   • Describe test scenario (what to test, how to test)
   • Specify test level (unit/integration/E2E)
   • Assign priority (P0/P1/P2)
   • Define expected outcome
4. Document risk-test mapping:
   • Which tests validate which risks?
   • What test coverage is needed?
   • What scenarios would expose the risk?

Output: Test scenarios prioritized by risk level, P0/P1/P2 test counts, risk-test mapping complete

See: references/templates.md#step-4-output for complete format and test examples

Step 5: Generate Risk Profile Report

Purpose: Create comprehensive risk profile report documenting all risks, scores, mitigations, and test priorities for reference during implementation and quality review.

Actions:

1. Load risk profile template from .claude/templates/risk-profile.md
2. Populate risk matrix:
   • List all risks sorted by score (highest first)
   • Include: #, Category, Risk, P, I, Score, Mitigation summary
3. Create high-risk summary section:
   • Risks with score ≥6 with detailed mitigations
   • Concrete actions, phase assignment, effort estimates
4. Document test prioritization:
   • P0/P1/P2 test scenarios with risk mapping
   • Test files, scenarios, expected outcomes
5. Add quality gate impact prediction:
   • Will any risks trigger FAIL (score ≥9)?
   • Will any risks trigger CONCERNS (score ≥6)?
   • What's needed for PASS? (mitigation + testing)
6. Generate file path: {qualityLocation}/assessments/{taskId}-risk-{YYYYMMDD}.md
7. Write risk profile file with all sections

Output: Risk profile report generated at path, total risks documented, critical/high risks detailed, test priorities documented (P0/P1/P2 counts), quality gate impact prediction

See: references/templates.md#step-5-output and #complete-risk-profile-report-template for complete format

Step 6: Present Summary to User

Purpose: Provide concise summary with key risk metrics, critical risks highlighted, mitigation strategies, test priorities, and clear next steps.

Actions:

1. Display formatted summary:
   • Task metadata (ID, title, assessment date)
   • Risk summary (total, critical, high, medium, low counts)
   • Critical risk(s) highlighted with mitigation (if any)
   • High-risk areas with mitigation summaries
   • Test priorities (P0/P1 scenarios)
   • Quality gate impact prediction
   • Recommendation for next steps
2. Highlight critical risks (score ≥7) requiring immediate attention
3. Provide implementation guidance:
   • Address critical risks first
   • Implement high-risk mitigations during development
   • Write P0/P1 tests to validate
4. Emit telemetry event with all metrics

Output: Formatted summary with task metadata, risk counts by severity, critical risks highlighted with mitigations, high-risk areas summarized, P0/P1 test priorities, quality gate impact prediction, path to PASS recommendations, next steps

See: references/templates.md#step-6-user-facing-summary for complete formatted output examples

Execution Complete.

Risk Scoring Methodology

Probability (P): 1-3 scale measuring likelihood (1=<20% unlikely, 2=20-60% may occur, 3=>60% likely)

Impact (I): 1-3 scale measuring severity (1=minor/easy fix, 2=significant issue/moderate fix, 3=critical failure/major fix)

Risk Score: P × I (1-9 scale) | 9=critical immediate mitigation, 6-8=high mitigation+testing, 3-5=medium monitor, 1-2=low standard precautions

Quality Gate Rules: Score ≥9 → FAIL | Score ≥6 → CONCERNS | Score <6 → No auto-impact

See: references/templates.md#probability-assessment-guidelines and #impact-assessment-guidelines for detailed scoring criteria and examples

Integration with Other Skills

Before: Planning skills (create-task-spec, breakdown-epic) create task spec → Task approved → Ready for risk assessment

After - Pre-implementation: Developer aware of risks, mitigations inform implementation approach, test priorities guide test writing

Handoff to test-design: Risk profile with P0/P1/P2 priorities → test-design creates detailed scenarios for high-risk areas

Handoff to quality-gate: Risk profile informs gate decision | Critical risks (≥7) checked for mitigation | High risks (≥6) checked for test coverage

See: references/templates.md#integration-examples for complete workflows with data flow

Best Practices

Assess early (after spec, before code) | Be honest about probability (consider team experience) | Consider real impact (data loss, security, business) | Actionable mitigations (specific, phase-assigned, effort-estimated) | Risk-driven testing (high risk = high priority tests) | Continuous reassessment (if requirements change or new risks discovered)

Reference Files

Detailed documentation in references/:

• templates.md: All output formats (Step 0-6), risk scoring examples, complete risk profile report template, risk category details, probability/impact guidelines, mitigation strategies, test prioritization examples, integration workflows, JSON output format

• risk-categories.md: Risk category definitions and examples (currently placeholder - see templates.md)

• risk-scoring.md: P×I methodology details (currently placeholder - see templates.md)

• mitigation-strategies.md: Mitigation patterns (currently placeholder - see templates.md)

• risk-examples.md: Risk profile examples (currently placeholder - see templates.md)

Risk Profile Assessment skill - Version 2.0 - Minimal V2 Architecture