change-order-analysis
Analyze and predict construction change orders using ML. Classify change order types, predict costs and schedule impacts, identify patterns, and optimize approval workflows.
Install / Use
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill change-order-analysisInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
AutomationSupported Platforms
Our assessment of change-order-analysis
change-order-analysis scores 91/100 on our quality scale, 1106th of 2,771 Automation skills we index (top 40%).
Its SKILL.md is 21 KB long, well organised into 11 sections with 4 code examples: a thorough specification that gives an agent plenty to work with.
It has 333 GitHub stars, a meaningful sign that others use it.
Maintenance, license and trust
- The repository was last updated about 3 months ago, so change-order-analysis is actively maintained.
- Our last check on 2026-11-20 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-07. Automated pattern scan on 2026-10-07. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
change-order-analysis compared with similar skills
All 4 of these similar skills score higher than change-order-analysis; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| change-order-analysis (this skill)by datadrivenconstruction | 91 | 333 | 3mo ago | SKILL.md |
| Agent-Reachby Panniantong | 100 | 113.3k | 12d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 82.1k | today | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 80.2k | today | CLAUDE.md |
| Claude-Code-Game-Studiosby Donchitos | 100 | 40.2k | 10d ago | CLAUDE.md |
Frequently asked questions
- How do I install change-order-analysis?
- Run
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill change-order-analysis. The install tabs above show the steps for each supported agent. - Which AI agents does change-order-analysis work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is change-order-analysis safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is change-order-analysis still maintained?
- The repository was last updated about 3 months ago, so change-order-analysis is actively maintained.
Skill content
View source on GitHubname: "change-order-analysis" description: "Analyze and predict construction change orders using ML. Classify change order types, predict costs and schedule impacts, identify patterns, and optimize approval workflows." homepage: "https://datadrivenconstruction.io" metadata: {"openclaw": {"emoji": "🚀", "os": ["darwin", "linux", "win32"], "homepage": "https://datadrivenconstruction.io", "requires": {"bins": ["python3"]}}}
Change Order Analysis
Overview
This skill implements machine learning-based change order analysis for construction projects. Predict change order costs, classify types, identify patterns in historical data, and streamline approval processes.
Capabilities:
- Change order classification
- Cost impact prediction
- Schedule impact analysis
- Pattern identification
- Root cause analysis
- Approval workflow optimization
Quick Start
from dataclasses import dataclass, field
from datetime import date, datetime
from typing import List, Dict, Optional
from enum import Enum
class ChangeOrderType(Enum):
DESIGN_CHANGE = "design_change"
OWNER_REQUEST = "owner_request"
FIELD_CONDITION = "field_condition"
CODE_COMPLIANCE = "code_compliance"
VALUE_ENGINEERING = "value_engineering"
ERROR_OMISSION = "error_omission"
SCOPE_CHANGE = "scope_change"
class ChangeOrderStatus(Enum):
DRAFT = "draft"
SUBMITTED = "submitted"
UNDER_REVIEW = "under_review"
APPROVED = "approved"
REJECTED = "rejected"
IMPLEMENTED = "implemented"
@dataclass
class ChangeOrder:
co_number: str
title: str
description: str
co_type: ChangeOrderType
status: ChangeOrderStatus
submitted_date: date
requested_by: str
cost_impact: float
schedule_impact_days: int
affected_elements: List[str] = field(default_factory=list)
def classify_change_order(description: str) -> ChangeOrderType:
"""Simple rule-based classification"""
description_lower = description.lower()
if any(word in description_lower for word in ['design', 'drawing', 'specification']):
return ChangeOrderType.DESIGN_CHANGE
elif any(word in description_lower for word in ['owner', 'client', 'request']):
return ChangeOrderType.OWNER_REQUEST
elif any(word in description_lower for word in ['site', 'field', 'condition', 'unforeseen']):
return ChangeOrderType.FIELD_CONDITION
elif any(word in description_lower for word in ['code', 'regulation', 'compliance']):
return ChangeOrderType.CODE_COMPLIANCE
elif any(word in description_lower for word in ['value', 'alternative', 'savings']):
return ChangeOrderType.VALUE_ENGINEERING
elif any(word in description_lower for word in ['error', 'omission', 'mistake']):
return ChangeOrderType.ERROR_OMISSION
else:
return ChangeOrderType.SCOPE_CHANGE
# Example
co = ChangeOrder(
co_number="CO-001",
title="Additional structural reinforcement",
description="Site conditions revealed weaker soil requiring additional foundation reinforcement",
co_type=classify_change_order("Site conditions revealed weaker soil"),
status=ChangeOrderStatus.SUBMITTED,
submitted_date=date.today(),
requested_by="Site Engineer",
cost_impact=50000,
schedule_impact_days=5
)
print(f"CO Type: {co.co_type.value}")
Comprehensive Change Order System
Change Order Management
from dataclasses import dataclass, field
from datetime import date, datetime, timedelta
from typing import List, Dict, Optional, Tuple
from enum import Enum
import pandas as pd
import numpy as np
class ImpactSeverity(Enum):
MINOR = "minor" # < 1% cost, < 1 week schedule
MODERATE = "moderate" # 1-5% cost, 1-4 weeks schedule
MAJOR = "major" # 5-10% cost, 1-3 months schedule
CRITICAL = "critical" # > 10% cost, > 3 months schedule
@dataclass
class CostBreakdown:
labor: float = 0
materials: float = 0
equipment: float = 0
subcontractor: float = 0
overhead: float = 0
profit: float = 0
@property
def total(self) -> float:
return self.labor + self.materials + self.equipment + self.subcontractor + self.overhead + self.profit
@dataclass
class ScheduleImpact:
direct_days: int
ripple_days: int
critical_path_affected: bool
affected_activities: List[str] = field(default_factory=list)
@property
def total_days(self) -> int:
return self.direct_days + self.ripple_days
@dataclass
class ChangeOrderDetail:
co_id: str
co_number: str
title: str
description: str
justification: str
# Classification
co_type: ChangeOrderType
initiated_by: str # owner, contractor, designer, etc.
responsibility: str # who pays
# Status
status: ChangeOrderStatus
submitted_date: date
approved_date: Optional[date] = None
implemented_date: Optional[date] = None
# Impact
cost_breakdown: CostBreakdown = field(default_factory=CostBreakdown)
schedule_impact: ScheduleImpact = None
severity: ImpactSeverity = ImpactSeverity.MINOR
# Affected scope
affected_elements: List[str] = field(default_factory=list)
affected_drawings: List[str] = field(default_factory=list)
affected_specs: List[str] = field(default_factory=list)
# Supporting documents
attachments: List[str] = field(default_factory=list)
related_rfis: List[str] = field(default_factory=list)
related_cos: List[str] = field(default_factory=list)
# Approval
approvals: List[Dict] = field(default_factory=list)
comments: List[Dict] = field(default_factory=list)
class ChangeOrderManager:
"""Manage project change orders"""
def __init__(self, project_id: str, contract_value: float):
self.project_id = project_id
self.contract_value = contract_value
self.change_orders: Dict[str, ChangeOrderDetail] = {}
self.co_counter = 0
def create_change_order(self, title: str, description: str,
co_type: ChangeOrderType,
initiated_by: str) -> ChangeOrderDetail:
"""Create new change order"""
self.co_counter += 1
co_id = f"CO-{self.project_id}-{self.co_counter:04d}"
co = ChangeOrderDetail(
co_id=co_id,
co_number=f"CO-{self.co_counter:04d}",
title=title,
description=description,
justification="",
co_type=co_type,
initiated_by=initiated_by,
responsibility="TBD",
status=ChangeOrderStatus.DRAFT,
submitted_date=date.today()
)
self.change_orders[co_id] = co
return co
def update_cost(self, co_id: str, cost_breakdown: CostBreakdown):
"""Update change order cost"""
co = self.change_orders.get(co_id)
if co:
co.cost_breakdown = cost_breakdown
co.severity = self._calculate_severity(co)
def update_schedule_impact(self, co_id: str, impact: ScheduleImpact):
"""Update schedule impact"""
co = self.change_orders.get(co_id)
if co:
co.schedule_impact = impact
co.severity = self._calculate_severity(co)
def _calculate_severity(self, co: ChangeOrderDetail) -> ImpactSeverity:
"""Calculate change order severity"""
cost_pct = co.cost_breakdown.total / self.contract_value * 100
schedule_days = co.schedule_impact.total_days if co.schedule_impact else 0
if cost_pct > 10 or schedule_days > 90:
return ImpactSeverity.CRITICAL
elif cost_pct > 5 or schedule_days > 30:
return ImpactSeverity.MAJOR
elif cost_pct > 1 or schedule_days > 7:
return ImpactSeverity.MODERATE
else:
return ImpactSeverity.MINOR
def submit_for_approval(self, co_id: str):
"""Submit change order for approval"""
co = self.change_orders.get(co_id)
if co and co.status == ChangeOrderStatus.DRAFT:
co.status = ChangeOrderStatus.SUBMITTED
co.submitted_date = date.today()
def approve(self, co_id: str, approver: str, comments: str = ""):
"""Approve change order"""
co = self.change_orders.get(co_id)
if co:
co.approvals.append({
'approver': approver,
'action': 'approved',
'date': date.today().isoformat(),
'comments': comments
})
co.status = ChangeOrderStatus.APPROVED
co.approved_date = date.today()
def get_summary(self) -> Dict:
"""Get change order summary"""
if not self.change_orders:
return {'message': 'No change orders'}
total_cost = sum(co.cost_breakdown.total for co in self.change_orders.values())
total_schedule = sum(
co.schedule_impact.total_days if co.schedule_impact else 0
for co in self.change_orders.values()
)
by_type = {}
by_status = {}
by_severity = {}
for co in self.change_orders.values():
t = co.co_type.value
by_type[t] = by_type.get(t, 0) + co.cost_breakdown.total
s = co.status.value
by_status[s] = by_status.get(s, 0) + 1
sev = co.severity.value
by_severity[sev] = by_severity.get(sev, 0) + 1
return {
'total_change_orders': len(self.change_orders),
'total_cost_impact': total_cost,
'cost_impact_pct': total_cost / self.contract_value * 100,
'total_schedule_impact_days': total_schedule,
'by_type': by_type,
'by_status': by_status,
'by_severity': by_severity
}
ML Classification and Prediction
from sklearn.ensemble import RandomForestClassifier, GradientBoostingRegressor
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
import pandas as pd
import numpy as np
import joblib
class ChangeOrderPredictor:
"""ML-based change order classification and cost prediction"""
def __init__(self):
self.type_classifier = None
self.cost_predictor = None
self.schedule_predictor = None
self.vectorizer = TfidfVectorizer(max_features=500, ngram_range=(1, 2))
self.type_encoder = LabelEncoder()
self.is_trained = False
def train(self, historical_data: pd.DataFrame):
"""Train models on historical change order data
Expected columns:
- description: text description
- co_type: change order type
- cost_impact: cost in dollars
- schedule_impact: days of delay
- contract_value: original contract value
- project_phase: phase when CO was raised
- affected_elements_count: number of affected elements
"""
# Prepare text features
text_features = self.vectorizer.fit_transform(historical_data['description'])
# Prepare numeric features
numeric_features = historical_data[[
'contract_value', 'affected_elements_count'
]].values
# Combine features
X = np.hstack([text_features.toarray(), numeric_features])
# Train type classifier
y_type = self.type_encoder.fit_transform(historical_data['co_type'])
X_train, X_test, y_train, y_test = train_test_split(X, y_type, test_size=0.2)
self.type_classifier = RandomForestClassifier(n_estimators=100, random_state=42)
self.type_classifier.fit(X_train, y_train)
type_accuracy = self.type_classifier.score(X_test, y_test)
# Train cost predictor
y_cost = historical_data['cost_impact'].values
self.cost_predictor = GradientBoostingRegressor(n_estimators=100, random_state=42)
self.cost_predictor.fit(X, y_cost)
# Train schedule predict
Truncated for display — read the full file on GitHub.
Related Skills
Agent-Reach
113.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
ruflo
82.1k🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
headroom
80.2kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Claude-Code-Game-Studios
40.2kTurn Claude Code into a full game dev studio — 49 AI agents, 75 workflow skills, and a complete coordination system mirroring real studio hierarchy.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
