cwicr-overhead-markup — Claude Code skill: add markups to estimates
cwicr-overhead-markup applies overhead, profit, and insurance markups to direct construction costs. Calculates full contract price from CWICR estimates with configurable rates for each markup type.
MIT 116 installs ★ 434 updated 2026-10-19
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill cwicr-overhead-markup -a claude-codeWhat cwicr-overhead-markup does
Takes direct costs and layers on general overhead, profit margin, insurance, bonds, and contingency. Supports three calculation methods: markup on direct cost, markup on cumulative cost, or fixed amounts. Built-in templates for residential, commercial, industrial, and government projects, each with its own rate structure.
Works with Python, pandas, and dataclasses. Breaks down markups as separate line items, computes total markup percentage, and returns the full pricing: cost by category (labour, materials, equipment, subcontract), all markups with amounts, and final price. Requires Python 3.
What it helps with
- calculate final contract price from direct cost estimates
- apply standard overhead and profit coefficients to construction work
- break down markups by type: overhead, profit, insurance, bonds, contingency
- compare bids with different markup structures side by side
Example prompts for the agent
- Add overhead 10%, profit 10%, and insurance 5% to the estimate
- Apply the commercial template with bonds and general conditions rates
- Show me the markup breakdown: how much is overhead, how much is profit
How to install cwicr-overhead-markup
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill cwicr-overhead-markup -a claude-code2Manually: put the files in place
~/.claude/skills/cwicr-overhead-markup/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/cwicr-overhead-markup/
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill cwicr-overhead-markup -a codex2Manually: put the files in place
.agents/skills/cwicr-overhead-markup/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill cwicr-overhead-markup -a cursor2Manually: put the files in place
.cursor/skills/cwicr-overhead-markup/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-overhead-markup2Manually: put the files in place
.github/skills/cwicr-overhead-markup/SKILL.md1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill cwicr-overhead-markup -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-overhead-markupManually: put the files in place
.devin/skills/cwicr-overhead-markup/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill cwicr-overhead-markup -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-overhead-markup
How do I install cwicr-overhead-markup in Claude Code?
Run npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill cwicr-overhead-markup -a claude-code, then check the skill config at ~/.claude/skills/cwicr-overhead-markup/SKILL.md.
What does cwicr-overhead-markup do?
Takes a direct cost total and layers on configurable markups for overhead, profit, insurance, bonds, and other indirect costs. Returns a full pricing breakdown with each markup line item and the final selling price.
What markup templates are included?
Residential, commercial, industrial, government contract, and subcontractor templates. Each defines rates for overhead, profit, insurance, bonds, and contingency suited to that project type.
Source text
SKILL.md · MIT
---
name: "cwicr-overhead-markup"
description: "Apply overhead, profit, and markup to CWICR estimates. Calculate indirect costs, general conditions, and contractor margins."
homepage: "https://datadrivenconstruction.io"
metadata: {"openclaw": {"emoji": "🗄️", "os": ["darwin", "linux", "win32"], "homepage": "https://datadrivenconstruction.io", "requires": {"bins": ["python3"]}}}
---
# CWICR Overhead & Markup Calculator
## Business Case
### Problem Statement
Direct costs need additional markups:
- General overhead (office, insurance)
- Project overhead (site costs)
- Profit margins
- Bonds and insurance
### Solution
Systematic markup application to CWICR direct costs with configurable rates for overhead, profit, bonds, and other indirect costs.
### Business Value
- **Complete pricing** - From cost to selling price
- **Configurable rates** - By project/client type
- **Transparency** - Clear markup breakdown
- **Consistency** - Standard markup application
## Technical Implementation
```python
import pandas as pd
from typing import Dict, Any, List, Optional
from dataclasses import dataclass, field
from enum import Enum
class MarkupType(Enum):
"""Types of markup."""
OVERHEAD = "overhead"
PROFIT = "profit"
BOND = "bond"
INSURANCE = "insurance"
CONTINGENCY = "contingency"
TAX = "tax"
ESCALATION = "escalation"
CUSTOM = "custom"
class MarkupMethod(Enum):
"""Markup calculation methods."""
ON_COST = "on_cost" # Markup on direct cost
ON_COST_PLUS = "on_cost_plus" # Markup on cost + previous markups
FIXED = "fixed" # Fixed amount
@dataclass
class MarkupItem:
"""Single markup item."""
name: str
markup_type: MarkupType
rate: float
method: MarkupMethod
base_amount: float
markup_amount: float
@dataclass
class MarkupSchedule:
"""Complete markup schedule."""
name: str
markups: List[MarkupItem]
def get_total_rate(self) -> float:
"""Get combined markup rate."""
return sum(m.rate for m in self.markups)
@dataclass
class PricingResult:
"""Complete pricing with all markups."""
direct_cost: float
labor_cost: float
material_cost: float
equipment_cost: float
subcontractor_cost: float
markups: List[MarkupItem]
total_markup: float
total_price: float
markup_percentage: float
# Standard markup templates
MARKUP_TEMPLATES = {
'residential': {
'overhead': 0.10,
'profit': 0.10,
'contingency': 0.05
},
'commercial': {
'overhead': 0.12,
'profit': 0.08,
'bond': 0.015,
'insurance': 0.02,
'contingency': 0.05
},
'industrial': {
'overhead': 0.15,
'profit': 0.08,
'bond': 0.02,
'insurance': 0.025,
'contingency': 0.08
},
'government': {
'overhead': 0.12,
'profit': 0.06,
'bond': 0.025,
'contingency': 0.05
},
'subcontractor': {
'overhead': 0.08,
'profit': 0.10
}
}
class CWICROverheadMarkup:
"""Apply overhead and markup to CWICR estimates."""
def __init__(self, cwicr_data: pd.DataFrame = None):
self.cost_data = cwicr_data
if cwicr_data is not None:
self._index_data()
def _index_data(self):
"""Index cost data."""
if 'work_item_code' in self.cost_data.columns:
self._code_index = self.cost_data.set_index('work_item_code')
else:
self._code_index = None
def get_template(self, template_name: str) -> Dict[str, float]:
"""Get markup template."""
return MARKUP_TEMPLATES.get(template_name, MARKUP_TEMPLATES['commercial'])
def create_markup_schedule(self,
name: str,
markups: Dict[str, float],
method: MarkupMethod = MarkupMethod.ON_COST) -> MarkupSchedule:
"""Create markup schedule from rates."""
items = []
for markup_name, rate in markups.items():
markup_type = MarkupType.CUSTOM
for mt in MarkupType:
if mt.value in markup_name.lower():
markup_type = mt
break
items.append(MarkupItem(
name=markup_name,
markup_type=markup_type,
rate=rate,
method=method,
base_amount=0,
markup_amount=0
))
return MarkupSchedule(name=name, markups=items)
def apply_markups(self,
direct_cost: float,
schedule: MarkupSchedule,
cost_breakdown: Dict[str, float] = None) -> PricingResult:
"""Apply markup schedule to direct cost."""
if cost_breakdown is None:
cost_breakdown = {
'labor': direct_cost * 0.40,
'material': direct_cost * 0.45,
'equipment': direct_cost * 0.10,
'subcontractor': direct_cost * 0.05
}
markup_items = []
running_total = direct_cost
for markup in schedule.markups:
if markup.method == MarkupMethod.ON_COST:
base = direct_cost
elif markup.method == MarkupMethod.ON_COST_PLUS:
base = running_total
else: # FIXED
base = 1
amount = base * markup.rate
markup_items.append(MarkupItem(
name=markup.name,
markup_type=markup.markup_type,
rate=markup.rate,
method=markup.method,
base_amount=round(base, 2),
markup_amount=round(amount, 2)
))
running_total += amount
total_markup = running_total - direct_cost
markup_pct = (total_markup / direct_cost * 100) if direct_cost > 0 else 0
return PricingResult(
direct_cost=round(direct_cost, 2),
labor_cost=round(cost_breakdown.get('labor', 0), 2),
material_cost=round(cost_breakdown.get('material', 0), 2),
equipment_cost=round(cost_breakdown.get('equipment', 0), 2),
subcontractor_cost=round(cost_breakdown.get('subcontractor', 0), 2),
markups=markup_items,
total_markup=round(total_markup, 2),
total_price=round(running_total, 2),
markup_percentage=round(markup_pct, 1)
)
def price_estimate(self,
items: List[Dict[str, Any]],
template: str = 'commercial') -> PricingResult:
"""Price complete estimate with markups."""
# Calculate direct costs
labor = 0
material = 0
equipment = 0
subcontractor = 0
for item in items:
code = item.get('work_item_code', item.get('code'))
qty = item.get('quantity', 0)
if self._code_index is not None and code in self._code_index.index:
wi = self._code_index.loc[code]
labor += float(wi.get('labor_cost', 0) or 0) * qty
material += float(wi.get('material_cost', 0) or 0) * qty
equipment += float(wi.get('equipment_cost', 0) or 0) * qty
subcontractor += item.get('subcontractor_cost', 0)
direct_cost = labor + material + equipment + subcontractor
cost_breakdown = {
'labor': labor,
'material': material,
'equipment': equipment,
'subcontractor': subcontractor
}
# Get template and create schedule
rates = self.get_template(template)
schedule = self.create_markup_schedule(template, rates)
return self.apply_markups(direct_cost, schedule, cost_breakdown)
def calculate_bid_price(self,
direct_cost: float,
overhead_rate: float = 0.12,
profit_rate: float = 0.08,
bond_rate: float = 0.015,
contingency_rate: float = 0.05) -> Dict[str, Any]:
"""Calculate bid price with standard markups."""
overhead = direct_cost * overhead_rate
subtotal1 = direct_cost + overhead
profit = subtotal1 * profit_rate
subtotal2 = subtotal1 + profit
bond = subtotal2 * bond_rate
subtotal3 = subtotal2 + bond
contingency = direct_cost * contingency_rate
total = subtotal3 + contingency
return {
'direct_cost': round(direct_cost, 2),
'overhead': round(overhead, 2),
'overhead_rate': f"{overhead_rate:.1%}",
'profit': round(profit, 2),
'profit_rate': f"{profit_rate:.1%}",
'bond': round(bond, 2),
'bond_rate': f"{bond_rate:.1%}",
'contingency': round(contingency, 2),
'contingency_rate': f"{contingency_rate:.1%}",
'bid_price': round(total, 2),
'total_markup': round(total - direct_cost, 2),
'total_markup_pct': round((total - direct_cost) / direct_cost * 100, 1)
}
def compare_markup_scenarios(self,
direct_cost: float,
scenarios: Dict[str, Dict[str, float]]) -> pd.DataFrame:
"""Compare different markup scenarios."""
results = []
for name, rates in scenarios.items():
schedule = self.create_markup_schedule(name, rates)
pricing = self.apply_markups(direct_cost, schedule)
results.append({
'Scenario': name,
'Direct Cost': pricing.direct_cost,
'Total Markup': pricing.total_markup,
'Markup %': pricing.markup_percentage,
'Total Price': pricing.total_price
})
return pd.DataFrame(results)
def export_pricing(self,
result: PricingResult,
output_path: str) -> str:
"""Export pricing breakdown to Excel."""
with pd.ExcelWriter(output_path, engine='openpyxl') as writer:
# Summary
summary_df = pd.DataFrame([{
'Direct Cost': result.direct_cost,
'Labor': result.labor_cost,
'Material': result.material_cost,
'Equipment': result.equipment_cost,
'Subcontractor': result.subcontractor_cost,
'Total Markup': result.total_markup,
'Markup %': result.markup_percentage,
'Total Price': result.total_price
}])
summary_df.to_excel(writer, sheet_name='Summary', index=False)
# Markup Details
markup_df = pd.DataFrame([
{
'Markup': m.name,
'Type': m.markup_type.value,
'Rate': f"{m.rate:.1%}",
'Base': m.base_amount,
'Amount': m.markup_amount
}
for m in result.markups
])
markup_df.to_excel(writer, sheet_name='Markups', index=False)
return output_path
```
## Quick Start
```python
# Initialize markup calculator
markup = CWICROverheadMarkup()
# Calculate bid price
bid = markup.calculate_bid_price(
direct_cost=1000000,
overhead_rate=0.12,
profit_rate=0.08
)
print(f"Direct Cost: ${bid['direct_cost']:,.2f}")
print(f"Bid Price: ${bid['bid_price']:,.2f}")
print(f"Total Markup: {bid['total_markup_pct']}%")
```
## Common Use Cases
### 1. Template-Based Pricing
```python
cwicr = pd.read_parquet("TR_workitems_costs_resources_DDC_CWICR.parquet")
markup = CWICROverheadMarkup(cwicr)
items = [
{'work_item_code': 'CONC-001', 'quantity': 150},
{'work_item_code': 'STRL-002', 'quantity': 25}
]
pricing = markup.price_estimate(items, template='commercial')
print(f"Total Price: ${pricing.total_price:,.2f}")
```
### 2. Compare Scenarios
```python
scenarios = {
'Aggressive': {'overhead': 0.08, 'profit': 0.05},
'Standard': {'overhead': 0.12, 'profit': 0.08},
'Premium': {'overhead': 0.15, 'profit': 0.12}
}
comparison = markup.compare_markup_scenarios(1000000, scenarios)
print(comparison)
```
### 3. Custom Markup Schedule
```python
schedule = markup.create_markup_schedule('Custom', {
'overhead': 0.10,
'profit': 0.08,
'bond': 0.02,
'insurance': 0.015
})
pricing = markup.apply_markups(500000, schedule)
```
## Resources
- **GitHub**: [OpenConstructionEstimate-DDC-CWICR](https://github.com/datadrivenconstruction/OpenConstructionEstimate-DDC-CWICR)
- **DDC Book**: Chapter 3.1 - Cost Markup Methods
© datadrivenconstruction · MIT · datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction