Skip to content
Skills Library
Management & product · Planning

dependency-mapping

/dependency-mapping

Build the cross-team dependency graph and derive the critical path — every handoff gets a producer, consumer, due date, and interface contract; cycles and single points of failure get flagged. Use when a program spans multiple teams and you need to know what actually decides the date.

Repository
ravenclaude ↗
Licence
MIT
Last repository change
27.10.2026

Assessment and security

90/ 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.
Content25 / 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 27.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

Build the cross-team dependency graph and derive the critical path — every handoff gets a producer, consumer, due date, and interface contract; cycles and single points of failure get flagged. Use when a program spans multiple teams and you need to know what actually decides the date.

Original author description

Build the cross-team dependency graph and derive the critical path — every handoff gets a producer, consumer, due date, and interface contract; cycles and single points of failure get flagged. Use when a program spans multiple teams and you need to know what actually decides the date.

How it works

  1. When to use
  2. Procedure
  3. Output
  4. Anti-patterns
Original SKILL.md headings · 38 lines, 267 words
SKILL.md preview
---
name: dependency-mapping
description: "Build the cross-team dependency graph and derive the critical path — every handoff gets a producer, consumer, due date, and interface contract; cycles and single points of failure get flagged. Use when a program spans multiple teams and you need to know what actually decides the date."
---

# Skill: Dependency mapping

Make the invisible cross-team handoffs visible, then compute what actually drives
the program date. A program is its dependencies, not its tasks.

## When to use

- A program spans ≥2 teams and the date feels unknowable.
- Two teams are building toward an integration with no agreed contract.
- You need to know which slips matter (critical path) and which don't (slack).

## Procedure

1. **Enumerate cross-team deliverables.** For each, record: producer team,
   consumer team, due date, and the **interface contract** (schema / API / event /
   doc) at the seam. A handoff with no named interface is the highest-risk kind.
2. **Build the graph.** Nodes are deliverables; edges are "X must finish before Y
   can start." Use the [`dependency-map`](../../templates/dependency-map.md) template.
3. **Derive the critical path.** Find the longest chain of gated handoffs — that
   chain *is* the date. Compute **slack** on every other chain.
4. **Flag cycles** (A waits on B waits on A): break with a stub/mock or a phased
   contract. **Flag single points of failure**: one under-resourced team on the
   critical path is a key-person risk.
5. **Make every seam contract-first.** Where two teams meet, agree the interface
   *before* either builds. Route unowned seams to the TPM to assign an owner.

## Output

A dependency map, the critical path, the slack on non-critical chains, and a list
of flagged cycles/SPOFs feeding the RAID log.

## Anti-patterns

- A "dependency list" that's really a task list (no producer→consumer edges).
- A date asserted with no critical path to defend it.
- An interface seam with no owner and no contract.

Versions

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

Database snapshot: 13.11.2026 · package version 3dfb0e5da5c0 (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

  • 100flow-next-deps
    Show spec dependency graph and execution order. Use when asking 'what's blocking what', 'execution order', 'dependency graph', 'what order should specs run', 'critical path', 'which specs can run in parallel'.
  • 100flow-next-deps
    Show spec dependency graph and execution order. Use when asking 'what's blocking what', 'execution order', 'dependency graph', 'what order should specs run', 'critical path', 'which specs can run in parallel'.
  • 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.
  • 100flow-next-deps
    Show spec dependency graph and execution order. Use when asking 'what's blocking what', 'execution order', 'dependency graph', 'what order should specs run', 'critical path', 'which specs can run in parallel'.
  • 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,…
  • 90schedule-and-critical-path
    Sequence work by dependency to find which tasks actually determine the finish date, and manage those. Use when a project has many parallel workstreams and an immovable date.

Feedback and reports

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