bim-classification-ai — Claude Code skill: setup and features
bim-classification-ai assigns standard classification codes to BIM elements using AI heuristics. Useful when preparing model data for cost estimation and quantity takeoff.
MIT 120 installs ★ 434 updated 2026-10-19
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill bim-classification-ai -a claude-codeWhat bim-classification-ai does
This skill matches BIM element properties to construction classification standards. It covers UniFormat, MasterFormat, OmniClass, UniClass, and CWICR codes. The logic evaluates element names and categories, returning suggested classification codes along with confidence scores.
Under the hood, a Python ClassificationDatabase class handles keyword matching against predefined code hierarchies. It maps building parts like foundations or exterior walls to their standard entries. The system also supports manual code overrides.
Running the code requires python3 installed on your machine along with pandas. The metadata marks win32 as the supported operating system.
What it helps with
- assign classification codes to unlabelled BIM elements
- map structural and MEP items to MasterFormat divisions
- prepare model parameters for automated quantity takeoff
- standardize inconsistent naming across building models
Example prompts for the agent
- Find the right UniFormat code for a cast-in-place concrete foundation
- Map structural steel columns to MasterFormat codes
- Suggest OmniClass categories for mechanical piping and ductwork
How to install bim-classification-ai
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill bim-classification-ai -a claude-code2Manually: put the files in place
~/.claude/skills/bim-classification-ai/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/bim-classification-ai/
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill bim-classification-ai -a codex2Manually: put the files in place
.agents/skills/bim-classification-ai/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill bim-classification-ai -a cursor2Manually: put the files in place
.cursor/skills/bim-classification-ai/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/BIM-Analysis/bim-classification-ai2Manually: put the files in place
.github/skills/bim-classification-ai/SKILL.md1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill bim-classification-ai -a gemini-cli2Platform CLI
gemini skills install https://github.com/datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --path 1_DDC_Toolkit/BIM-Analysis/bim-classification-aiManually: put the files in place
.devin/skills/bim-classification-ai/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill bim-classification-ai -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 bim-classification-ai
How to install bim-classification-ai in Claude Code?
Run npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill bim-classification-ai -a claude-code. The command configures the skill and places it into ~/.claude/skills/.
Which classification standards are included?
It includes UniFormat II, MasterFormat, OmniClass, UniClass, and CWICR. The database evaluates element names and keywords against hierarchical code records.
What are the runtime requirements for bim-classification-ai?
You need python3 in your environment and the pandas library. Repository metadata specifies Windows (win32) support.
Source text
SKILL.md · MIT
---
name: "bim-classification-ai"
description: "Classify BIM elements using AI and standard classification systems. Map elements to UniFormat, MasterFormat, OmniClass, and CWICR codes."
homepage: "https://datadrivenconstruction.io"
metadata: {"openclaw": {"emoji": "🔍", "os": ["win32"], "homepage": "https://datadrivenconstruction.io", "requires": {"bins": ["python3"]}}}
---
# BIM Classification AI
## Business Case
### Problem Statement
BIM models often lack proper classification:
- Elements without classification codes
- Inconsistent naming conventions
- Manual classification is tedious
- Difficult to map to cost databases
### Solution
AI-powered classification system that analyzes BIM element properties and suggests appropriate classification codes from multiple standards.
### Business Value
- **Automation** - Reduce manual classification effort
- **Consistency** - Standardized classification across projects
- **Integration** - Enable cost estimation and QTO
- **Quality** - Improved data quality in BIM models
## Technical Implementation
```python
import pandas as pd
from typing import Dict, Any, List, Optional, Tuple
from dataclasses import dataclass, field
from enum import Enum
import re
class ClassificationSystem(Enum):
"""Classification standards."""
UNIFORMAT = "uniformat"
MASTERFORMAT = "masterformat"
OMNICLASS = "omniclass"
UNICLASS = "uniclass"
CWICR = "cwicr"
@dataclass
class ClassificationCode:
"""Classification code with metadata."""
code: str
title: str
system: ClassificationSystem
level: int
parent_code: Optional[str] = None
keywords: List[str] = field(default_factory=list)
@dataclass
class ClassificationResult:
"""Result of classification attempt."""
element_id: str
element_name: str
element_category: str
suggested_codes: List[Tuple[ClassificationCode, float]] # (code, confidence)
selected_code: Optional[ClassificationCode] = None
manual_override: bool = False
class ClassificationDatabase:
"""Classification codes database."""
def __init__(self):
self.codes: Dict[ClassificationSystem, List[ClassificationCode]] = {
system: [] for system in ClassificationSystem
}
self._load_standard_codes()
def _load_standard_codes(self):
"""Load standard classification codes."""
# UniFormat II codes
uniformat_codes = [
("A", "Substructure", 1, None, ["foundation", "basement", "excavation"]),
("A10", "Foundations", 2, "A", ["footing", "pile", "foundation"]),
("A1010", "Standard Foundations", 3, "A10", ["spread footing", "strip footing"]),
("A1020", "Special Foundations", 3, "A10", ["pile", "caisson", "mat foundation"]),
("B", "Shell", 1, None, ["superstructure", "exterior", "roof"]),
("B10", "Superstructure", 2, "B", ["floor", "roof", "structure"]),
("B1010", "Floor Construction", 3, "B10", ["slab", "deck", "floor"]),
("B1020", "Roof Construction", 3, "B10", ["roof", "deck", "truss"]),
("B20", "Exterior Enclosure", 2, "B", ["wall", "window", "door"]),
("B2010", "Exterior Walls", 3, "B20", ["curtain wall", "masonry", "cladding"]),
("B2020", "Exterior Windows", 3, "B20", ["window", "glazing", "storefront"]),
("B30", "Roofing", 2, "B", ["roof", "membrane", "insulation"]),
("C", "Interiors", 1, None, ["partition", "ceiling", "floor finish"]),
("C10", "Interior Construction", 2, "C", ["partition", "door", "glazing"]),
("C20", "Stairs", 2, "C", ["stair", "railing", "ladder"]),
("C30", "Interior Finishes", 2, "C", ["finish", "paint", "flooring"]),
("D", "Services", 1, None, ["mechanical", "electrical", "plumbing"]),
("D10", "Conveying", 2, "D", ["elevator", "escalator", "lift"]),
("D20", "Plumbing", 2, "D", ["pipe", "fixture", "drain"]),
("D30", "HVAC", 2, "D", ["duct", "hvac", "air handling"]),
("D40", "Fire Protection", 2, "D", ["sprinkler", "fire", "suppression"]),
("D50", "Electrical", 2, "D", ["electrical", "power", "lighting"]),
]
for code, title, level, parent, keywords in uniformat_codes:
self.codes[ClassificationSystem.UNIFORMAT].append(
ClassificationCode(code, title, ClassificationSystem.UNIFORMAT, level, parent, keywords)
)
# MasterFormat codes (simplified)
masterformat_codes = [
("03", "Concrete", 1, None, ["concrete", "formwork", "reinforcing"]),
("03 30 00", "Cast-in-Place Concrete", 2, "03", ["concrete", "pour", "slab"]),
("03 41 00", "Precast Structural Concrete", 2, "03", ["precast", "concrete", "panel"]),
("04", "Masonry", 1, None, ["brick", "block", "stone"]),
("05", "Metals", 1, None, ["steel", "metal", "aluminum"]),
("05 12 00", "Structural Steel Framing", 2, "05", ["beam", "column", "steel"]),
("06", "Wood, Plastics, Composites", 1, None, ["wood", "timber", "lumber"]),
("07", "Thermal and Moisture Protection", 1, None, ["insulation", "roofing", "waterproofing"]),
("08", "Openings", 1, None, ["door", "window", "glazing"]),
("09", "Finishes", 1, None, ["drywall", "paint", "flooring"]),
("21", "Fire Suppression", 1, None, ["sprinkler", "fire", "suppression"]),
("22", "Plumbing", 1, None, ["pipe", "fixture", "plumbing"]),
("23", "HVAC", 1, None, ["hvac", "duct", "mechanical"]),
("26", "Electrical", 1, None, ["electrical", "power", "lighting"]),
]
for code, title, level, parent, keywords in masterformat_codes:
self.codes[ClassificationSystem.MASTERFORMAT].append(
ClassificationCode(code, title, ClassificationSystem.MASTERFORMAT, level, parent, keywords)
)
def search(self, query: str, system: ClassificationSystem = None) -> List[ClassificationCode]:
"""Search classification codes by keyword."""
results = []
query_lower = query.lower()
systems = [system] if system else list(ClassificationSystem)
for sys in systems:
for code in self.codes.get(sys, []):
# Check title
if query_lower in code.title.lower():
results.append(code)
continue
# Check keywords
if any(query_lower in kw.lower() for kw in code.keywords):
results.append(code)
return results
class BIMClassificationAI:
"""AI-powered BIM element classification."""
def __init__(self, classification_db: ClassificationDatabase = None):
self.db = classification_db or ClassificationDatabase()
self.category_mappings = self._load_category_mappings()
self.results: List[ClassificationResult] = []
def _load_category_mappings(self) -> Dict[str, List[str]]:
"""Load Revit/IFC category to classification mappings."""
return {
# Structural
"Structural Columns": ["B10", "05 12 00", "column", "structural"],
"Structural Framing": ["B10", "05 12 00", "beam", "framing"],
"Structural Foundations": ["A10", "03 30 00", "foundation", "footing"],
"Floors": ["B1010", "03 30 00", "floor", "slab"],
# Architectural
"Walls": ["B20", "04", "wall", "partition"],
"Curtain Walls": ["B2010", "08 44 00", "curtain wall", "glazing"],
"Windows": ["B2020", "08 50 00", "window", "glazing"],
"Doors": ["C10", "08 10 00", "door", "opening"],
"Roofs": ["B30", "07 50 00", "roof", "roofing"],
"Ceilings": ["C30", "09 51 00", "ceiling", "finish"],
"Stairs": ["C20", "05 51 00", "stair", "railing"],
# MEP
"Ducts": ["D30", "23 31 00", "duct", "hvac"],
"Pipes": ["D20", "22 11 00", "pipe", "plumbing"],
"Electrical Equipment": ["D50", "26 20 00", "electrical", "panel"],
"Lighting Fixtures": ["D50", "26 51 00", "light", "fixture"],
"Sprinklers": ["D40", "21 13 00", "sprinkler", "fire protection"],
"Mechanical Equipment": ["D30", "23 70 00", "ahu", "hvac equipment"],
}
def classify_element(self,
element_id: str,
element_name: str,
category: str,
properties: Dict[str, Any] = None,
target_systems: List[ClassificationSystem] = None) -> ClassificationResult:
"""Classify a single BIM element."""
target_systems = target_systems or [ClassificationSystem.UNIFORMAT, ClassificationSystem.MASTERFORMAT]
suggestions = []
# Get keywords from category mapping
keywords = self.category_mappings.get(category, [])
# Add keywords from element name
name_words = re.findall(r'\w+', element_name.lower())
keywords.extend(name_words)
# Add keywords from properties
if properties:
for key, value in properties.items():
if isinstance(value, str):
keywords.extend(re.findall(r'\w+', value.lower()))
# Search classification codes
for system in target_systems:
for keyword in keywords:
matches = self.db.search(keyword, system)
for match in matches:
confidence = self._calculate_confidence(match, keywords, category)
suggestions.append((match, confidence))
# Remove duplicates and sort by confidence
seen = set()
unique_suggestions = []
for code, conf in sorted(suggestions, key=lambda x: x[1], reverse=True):
if code.code not in seen:
seen.add(code.code)
unique_suggestions.append((code, conf))
result = ClassificationResult(
element_id=element_id,
element_name=element_name,
element_category=category,
suggested_codes=unique_suggestions[:5],
selected_code=unique_suggestions[0][0] if unique_suggestions else None
)
self.results.append(result)
return result
def _calculate_confidence(self, code: ClassificationCode,
keywords: List[str], category: str) -> float:
"""Calculate classification confidence score."""
score = 0.0
# Direct category match
if category in self.category_mappings:
if code.code in self.category_mappings[category]:
score += 0.5
# Keyword matches
keyword_matches = sum(1 for kw in keywords if kw.lower() in
[k.lower() for k in code.keywords])
score += min(keyword_matches * 0.1, 0.3)
# Title match
title_words = code.title.lower().split()
title_matches = sum(1 for kw in keywords if kw.lower() in title_words)
score += min(title_matches * 0.1, 0.2)
return min(score, 1.0)
def classify_batch(self, elements_df: pd.DataFrame,
id_column: str = 'element_id',
name_column: str = 'name',
category_column: str = 'category') -> pd.DataFrame:
"""Classify multiple elements from DataFrame."""
results = []
for _, row in elements_df.iterrows():
result = self.classify_element(
element_id=str(row[id_column]),
element_name=str(row[name_column]),
category=str(row[category_column]),
properties=row.to_dict()
)
results.append({
'element_id': result.element_id,
'element_name': result.element_name,
'category': result.element_category,
'uniformat_code': next((c.code for c, _ in result.suggested_codes
if c.system == ClassificationSystem.UNIFORMAT), None),
'masterformat_code': next((c.code for c, _ in result.suggested_codes
if c.system == ClassificationSystem.MASTERFORMAT), None),
'confidence': result.suggested_codes[0][1] if result.suggested_codes else 0
})
return pd.DataFrame(results)
def get_summary(self) -> Dict[str, Any]:
"""Get classification summary."""
total = len(self.results)
classified = sum(1 for r in self.results if r.selected_code)
high_confidence = sum(1 for r in self.results
if r.suggested_codes and r.suggested_codes[0][1] > 0.7)
return {
'total_elements': total,
'classified': classified,
'classification_rate': round(classified / total * 100, 1) if total > 0 else 0,
'high_confidence': high_confidence,
'high_confidence_rate': round(high_confidence / total * 100, 1) if total > 0 else 0
}
def export_results(self) -> pd.DataFrame:
"""Export classification results to DataFrame."""
data = []
for result in self.results:
row = {
'element_id': result.element_id,
'element_name': result.element_name,
'category': result.element_category,
'selected_code': result.selected_code.code if result.selected_code else None,
'selected_title': result.selected_code.title if result.selected_code else None,
'selected_system': result.selected_code.system.value if result.selected_code else None,
'manual_override': result.manual_override
}
# Add top suggestions
for i, (code, conf) in enumerate(result.suggested_codes[:3]):
row[f'suggestion_{i+1}_code'] = code.code
row[f'suggestion_{i+1}_confidence'] = round(conf, 2)
data.append(row)
return pd.DataFrame(data)
```
## Quick Start
```python
# Initialize classifier
classifier = BIMClassificationAI()
# Classify single element
result = classifier.classify_element(
element_id="12345",
element_name="Concrete Floor Slab Level 2",
category="Floors",
properties={'material': 'Concrete', 'thickness': '200mm'}
)
print(f"Suggested: {result.selected_code.code} - {result.selected_code.title}")
print(f"Confidence: {result.suggested_codes[0][1]:.1%}")
```
## Common Use Cases
### 1. Batch Classification
```python
# Load BIM elements
elements = pd.read_excel("bim_elements.xlsx")
# Classify all
classified = classifier.classify_batch(elements)
classified.to_excel("classified_elements.xlsx")
```
### 2. Map to CWICR
```python
# Get UniFormat code for cost mapping
uniformat = result.selected_code.code
cwicr_code = map_uniformat_to_cwicr(uniformat)
```
### 3. Quality Check
```python
summary = classifier.get_summary()
print(f"Classification rate: {summary['classification_rate']}%")
```
## Resources
- **DDC Book**: Chapter 2.5 - Data Standards
- **Reference**: UniFormat II, CSI MasterFormat
© datadrivenconstruction · MIT · datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction