Dependency Mapping Skill

Map dependencies between implementation slices using Design Structure Matrix (DSM), calculate risk scores, and recommend implementation sequence.

When to Use

• During Ask mode Phase 2 (CONVERGE)
• When planning multi-slice features
• Before phasing to understand risk order

Instructions

Phase 1: Build DSM Matrix

Create a square matrix with slices on both axes. Mark dependencies with *:

         | #1.1 | #1.2 | #2.1 | #2.2 | #2.3 | #3.1 |
---------+------+------+------+------+------+------+
#1.1     |  -   |      |      |      |      |      |
#1.2     |  *   |  -   |      |      |      |      |
#2.1     |      |  *   |  -   |      |      |      |
#2.2     |      |      |  *   |  -   |      |  *   |
#2.3     |      |  *   |  *   |      |  -   |      |
#3.1     |      |      |      |      |      |  -   |

Legend: * = row depends on column
Reading: Row #2.2 has * in columns #2.1 and #3.1 = #2.2 depends on #2.1 AND #3.1

Phase 2: Calculate Dependency Score

For each slice, count:

Metric	Formula	Meaning
Fan-in	How many slices depend ON this?	High = blocker, ship early
Fan-out	How many slices does this DEPEND on?	High = risky, ship later
Dependency Score	Fan-out count	Lower = safer

Phase 3: Calculate Leverage Score

Score each slice on reuse of existing patterns:

Level	Score	Description
Full Reuse	0	Uses existing component from design system/Storybook as-is
Extend	1	Extends existing component with new props/variants
Compose	2	Composes multiple existing components
New Pattern	3	Creates new component following design system tokens
New System	5	Requires new patterns not in design system

Check these sources before scoring:

• /docs/design-system/components.md - Existing components
• Glob **/*.stories.tsx - Storybook patterns
• SemanticSearch for similar implementations in codebase

Phase 4: Calculate Risk Score

Risk Score = (Dependencies x 2) + Leverage + PriorityTier

Where PriorityTier:
- P1 (Frontend-only) = 0
- P2 (Frontend + Backend non-breaking) = 1
- P3 (Backend contract changes) = 2
- P4 (Data model changes) = 3

Phase 5: Identify Blockers

Flag slices that block others (high fan-in):

#3.1 WorkspaceInvite Entity
  Fan-in: 3 (blocks #2.2, #2.3, #2.4)
  RECOMMENDATION: Consider stub/mock for Phase 1, or ship early despite risk

Phase 6: Rank by Risk

Sort slices by Risk Score (lowest first = ships first):

Rank	Slice	Deps	Leverage	Tier	Risk Score
1	#1.1 Workspace Switcher	0	Extend (1)	P1 (0)	1
2	#1.2 Members Page UI	1	Compose (2)	P1 (0)	4
3	#2.1 List Members API	1	N/A	P2 (1)	4

Output Format

## Dependency Analysis

### DSM Matrix

[Matrix as shown above]

### Risk Scoring

| Slice | Deps | Leverage | Tier | Risk | Rank |
|-------|------|----------|------|------|------|
| [Slice] | [N] | [Level (score)] | P[N] | [Score] | [#] |

### Blockers Identified

| Slice | Blocks | Fan-in | Recommendation |
|-------|--------|--------|----------------|
| [Slice] | [List] | [N] | [Stub/Ship early/etc] |

### Recommended Sequence

1. [Lowest risk slice] - [Why safe]
2. [Next slice] - [Dependencies satisfied by #1]
...

### Existing System Leverage

| Component | Source | Slices Using | LOC Saved |
|-----------|--------|--------------|-----------|
| [Component] | [design-system/Storybook] | [List] | ~[N] |

Invocation

Invoke manually with "use dependency-mapping skill" or follow Ask mode Phase 2 (CONVERGE) which references this skill.

Related Skills

• phasing - Uses risk scores to group into phases
• design-context - Identifies existing patterns to leverage
• gtm-alignment - May override risk-based order for GTM priority