cwicr-waste-calculator — Claude Code skill: waste estimates
cwicr-waste-calculator is a Claude Code skill that estimates material losses using CWICR norms. It responds to requests to account for cutting, spills, breakage, and installation overrun.
MIT 117 installs ★ 434 updated 2026-10-19
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill cwicr-waste-calculator -a claude-codeWhat cwicr-waste-calculator does
cwicr-waste-calculator adds estimated material losses to a base quantity. It identifies a material category from its description, then applies factors for cutting, spillage, breakage, and installation overrun. Other materials use a general set of factors.
The calculation can use CWICR data: the skill looks up a material by code and reads its description, unit, and cost when those fields are available. Its output includes the starting quantity, the quantity with waste, and the waste cost. python3 is required.
What it helps with
- estimate extra material for cutting and breakage
- include spillage in liquid material quantities
- calculate the cost of material losses
- apply waste factors to a CWICR material entry
Example prompts for the agent
- Calculate concrete quantities with extra allowance for cutting and spillage.
- Estimate waste for a material code from the CWICR table.
- Add cutting and breakage losses to the tile quantity.
How to install cwicr-waste-calculator
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill cwicr-waste-calculator -a claude-code2Manually: put the files in place
~/.claude/skills/cwicr-waste-calculator/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/cwicr-waste-calculator/
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill cwicr-waste-calculator -a codex2Manually: put the files in place
.agents/skills/cwicr-waste-calculator/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill cwicr-waste-calculator -a cursor2Manually: put the files in place
.cursor/skills/cwicr-waste-calculator/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/CWICR-Database/cwicr-waste-calculator2Manually: put the files in place
.github/skills/cwicr-waste-calculator/SKILL.md1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill cwicr-waste-calculator -a gemini-cli2Platform CLI
gemini skills install https://github.com/datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --path 1_DDC_Toolkit/CWICR-Database/cwicr-waste-calculatorManually: put the files in place
.devin/skills/cwicr-waste-calculator/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill cwicr-waste-calculator -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 cwicr-waste-calculator
How do I install cwicr-waste-calculator in Claude Code?
Run npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill cwicr-waste-calculator -a claude-code. The skill is installed at ~/.claude/skills/cwicr-waste-calculator/SKILL.md.
What does cwicr-waste-calculator do?
It estimates material waste using factors selected by material type. The calculation covers cutting, spillage, breakage, and installation overrun.
What does cwicr-waste-calculator need to run?
It requires python3. A CWICR materials table can supply material details for the calculation.
Source text
SKILL.md · MIT
---
name: "cwicr-waste-calculator"
description: "Calculate material waste factors and losses using CWICR norms. Apply waste percentages, cutting losses, and spillage factors to material quantities."
homepage: "https://datadrivenconstruction.io"
metadata: {"openclaw": {"emoji": "🗄️", "os": ["darwin", "linux", "win32"], "homepage": "https://datadrivenconstruction.io", "requires": {"bins": ["python3"]}}}
---
# CWICR Waste Calculator
## Business Case
### Problem Statement
Material estimates need waste factors:
- Cutting/trimming losses
- Spillage and breakage
- Overordering requirements
- Different waste by material type
### Solution
Systematic waste calculation using CWICR material data with industry-standard waste factors by material category.
### Business Value
- **Accurate ordering** - Include realistic waste
- **Cost control** - Budget for actual usage
- **Sustainability** - Track and reduce waste
- **Benchmarking** - Compare waste across projects
## Technical Implementation
```python
import pandas as pd
import numpy as np
from typing import Dict, Any, List, Optional
from dataclasses import dataclass
from enum import Enum
class WasteCategory(Enum):
"""Waste category types."""
CUTTING = "cutting" # Cutting/trimming losses
SPILLAGE = "spillage" # Liquid material spillage
BREAKAGE = "breakage" # Damaged materials
OVERRUN = "overrun" # Installation overrun
THEFT = "theft" # Site theft allowance
WEATHER = "weather" # Weather damage
@dataclass
class WasteFactor:
"""Waste factor for a material."""
material_code: str
material_name: str
base_quantity: float
unit: str
cutting_waste_pct: float
spillage_pct: float
breakage_pct: float
overrun_pct: float
total_waste_pct: float
quantity_with_waste: float
waste_quantity: float
waste_cost: float
# Industry standard waste factors by material type
WASTE_FACTORS = {
'concrete': {
'cutting': 0.02, 'spillage': 0.03, 'breakage': 0.0, 'overrun': 0.02
},
'rebar': {
'cutting': 0.05, 'spillage': 0.0, 'breakage': 0.01, 'overrun': 0.02
},
'brick': {
'cutting': 0.05, 'spillage': 0.0, 'breakage': 0.03, 'overrun': 0.02
},
'block': {
'cutting': 0.04, 'spillage': 0.0, 'breakage': 0.02, 'overrun': 0.02
},
'lumber': {
'cutting': 0.10, 'spillage': 0.0, 'breakage': 0.02, 'overrun': 0.03
},
'plywood': {
'cutting': 0.12, 'spillage': 0.0, 'breakage': 0.02, 'overrun': 0.02
},
'drywall': {
'cutting': 0.10, 'spillage': 0.0, 'breakage': 0.03, 'overrun': 0.02
},
'tile': {
'cutting': 0.10, 'spillage': 0.0, 'breakage': 0.05, 'overrun': 0.03
},
'paint': {
'cutting': 0.0, 'spillage': 0.05, 'breakage': 0.0, 'overrun': 0.10
},
'mortar': {
'cutting': 0.0, 'spillage': 0.05, 'breakage': 0.0, 'overrun': 0.03
},
'insulation': {
'cutting': 0.08, 'spillage': 0.0, 'breakage': 0.02, 'overrun': 0.03
},
'roofing': {
'cutting': 0.10, 'spillage': 0.0, 'breakage': 0.02, 'overrun': 0.05
},
'pipe': {
'cutting': 0.05, 'spillage': 0.0, 'breakage': 0.01, 'overrun': 0.02
},
'wire': {
'cutting': 0.03, 'spillage': 0.0, 'breakage': 0.0, 'overrun': 0.05
},
'conduit': {
'cutting': 0.05, 'spillage': 0.0, 'breakage': 0.01, 'overrun': 0.02
},
'duct': {
'cutting': 0.08, 'spillage': 0.0, 'breakage': 0.01, 'overrun': 0.03
},
'steel': {
'cutting': 0.03, 'spillage': 0.0, 'breakage': 0.0, 'overrun': 0.02
},
'glass': {
'cutting': 0.05, 'spillage': 0.0, 'breakage': 0.05, 'overrun': 0.02
},
'flooring': {
'cutting': 0.10, 'spillage': 0.0, 'breakage': 0.02, 'overrun': 0.03
},
'adhesive': {
'cutting': 0.0, 'spillage': 0.08, 'breakage': 0.0, 'overrun': 0.05
},
'default': {
'cutting': 0.05, 'spillage': 0.02, 'breakage': 0.02, 'overrun': 0.03
}
}
class CWICRWasteCalculator:
"""Calculate material waste using CWICR data."""
def __init__(self, cwicr_data: pd.DataFrame):
self.materials = cwicr_data
self._index_data()
def _index_data(self):
"""Index materials data."""
if 'material_code' in self.materials.columns:
self._mat_index = self.materials.set_index('material_code')
elif 'work_item_code' in self.materials.columns:
self._mat_index = self.materials.set_index('work_item_code')
else:
self._mat_index = None
def _detect_material_type(self, description: str) -> str:
"""Detect material type from description."""
desc_lower = str(description).lower()
for mat_type in WASTE_FACTORS.keys():
if mat_type in desc_lower:
return mat_type
# Check common synonyms
synonyms = {
'concrete': ['beton', 'cement'],
'rebar': ['reinforcement', 'armature', 'арматура'],
'brick': ['кирпич', 'block'],
'lumber': ['wood', 'timber', 'древесина'],
'drywall': ['gypsum', 'plasterboard', 'гипсокартон'],
'tile': ['ceramic', 'плитка', 'керамика'],
'paint': ['краска', 'coating'],
'insulation': ['изоляция', 'утеплитель'],
'pipe': ['труба', 'piping'],
'wire': ['провод', 'cable', 'кабель']
}
for mat_type, words in synonyms.items():
if any(word in desc_lower for word in words):
return mat_type
return 'default'
def get_waste_factors(self, material_type: str) -> Dict[str, float]:
"""Get waste factors for material type."""
return WASTE_FACTORS.get(material_type, WASTE_FACTORS['default'])
def calculate_waste(self,
material_code: str,
base_quantity: float,
unit_cost: float = 0,
custom_factors: Dict[str, float] = None) -> WasteFactor:
"""Calculate waste for a material."""
# Get material info
material_name = material_code
unit = "unit"
if self._mat_index is not None and material_code in self._mat_index.index:
mat = self._mat_index.loc[material_code]
material_name = str(mat.get('description', mat.get('material_description', material_code)))
unit = str(mat.get('unit', mat.get('material_unit', 'unit')))
if unit_cost == 0:
unit_cost = float(mat.get('material_cost', mat.get('unit_cost', 0)) or 0)
# Detect material type and get factors
mat_type = self._detect_material_type(material_name)
factors = custom_factors or self.get_waste_factors(mat_type)
cutting = factors.get('cutting', 0)
spillage = factors.get('spillage', 0)
breakage = factors.get('breakage', 0)
overrun = factors.get('overrun', 0)
# Calculate total waste
total_waste_pct = cutting + spillage + breakage + overrun
waste_quantity = base_quantity * total_waste_pct
quantity_with_waste = base_quantity + waste_quantity
waste_cost = waste_quantity * unit_cost
return WasteFactor(
material_code=material_code,
material_name=material_name,
base_quantity=base_quantity,
unit=unit,
cutting_waste_pct=round(cutting * 100, 1),
spillage_pct=round(spillage * 100, 1),
breakage_pct=round(breakage * 100, 1),
overrun_pct=round(overrun * 100, 1),
total_waste_pct=round(total_waste_pct * 100, 1),
quantity_with_waste=round(quantity_with_waste, 2),
waste_quantity=round(waste_quantity, 2),
waste_cost=round(waste_cost, 2)
)
def calculate_project_waste(self,
materials: List[Dict[str, Any]]) -> Dict[str, Any]:
"""Calculate waste for entire project."""
results = []
total_base_cost = 0
total_waste_cost = 0
for mat in materials:
code = mat.get('material_code', mat.get('code'))
qty = mat.get('quantity', 0)
cost = mat.get('unit_cost', 0)
custom = mat.get('waste_factors')
waste = self.calculate_waste(code, qty, cost, custom)
results.append(waste)
total_base_cost += qty * cost
total_waste_cost += waste.waste_cost
# Summary by waste category
by_category = {
'cutting': sum(r.cutting_waste_pct * r.base_quantity / 100 for r in results),
'spillage': sum(r.spillage_pct * r.base_quantity / 100 for r in results),
'breakage': sum(r.breakage_pct * r.base_quantity / 100 for r in results),
'overrun': sum(r.overrun_pct * r.base_quantity / 100 for r in results)
}
return {
'materials': results,
'total_base_cost': round(total_base_cost, 2),
'total_waste_cost': round(total_waste_cost, 2),
'waste_percentage': round(total_waste_cost / total_base_cost * 100, 1) if total_base_cost > 0 else 0,
'by_category': by_category,
'order_quantity_increase': round(sum(r.waste_quantity for r in results), 2)
}
def optimize_cutting(self,
material_code: str,
required_lengths: List[float],
stock_length: float) -> Dict[str, Any]:
"""Optimize cutting to minimize waste (1D cutting stock problem)."""
# Simple first-fit decreasing algorithm
sorted_lengths = sorted(required_lengths, reverse=True)
stock_pieces = []
waste_per_piece = []
for length in sorted_lengths:
placed = False
for i, remaining in enumerate(stock_pieces):
if remaining >= length:
stock_pieces[i] -= length
placed = True
break
if not placed:
stock_pieces.append(stock_length - length)
total_stock_needed = len(stock_pieces)
total_material = total_stock_needed * stock_length
total_used = sum(required_lengths)
total_waste = total_material - total_used
waste_pct = total_waste / total_material * 100 if total_material > 0 else 0
return {
'material_code': material_code,
'stock_pieces_needed': total_stock_needed,
'stock_length': stock_length,
'total_material': round(total_material, 2),
'total_used': round(total_used, 2),
'total_waste': round(total_waste, 2),
'waste_percentage': round(waste_pct, 1),
'cutting_efficiency': round(100 - waste_pct, 1)
}
def export_waste_report(self,
project_waste: Dict[str, Any],
output_path: str) -> str:
"""Export waste report to Excel."""
with pd.ExcelWriter(output_path, engine='openpyxl') as writer:
# Summary
summary_df = pd.DataFrame([{
'Total Base Cost': project_waste['total_base_cost'],
'Total Waste Cost': project_waste['total_waste_cost'],
'Waste Percentage': project_waste['waste_percentage'],
'Order Increase': project_waste['order_quantity_increase']
}])
summary_df.to_excel(writer, sheet_name='Summary', index=False)
# Materials
mat_df = pd.DataFrame([
{
'Material': m.material_name,
'Base Qty': m.base_quantity,
'Unit': m.unit,
'Cutting %': m.cutting_waste_pct,
'Spillage %': m.spillage_pct,
'Breakage %': m.breakage_pct,
'Overrun %': m.overrun_pct,
'Total Waste %': m.total_waste_pct,
'Order Qty': m.quantity_with_waste,
'Waste Cost': m.waste_cost
}
for m in project_waste['materials']
])
mat_df.to_excel(writer, sheet_name='Materials', index=False)
return output_path
```
## Quick Start
```python
# Load CWICR data
cwicr = pd.read_parquet("TR_workitems_costs_resources_DDC_CWICR.parquet")
# Initialize calculator
waste_calc = CWICRWasteCalculator(cwicr)
# Calculate waste for single material
waste = waste_calc.calculate_waste(
material_code="CONC-001",
base_quantity=100,
unit_cost=150
)
print(f"Base Qty: {waste.base_quantity}")
print(f"Order Qty: {waste.quantity_with_waste}")
print(f"Waste: {waste.total_waste_pct}%")
print(f"Waste Cost: ${waste.waste_cost:,.2f}")
```
## Common Use Cases
### 1. Project-Wide Waste
```python
materials = [
{'code': 'CONC-001', 'quantity': 200, 'unit_cost': 150},
{'code': 'REBAR-002', 'quantity': 5000, 'unit_cost': 1.2},
{'code': 'BRICK-003', 'quantity': 10000, 'unit_cost': 0.50}
]
project = waste_calc.calculate_project_waste(materials)
print(f"Total Waste Cost: ${project['total_waste_cost']:,.2f}")
```
### 2. Cutting Optimization
```python
cutting = waste_calc.optimize_cutting(
material_code="REBAR-001",
required_lengths=[2.5, 3.0, 1.8, 2.2, 4.0, 3.5],
stock_length=6.0
)
print(f"Efficiency: {cutting['cutting_efficiency']}%")
```
### 3. Custom Waste Factors
```python
custom_factors = {'cutting': 0.15, 'spillage': 0, 'breakage': 0.05, 'overrun': 0.05}
waste = waste_calc.calculate_waste("TILE-001", 500, 25, custom_factors)
```
## Resources
- **GitHub**: [OpenConstructionEstimate-DDC-CWICR](https://github.com/datadrivenconstruction/OpenConstructionEstimate-DDC-CWICR)
- **DDC Book**: Chapter 3.1 - Material Waste Management
© datadrivenconstruction · MIT · datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction