agentsclimarketplace

Risk management

Skill viktorbezdek/skillstack/risk-management/skills/risk-management

Skills I use and develop to deliver better outcomes faster and with less effort.

Install
npx -y skills add viktorbezdek/skillstack --skill risk-management

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

  • 10 stars10 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Systematically assess and mitigate risks using risk registers, probability-impact matrices, mitigation strategies, and contingency plans. Use when the user asks to assess risks, build a risk register, plan for failure modes, evaluate downside scenarios, prepare contingency plans, or quantify uncertainty before a decision or launch. NOT for finding conceptual flaws or blind spots in ideas (use critical-intuition). NOT for security vulnerability auditing in code (use code-review). NOT for identifying boundary conditions in code (use edge-case-coverage).

SKILL.md

6.8 KB, ~1.5k tokens by cl100k_base, as published. Nobody here has run it

Risk Management

Identify, assess, and mitigate risks systematically.

When to use this skill

  • Starting a new project or initiative — before committing resources
  • Planning a migration, launch, or infrastructure change
  • Running a pre-mortem before a critical project begins
  • Assessing organizational risks from restructuring or strategic changes
  • Activating a contingency plan when a tracked risk materializes
  • Building a risk register from an existing list of concerns

When NOT to use this skill

  • Security vulnerability scanning → use dedicated security audit tools
  • Financial risk modeling (Monte Carlo, VaR) → use specialized quantitative tools
  • Real-time incident response → use debugging/troubleshooting workflows
  • Finding conceptual flaws in ideas → use critical-intuition
  • Edge-case coverage in code → use edge-case-coverage

Decision tree

What are you trying to do?
  │
  ├─ Assess risks for a NEW project/initiative
  │   └─ Full risk assessment: identify by category → score → mitigate → monitor
  │
  ├─ Imagine the project already FAILED and find out why
  │   └─ Pre-mortem technique (see below)
  │
  ├─ Score and prioritize an EXISTING list of concerns
  │   └─ Apply 3x3 matrix → assign strategies → add owners and review dates
  │
  └─ A tracked risk has MATERIALIZED
      └─ Contingency activation: execute response → update register → surface new risks

Risk Assessment Matrix

           IMPACT
           Low    Med    High
LIKELIHOOD
High       Med    High   Critical
Med        Low    Med    High
Low        Low    Low    Med

Risk Categories

CategoryExamples
TechnicalArchitecture, integration, performance
ScheduleDependencies, estimation, resources
ResourceSkills, availability, turnover
ExternalVendors, regulations, market
OrganizationalPriorities, funding, politics

Risk Register Template

## Risk Register

| ID | Risk | Category | Likelihood | Impact | Score | Mitigation | Owner | Status |
|----|------|----------|------------|--------|-------|------------|-------|--------|
| R1 | [desc] | Technical | High | Med | 6 | [action] | [name] | Open |
| R2 | [desc] | Schedule | Med | High | 6 | [action] | [name] | Open |

Scoring

  • Likelihood: 1 (Low) - 3 (High)
  • Impact: 1 (Low) - 3 (High)
  • Score = Likelihood x Impact
  • 1-2: Low priority (Accept/monitor), 3-4: Medium (Mitigate), 6-9: High/Critical (Avoid/Mitigate/Transfer)

Mitigation Strategies

StrategyWhen to UseExample
AvoidRisk is Critical (6-9) and can be eliminated by changing approachUse open-source alternative to avoid vendor lock-in
TransferRisk involves financial loss or liability that can be shiftedCyber insurance for data breach risk
MitigateRisk cannot be avoided but likelihood/impact can be reducedRun load tests before migration to reduce performance regression risk
AcceptRisk is Low (1-2) or mitigation cost exceeds expected impactMinor UI change may confuse some users temporarily

Risk Response Template

## Risk: [Name]

**Description**: [what could go wrong]
**Trigger**: [warning signs]
**Probability**: [%]
**Impact**: [consequence]

