schedule-delay-analyzer — Claude Code skill for delay analysis
schedule-delay-analyzer is a skill that tracks project delays, their causes, and critical-path effects to estimate a time extension and review compensable costs.
MIT 132 installs ★ 434 updated 2026-10-19
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill schedule-delay-analyzer -a claude-codeWhat schedule-delay-analyzer does
The skill records schedule baselines and delay events. Each event can include an activity, delay category and cause, dates, critical-path status, description, and cost impact. It totals days on the critical path, groups events by category or cause, and calculates figures for a time-extension claim, including compensable days and costs.
A project summary also gives a projected completion date, and the analysis can be exported to Excel. The example implementation imports pandas; running it requires python3, and Excel export requires pandas. The total critical-path delay is the sum of all events marked as critical, so overlapping events can inflate the result unless you check it against the project schedule.
What it helps with
- total delay days on the critical path
- group events by cause and delay category
- estimate days for a time-extension claim
- calculate compensable delay days and costs
- export delay events to Excel
Example prompts for the agent
- Analyze the project delay events and total their effect on the critical path.
- Group the recorded delays by cause and summarize days and costs by category.
- Estimate the time extension from excusable critical-path delays and export the analysis to Excel.
How to install schedule-delay-analyzer
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill schedule-delay-analyzer -a claude-code2Manually: put the files in place
~/.claude/skills/schedule-delay-analyzer/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/schedule-delay-analyzer/
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill schedule-delay-analyzer -a codex2Manually: put the files in place
.agents/skills/schedule-delay-analyzer/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill schedule-delay-analyzer -a cursor2Manually: put the files in place
.cursor/skills/schedule-delay-analyzer/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction 1_DDC_Toolkit/Schedule-Management/schedule-delay-analyzer2Manually: put the files in place
.github/skills/schedule-delay-analyzer/SKILL.md1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill schedule-delay-analyzer -a gemini-cli2Platform CLI
gemini skills install https://github.com/datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --path 1_DDC_Toolkit/Schedule-Management/schedule-delay-analyzerManually: put the files in place
.devin/skills/schedule-delay-analyzer/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill schedule-delay-analyzer -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about schedule-delay-analyzer
How do I install schedule-delay-analyzer in Claude Code?
Run npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill schedule-delay-analyzer -a claude-code. The skill file is placed at ~/.claude/skills/schedule-delay-analyzer/SKILL.md.
What does schedule-delay-analyzer do?
It totals critical-path delays, groups events by cause and category, and estimates a time extension and compensable costs. It can also export the analysis to Excel.
What is needed to run it and export a report?
The example requires python3. Excel export uses pandas.
Source text
SKILL.md · MIT
---
name: "schedule-delay-analyzer"
description: "Analyze schedule delays, identify causes, and calculate time impacts using delay analysis methods."
homepage: "https://datadrivenconstruction.io"
metadata: {"openclaw": {"emoji": "📅", "os": ["darwin", "linux", "win32"], "homepage": "https://datadrivenconstruction.io", "requires": {"bins": ["python3"]}}}
---
# Schedule Delay Analyzer
## Technical Implementation
```python
import pandas as pd
from datetime import date, timedelta
from typing import Dict, Any, List, Optional
from dataclasses import dataclass, field
from enum import Enum
class DelayType(Enum):
EXCUSABLE_COMPENSABLE = "excusable_compensable"
EXCUSABLE_NON_COMPENSABLE = "excusable_non_compensable"
NON_EXCUSABLE = "non_excusable"
CONCURRENT = "concurrent"
class DelayCause(Enum):
OWNER_CHANGE = "owner_change"
DESIGN_ERROR = "design_error"
WEATHER = "weather"
DIFFERING_CONDITIONS = "differing_conditions"
CONTRACTOR_ISSUE = "contractor_issue"
MATERIAL_DELAY = "material_delay"
LABOR_SHORTAGE = "labor_shortage"
PERMIT_DELAY = "permit_delay"
OTHER = "other"
@dataclass
class DelayEvent:
delay_id: str
activity_id: str
activity_name: str
delay_type: DelayType
cause: DelayCause
start_date: date
end_date: date
delay_days: int
on_critical_path: bool
description: str
documentation: List[str] = field(default_factory=list)
cost_impact: float = 0.0
@dataclass
class ScheduleBaseline:
baseline_date: date
planned_completion: date
activities: Dict[str, Dict[str, date]] # activity_id: {start, end}
class ScheduleDelayAnalyzer:
def __init__(self, project_name: str, contract_completion: date):
self.project_name = project_name
self.contract_completion = contract_completion
self.baselines: List[ScheduleBaseline] = []
self.delays: Dict[str, DelayEvent] = {}
self._counter = 0
def add_baseline(self, baseline_date: date, planned_completion: date,
activities: Dict[str, Dict[str, date]]):
baseline = ScheduleBaseline(baseline_date, planned_completion, activities)
self.baselines.append(baseline)
def record_delay(self, activity_id: str, activity_name: str,
delay_type: DelayType, cause: DelayCause,
start_date: date, end_date: date,
on_critical_path: bool, description: str,
cost_impact: float = 0) -> DelayEvent:
self._counter += 1
delay_id = f"DLY-{self._counter:04d}"
delay = DelayEvent(
delay_id=delay_id,
activity_id=activity_id,
activity_name=activity_name,
delay_type=delay_type,
cause=cause,
start_date=start_date,
end_date=end_date,
delay_days=(end_date - start_date).days,
on_critical_path=on_critical_path,
description=description,
cost_impact=cost_impact
)
self.delays[delay_id] = delay
return delay
def calculate_project_delay(self) -> int:
"""Calculate total critical path delay."""
critical_delays = [d for d in self.delays.values() if d.on_critical_path]
return sum(d.delay_days for d in critical_delays)
def analyze_by_type(self) -> Dict[str, Dict[str, Any]]:
analysis = {}
for delay in self.delays.values():
dtype = delay.delay_type.value
if dtype not in analysis:
analysis[dtype] = {'count': 0, 'days': 0, 'cost': 0}
analysis[dtype]['count'] += 1
analysis[dtype]['days'] += delay.delay_days
analysis[dtype]['cost'] += delay.cost_impact
return analysis
def analyze_by_cause(self) -> Dict[str, int]:
by_cause = {}
for delay in self.delays.values():
cause = delay.cause.value
by_cause[cause] = by_cause.get(cause, 0) + delay.delay_days
return by_cause
def calculate_time_extension_claim(self) -> Dict[str, Any]:
"""Calculate basis for time extension claim."""
excusable = [d for d in self.delays.values()
if d.delay_type in [DelayType.EXCUSABLE_COMPENSABLE,
DelayType.EXCUSABLE_NON_COMPENSABLE]
and d.on_critical_path]
compensable = [d for d in excusable
if d.delay_type == DelayType.EXCUSABLE_COMPENSABLE]
return {
'excusable_delays': len(excusable),
'excusable_days': sum(d.delay_days for d in excusable),
'compensable_delays': len(compensable),
'compensable_days': sum(d.delay_days for d in compensable),
'total_cost_impact': sum(d.cost_impact for d in compensable),
'recommended_extension': sum(d.delay_days for d in excusable)
}
def get_summary(self) -> Dict[str, Any]:
critical_delay = self.calculate_project_delay()
projected_completion = self.contract_completion + timedelta(days=critical_delay)
return {
'project': self.project_name,
'contract_completion': self.contract_completion,
'projected_completion': projected_completion,
'total_delays': len(self.delays),
'critical_path_delays': sum(1 for d in self.delays.values() if d.on_critical_path),
'total_delay_days': critical_delay,
'by_type': self.analyze_by_type(),
'by_cause': self.analyze_by_cause()
}
def export_analysis(self, output_path: str):
data = [{
'ID': d.delay_id,
'Activity': d.activity_name,
'Type': d.delay_type.value,
'Cause': d.cause.value,
'Start': d.start_date,
'End': d.end_date,
'Days': d.delay_days,
'Critical': d.on_critical_path,
'Cost Impact': d.cost_impact,
'Description': d.description
} for d in self.delays.values()]
pd.DataFrame(data).to_excel(output_path, index=False)
```
## Quick Start
```python
analyzer = ScheduleDelayAnalyzer("Office Tower", date(2024, 12, 31))
delay = analyzer.record_delay(
activity_id="A-300",
activity_name="Foundation Work",
delay_type=DelayType.EXCUSABLE_COMPENSABLE,
cause=DelayCause.OWNER_CHANGE,
start_date=date(2024, 3, 1),
end_date=date(2024, 3, 15),
on_critical_path=True,
description="Owner requested additional scope",
cost_impact=50000
)
summary = analyzer.get_summary()
print(f"Project delayed by {summary['total_delay_days']} days")
claim = analyzer.calculate_time_extension_claim()
print(f"Recommended extension: {claim['recommended_extension']} days")
```
## Resources
- **DDC Book**: Chapter 3.3 - Schedule Management
© datadrivenconstruction · MIT · datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction