dependency-mapper://

[ dependency-mapper:// ] experimental

cat: ai model: @cf/meta/llama-3.1-8b-instruct

Paste a list of tasks + which depends on which → get a dependency graph in plain text, a critical path, and the 2-3 tasks where slippage costs you most.

// system prompt

You map task dependencies. User provides a list of tasks with dependencies. Output:

  Dependency graph:
  ```
  <ascii or mermaid-style diagram showing the dependency chain>
  ```

  Critical path:
  <ordered list of tasks on the critical path>

  Parallelisable branches:
  • <branch 1 — tasks that can run alongside the critical path>
  • <branch 2>

  Bottleneck tasks (one slip cascades):
  1. <task> — <why this one bottlenecks: how many downstream tasks block on it>
  2. <task> — <…>

  Recommended attention:
  • <where to add buffer / where to fast-track>

Rules:
- Use a mermaid-compatible syntax for the graph (renders in Notion / GitHub).
- Critical path = longest chain of dependent tasks.
- Bottleneck ≠ critical path: a bottleneck is a task with many downstream dependents (high fan-out).
- Don't invent task durations unless the user supplies them. Talk about chain length, not days.
- If the dependency list has a cycle (A depends on B, B depends on A), flag it: "[cycle detected: <A> ↔ <B>]".

List of tasks with dependencies (e.g. "B depends on A")

⚡ powered by Cloudflare Workers AI · quota deducted on success

// output

// sample output

Dependency graph:
```mermaid
graph LR
  A[Design review] --> B[API spec]
  A --> C[Frontend mockups]
  B --> D[Backend impl]
  C --> E[Frontend impl]
  D --> F[Integration testing]
  E --> F
  F --> G[UAT]
  B --> H[Documentation]
  G --> I[Launch prep]
  H --> I
```

Critical path:
A → B → D → F → G → I  (6 tasks long)

Parallelisable branches:
• C → E runs alongside B → D (mockups + frontend can move while API spec / backend land).
• H (Documentation) runs alongside D → F → G (only needs B as input).

Bottleneck tasks (one slip cascades):
1. A — Design review. Five tasks block on it directly (B, C). Every other task is downstream of A. A 1-day slip on A = at least a 1-day slip on launch.
2. F — Integration testing. Two parallel chains (D and E) feed into it. If either chain slips, F slips. Most likely place for invisible slippage to compound.
3. B — API spec. Both D (backend) and H (documentation) depend on it. Slip here delays both the critical path and the parallel chain.

Recommended attention:
• Add buffer around F. It's where two chains converge — small slips in either input compound here.
• Fast-track A. Six tasks downstream means every day saved at A is a day saved at I.
• Watch B closely. It's on the critical path AND fans out to the documentation chain — slipping B costs you on two fronts.

// powered by cloudflare workers ai · quota deducted on success ← back to catalog