Agent skill · Workflow & Productivity

timeline-generator-scott-margetts

Build dependency network and critical path from a matter plan. Produce an interactive Gantt, flag near-critical tasks, and run what-if cascade scenarios when delays occur — showing programme impact and drafting communications. Produces filtered workstream or jurisdiction views for local counsel. Trigger on: 'build a timeline', 'Gantt chart', 'critical path', 'what if X is delayed', 'what moves if', 'schedule impact', 'how does this affect the programme', 'when do we finish', 'can we still close on time', 'if we miss this deadline', 'run a what-if', 'visualise the plan', 'Germany timeline', 'wh

lawve-aigithub.com/lawve-aiGitHub ↗
claude-codeNOASSERTION
Install
npx skills add lawve-ai/awesome-legal-skills --skill timeline-generator-scott-margetts --agent claude-code

Same command for any agent — swap --agent for codex, cursor, copilot.

Facts
Files in the skill folder: 3
SKILL.md size: 38 KB
Bundled scripts: none
Version: 2026.03.17
Declared author: Scott Margetts
Path: skills/timeline-generator-scott-margetts/SKILL.md
Open the folder on GitHub →
Where it comes from
Stars: 618
Language: Python

Weekly change comes from our own snapshots, not the repository page — it measures attention, not adoption.

Review
written from the skill's own SKILL.md · Aug 5, 2026

What it does

Converts a dependency-tagged task list into a visual timeline with critical path analysis. It identifies tasks that must finish on time to close the matter as planned and models delays to show downstream impacts and draft communications. It can produce filtered views for a specific workstream or jurisdiction for local counsel, and supports what-if cascade scenarios where delays trigger a cascade of downstream task moves and revised programme completion dates, along with draft client and local counsel communications.

How it works

  • Mode 1 (Baseline build): build the dependency network from a matter plan, calculate ES, EF, LS, LF, and the critical path. Produce a Gantt diagram and a dependency summary. Input must include Task ID, Duration (working days), Predecessor(s), Dependency type (FS/FF/SS), and a fixed date anchor. It supports forward-scheduling or back-scheduling depending on known dates.
  • Mode 2 (What-if analysis): take the existing baseline plus a proposed change, compute which tasks move, whether the critical path changes, and the new programme completion date. It also produces a draft client notification and affected local counsel communications. Input is the baseline plus the proposed change in plain language.
  • Mode 3 (Baseline update): apply a confirmed change to produce a versioned updated baseline, a comparison table showing original vs revised dates for affected tasks, and trigger handoffs to other skills.
  • Mode 4 (Workstream/jurisdiction view): generate a filtered Gantt and timeline for a specified workstream or jurisdiction from the full baseline. Output includes in-scope tasks, upstream constraints, downstream milestones, and ensures float is inherited from the full network calculation. It explains what is not shown and preserves the full-network float values.

When to use it

Use to establish a timing baseline, perform delay impact analyses (what-if cascades), or publish workstream-specific views for local counsel. Trigger phrases include: 'build a timeline', 'Gantt chart', 'critical path', 'what if X is delayed', 'what moves if', 'schedule impact', 'how does this affect the programme', 'when do we finish', 'can we still close on time', 'if we miss this deadline', 'run a what-if', 'visualise the plan', 'Germany timeline', 'timeline for local counsel', or requests for specific workstreams.

What it can touch

The skill uses the matter-plan-builder output to compute timelines and can produce a filtered view for a given workstream or jurisdiction. It references dependencies, durations, and fixed dates, and outputs a Gantt diagram, dependency summary, and comparison tables. It does not specify external tools beyond the stated input/output mechanisms and requires an existing baseline and, for what-if, a proposed change description.

Caveats

Inputs must be complete and include necessary dates and dependencies. If inputs are missing, the process stops and asks for the missing data. The what-if analysis can produce multiple scenarios when lags represent external determinations, and it requires explicit clarification of lag type or models as per the guidance in the baseline procedure. The approach emphasizes transparency by showing how calculations are derived for critical path tasks and any non-obvious constraints.

From the SKILL.md

# Timeline Generator ## Purpose Convert a dependency-tagged task list into a visual timeline with critical path analysis. Identify which tasks must complete on time for the matter to close as planned. Model delays before they happen — or calculate their programme-level impact after they do. The what-if cascade is the central capability. When a jurisdiction delays, a regulatory determination runs long, or a counterparty goes quiet, the question is not just "is this task late" but "which of the twenty-three things downstream of this task now move, by how much, and what does the client need to know?" This skill produces that answer, along with the draft communications. This skill consumes the structured output of matter-plan-builder and feeds its results back as updated milestone dates to status-report-drafter and scope-change-controller. It sits at the technical centre of the LPM plugin: every other skill produces or consumes timeline data; this skill owns the calculation layer. --- ## Operating Modes ### Mode 1 — Baseline build At matter setup: build the dependency network from the matter plan, calculate the critical path and near-critical paths, produce the Gantt diagram and depend

What's inside
Steps it walks through
  1. Purpose
  2. Operating Modes
  3. Mode 1 — Baseline build
  4. Mode 2 — What-if analysis
  5. Mode 3 — Baseline update
  6. Mode 4 — Workstream or jurisdiction view
  7. Before Starting Any Mode
  8. Step-by-Step Process
  9. Step 1: Build the dependency network
  10. Step 2: Forward pass — calculate Early Start and Early Finish
  11. Step 3: Backward pass — calculate Late Start and Late Finish
  12. Step 4: Calculate float and identify the critical path
  13. Step 5: Produce the baseline output
  14. Step 6: What-if cascade (Mode 2 only)
Ships with 2 files
  • LICENSE.txt
  • README.md
More from awesome-legal-skills
All skills →
About this skill
What does the timeline-generator-scott-margetts skill do?

Build dependency network and critical path from a matter plan. Produce an interactive Gantt, flag near-critical tasks, and run what-if cascade scenarios when delays occur — showing programme impact and drafting communications. Produces filtered workstream or jurisdiction views for local counsel. Trigger on: 'build a timeline', 'Gantt chart', 'critical path', 'what if X is delayed', 'what moves if', 'schedule impact', 'how does this affect the programme', 'when do we finish', 'can we still close on time', 'if we miss this deadline', 'run a what-if', 'visualise the plan', 'Germany timeline', 'wh

How do I install it?

Run `npx skills add lawve-ai/awesome-legal-skills --skill timeline-generator-scott-margetts --agent claude-code` — it drops the skill into your project so the agent can pick it up. Swap the --agent value for codex, cursor or copilot if you use one of those.

Where does this skill come from?

From lawve-ai/awesome-legal-skills, a repository with 618 stars. We read it straight from the repository tree rather than a submitted listing, so what you see here is what is actually published.

Is a popular skill a good skill?

Not necessarily. Stars measure attention, not adoption — a repository can trend for a week and be abandoned. That is why we show the weekly change from our own snapshots next to the total, instead of a single flattering number.

Keep going