Skip to content
Skills Library
Management & product · Analysis

dependency-mapping

/dependency-mapping

Use when asked to map issue dependencies, show what blocks what, or find the critical path through project work - reads GitHub issues for blocked-by/depends-on signals and generates Mermaid flowcharts of blocking chains

Author
britt ↗
Licence
MIT
Last repository change
22.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 22.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when asked to map issue dependencies, show what blocks what, or find the critical path through project work - reads GitHub issues for blocked-by/depends-on signals and generates Mermaid flowcharts of blocking chains

Original author description

Use when asked to map issue dependencies, show what blocks what, or find the critical path through project work - reads GitHub issues for blocked-by/depends-on signals and generates Mermaid flowcharts of blocking chains

How it works

  1. When to Use
  2. CRITICAL: Mermaid Syntax Rules
  3. Dependency Graph Patterns
  4. Dependency Analysis Process
  5. Dependency Detection Keywords
  6. Arrow Types
  7. Best Practices
  8. Example Output
  9. After Generating Graph
  10. Common Mistakes
Original SKILL.md headings · 245 lines, 854 words
SKILL.md preview
---
name: dependency-mapping
description: "Use when asked to map issue dependencies, show what blocks what, or find the critical path through project work - reads GitHub issues for blocked-by/depends-on signals and generates Mermaid flowcharts of blocking chains"
---

# Dependency Mapping Skill

Generate Mermaid flowcharts that visualize GitHub issue dependencies, blocking relationships, and critical paths through the project.

## When to Use

Activate this skill when:
- User asks "show me the dependencies", "map the issue dependencies"
- User wants to see which issues block others
- During sprint planning to identify critical path
- After issue decomposition to visualize relationships

## CRITICAL: Mermaid Syntax Rules

### NEVER use parentheses in node labels

Parentheses break GitHub rendering.

**WRONG:**
```mermaid
flowchart LR
    I1[#1 Setup (init)]
```

**CORRECT:**
```mermaid
flowchart LR
    I1[#1 Setup - init]
```

### Issue Node Naming Convention

Use consistent naming for issue nodes:

```mermaid
flowchart LR
    I201[#201 Setup auth module]
    I202[#202 Implement login]
    I203[#203 Add password reset]
```

Format: `I<number>[#<number> <short title>]`

## Dependency Graph Patterns

### Linear Dependencies

Issues that must be done in sequence:

```mermaid
flowchart LR
    I1[#1 Setup project] --> I2[#2 Create database]
    I2 --> I3[#3 Add API endpoints]
    I3 --> I4[#4 Integration tests]
```

### Parallel Work

Issues that can be done simultaneously:

```mermaid
flowchart TB
    I1[#1 Setup project]
    I1 --> I2[#2 Frontend setup]
    I1 --> I3[#3 Backend setup]
    I2 --> I4[#4 Integration]
    I3 --> I4
```

### Complex Dependencies

Multiple blocking relationships:

```mermaid
flowchart TB
    subgraph Foundation
        I1[#1 Project setup]
        I2[#2 Database schema]
    end

    subgraph Features
        I3[#3 User auth]
        I4[#4 User profile]
        I5[#5 Settings page]
    end

    subgraph Integration
        I6[#6 End-to-end tests]
    end

    I1 --> I2
    I1 --> I3
    I2 --> I3
    I3 --> I4
    I3 --> I5
    I4 --> I6
    I5 --> I6
```

### Critical Path Highlighting

Emphasize the longest dependency chain:

```mermaid
flowchart LR
    I1[#1 Setup]
    I2[#2 Database]
    I3[#3 Auth]
    I4[#4 API]
    I5[#5 Tests]

    I1 ==> I2
    I2 ==> I3
    I3 ==> I4
    I4 ==> I5

    I1 --> I6[#6 Docs]

    style I1 fill:#f96
    style I2 fill:#f96
    style I3 fill:#f96
    style I4 fill:#f96
    style I5 fill:#f96
```

## Dependency Analysis Process

### Step 1: Gather Issues

**Prerequisite**: Requires the `gh` CLI (e.g. `gh issue list --state open --json number,title,labels,body`) or an equivalent GitHub MCP server.

Gather all open issues:
- Note issue numbers and titles
- Check for "blocked by" or "depends on" in labels
- Look for dependency keywords in descriptions

### Step 2: Parse Dependencies

Look for dependency indicators:
- **Labels**: `blocked`, `waiting`, `depends-on`
- **Body text**: "Blocked by #X", "Depends on #X", "After #X"
- **Comments**: Discussion about ordering

### Step 3: Build Dependency Map

Create a map of relationships:
```
#201 → blocks → #202, #203
#202 → blocks → #204
#203 → blocks → #204
```

### Step 4: Identify Critical Path

Find the longest chain of dependencies - this is the critical path that determines minimum project duration.

### Step 5: Generate Diagram

Create the Mermaid flowchart with:
- All issues as nodes
- Arrows showing "blocks" direction
- Subgraphs for phases or areas
- Styling for critical path

## Dependency Detection Keywords

Look for these patterns in issue bodies:

| Pattern | Meaning |
|---------|---------|
| "Blocked by #X" | This issue depends on #X |
| "Depends on #X" | This issue depends on #X |
| "After #X" | Do this after #X |
| "Blocks #X" | This issue must complete before #X |
| "Required for #X" | This issue must complete before #X |
| "Prerequisite: #X" | This issue depends on #X |

## Arrow Types

| Arrow | Use For |
|-------|---------|
| `-->` | Standard dependency |
| `==>` | Critical path |
| `-.->` | Soft dependency or optional |
| `--text-->` | Labeled relationship |

## Best Practices

1. **Left-to-right for linear** - Use `flowchart LR` for sequential work
2. **Top-to-bottom for complex** - Use `flowchart TB` for many branches
3. **Group by phase** - Use subgraphs for project phases
4. **Highlight critical path** - Use thick arrows and colors
5. **Keep titles short** - Truncate to fit in diagram
6. **Link to issues** - Include issue numbers for reference

## Example Output

For a set of issues about building an API:

```mermaid
flowchart TB
    subgraph Setup
        I1[#101 Initialize project]
        I2[#102 Configure database]
    end

    subgraph Core API
        I3[#103 User endpoints]
        I4[#104 Auth endpoints]
        I5[#105 Data endpoints]
    end

    subgraph Testing
        I6[#106 Unit tests]
        I7[#107 Integration tests]
    end

    I1 --> I2
    I2 --> I3
    I2 --> I4
    I2 --> I5
    I3 --> I6
    I4 --> I6
    I5 --> I6
    I6 --> I7

    %% Critical path
    linkStyle 0,1,3,5,7 stroke:#f00,stroke-width:2px
```

## After Generating Graph

- Offer to save the graph to a markdown file the user names
- Identify the critical path length
- Flag any circular dependencies as errors
- Suggest `timeline-planning` skill (if available) for Gantt chart
- Recommend addressing blockers first

## Common Mistakes

- **Parentheses in node labels** - breaks GitHub's Mermaid rendering. NEVER use parentheses in labels; use dashes instead (see the CRITICAL syntax rules above).
- **Unflagged circular dependencies** - if #A blocks #B and #B blocks #A, the diagram may still render but the plan is impossible. Always call out cycles as errors.
- **Inconsistent node IDs** - deviating from the `I<number>[#<number> <short title>]` convention silently creates duplicate nodes for the same issue.

Versions

RepositoryScoreLicence
This page · britt/claude-code-skills100MIT
qa-aman/claude-skills100MIT
mcorbett51090/ravenclaude90MIT
helx0071/skillsmo90MIT

Identical content appears in 1 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version ff120cd12c2d (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90mapping-dependencies
    Maps task dependencies in an Astravue project, finds the critical path and blocked work, and detects circular dependencies before any rescheduling. Use when the user asks about dependencies, blockers, what's blocking what, the critical path, or wants to understand or fix the sequencing of a project.
  • 100timeline-planning
    Use when asked for a project timeline, schedule, sprint plan, or Gantt chart, or after breaking work into issues - converts issue estimates and dependencies into a Mermaid Gantt chart with phases, milestones, and critical path
  • 100plan-dag
    Render the current plan as a high-DPI PNG dependency DAG — nodes are issues / sub-issues / PRs, edges come from sub-issue links plus dependency-language prose ("Depends on", "Part of", "Blocks", "Closes") and PR / commit cross-references, and every node is color-coded done /…
  • 100project-planning
    Use when the user says 'build a project plan', 'help me plan X', 'break down this project', or 'scope out this feature' - orchestrates issue-decomposition, architecture-diagramming, dependency-mapping, and timeline-planning to produce GitHub issues, diagrams, and a saved plan document
  • 100dependency-map
    Track cross-team dependencies in one JSON file and get a risk-ranked blocker list, the longest hand-off chain and a Mermaid graph. Use when several teams depend on each other and you need to know what to chase this week.
  • 100dependency-critical-path-analyzer
    Analyzes task and project dependency graphs to identify the critical path, surface blockers, calculate slack/float for non-critical tasks, and produce schedule risk assessments with prioritized recommendations. Accepts task lists with dependencies in various formats (CSV,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.