### Response Plan
- **Strategy**: [avoid/transfer/mitigate/accept]
- **Actions**:
  1. [preventive action]
  2. [contingency if occurs]
- **Owner**: [responsible person]
- **Review date**: [when to reassess]

Monitoring Practices

FrequencyActivity
DailyCheck trigger conditions
WeeklyReview active risks
MonthlyReassess scores
QuarterlyFull register review

Pre-Mortem Technique

Before project starts, imagine it failed.

  1. What went wrong? — list specific failure modes (not "it failed" but "the database migration corrupted production data")
  2. Why did it happen? — trace each failure to a root cause; ask "why?" three times
  3. What could we have done? — convert each finding into a preventive action with an owner

Convert answers to risks and mitigations. The pre-mortem bypasses optimism bias because starting from assumed failure removes the temptation to say "that probably won't happen."

When to run a pre-mortem: before any project with a hard deadline, irreversible commitment, or budget > 2 team-months.

Anti-Patterns with Solutions

  1. Medium-Medium everything — every risk gets scored "Medium/Medium" without analysis, making the register useless for prioritization.

    • Solution: for each "Medium," demand evidence: "what specific fact supports this score? What would change it to High?" If no evidence exists, the score is a guess — gather data before scoring.
  2. Vague mitigations — "Mitigate: reduce risk" without specific actions, triggers, or owners.

    • Solution: every mitigation must answer four questions: What specific action? Who owns it? By when? What trigger activates it? Example: "Mitigate: run Aurora compatibility audit by end of week 1 (owned by DB lead), trigger: any incompatible extension found."
  3. Register as checkbox exercise — team fills it mechanically and never revisits.

    • Solution: assign each risk a specific owner with a concrete check action (not "keep an eye on it" but "run load test against staging every Monday"); schedule quarterly reviews that close resolved risks and force Accept decisions on stale items.
  4. Optimism bias — forward-looking analysis misses risks because "things usually work out."

    • Solution: use the pre-mortem technique; it bypasses optimism bias by starting from assumed failure.
  5. Infinite register growth — every concern gets added, nothing is ever closed.

    • Solution: cap at 20 items; at each review, close resolved risks, merge duplicates, and force decisions on items open for 2+ cycles. A register over 20 items loses its usefulness.
  6. Single-category tunnel vision — only technical risks get identified, ignoring schedule, resource, external, and organizational risks.

    • Solution: systematically walk all five categories during identification; use the category table as a checklist, not a suggestion.

What ships with it: 2 files

3.2 KB alongside SKILL.md

Gives 0 of the 12 instructions most security skills give in ~1.5k tokens

Counted across 648 of the 828 authors here whose files we hold, read 2026-08-07

  • Parameterize all database queriesin 68 of 648, across 51 files
  • Hash passwords using bcrypt, scrypt, or argon2in 49 of 648, across 36 files
  • Apply rate limiting to authentication endpointsin 48 of 648, across 24 files
  • Configure security headersin 35 of 648, across 19 files
  • Validate all inputsin 32 of 648, across 24 files
  • Validate all external input at the system boundaryin 29 of 648, across 19 files
  • Run containers as a non-root userin 28 of 648, across 15 files
  • Use httponly secure samesite cookies for sessionsin 26 of 648, across 15 files
  • Run dependency audits before every releasein 21 of 648, across 10 files
  • Encode output to prevent cross-site scriptingin 21 of 648, across 11 files
  • Copy dependencies before source codein 20 of 648, across 9 files
  • Store secrets in environment variablesin 20 of 648, across 18 files

Said here and by no other author read

  • score likelihood and impact from one to three
  • assign one of four mitigation strategies
  • assign a specific owner to each risk
  • run a pre-mortem before a project starts
  • ask why three times to find root causes
  • convert pre-mortem findings into preventive actions

Grouped from the skills themselves: near-identical wordings counted once, and counted by distinct author, so one author publishing three of these counts once. Length counted with cl100k_base; the agent that loads this file may tokenize it differently.

Keep looking

Skills are one crate of 328,083. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.