prefab-optimization
Optimize prefabrication and modular construction workflows. Plan module sequencing, factory scheduling, transportation logistics, and on-site assembly for maximum efficiency.
Install / Use
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill prefab-optimizationInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
AutomationSupported Platforms
Our assessment of prefab-optimization
prefab-optimization scores 91/100 on our quality scale, 1111th of 2,771 Automation skills we index (top 41%).
Its SKILL.md is 24 KB long, well organised into 13 sections with 5 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 prefab-optimization 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.
prefab-optimization compared with similar skills
All 4 of these similar skills score higher than prefab-optimization; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| prefab-optimization (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 prefab-optimization?
- Run
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill prefab-optimization. The install tabs above show the steps for each supported agent. - Which AI agents does prefab-optimization 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 prefab-optimization 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 prefab-optimization still maintained?
- The repository was last updated about 3 months ago, so prefab-optimization is actively maintained.
Skill content
View source on GitHubname: "prefab-optimization" description: "Optimize prefabrication and modular construction workflows. Plan module sequencing, factory scheduling, transportation logistics, and on-site assembly for maximum efficiency." homepage: "https://datadrivenconstruction.io" metadata: {"openclaw": {"emoji": "🚀", "os": ["darwin", "linux", "win32"], "homepage": "https://datadrivenconstruction.io", "requires": {"bins": ["python3"]}}}
Prefabrication Optimization
Overview
This skill implements optimization algorithms for prefabricated and modular construction. Maximize factory utilization, minimize transportation costs, and optimize on-site assembly sequences.
Optimization Areas:
- Module design for transport
- Factory production scheduling
- Logistics and transportation
- On-site assembly sequencing
- Crane and equipment planning
- Quality control checkpoints
Quick Start
from dataclasses import dataclass, field
from datetime import date, datetime, timedelta
from typing import List, Dict, Tuple, Optional
from enum import Enum
class ModuleStatus(Enum):
DESIGN = "design"
PRODUCTION = "production"
QC = "quality_control"
STORAGE = "storage"
TRANSPORT = "transport"
ON_SITE = "on_site"
INSTALLED = "installed"
@dataclass
class PrefabModule:
module_id: str
name: str
module_type: str
dimensions: Tuple[float, float, float] # L, W, H in meters
weight_kg: float
status: ModuleStatus = ModuleStatus.DESIGN
production_hours: float = 0
dependencies: List[str] = field(default_factory=list)
@dataclass
class ProductionSlot:
slot_id: str
start_time: datetime
end_time: datetime
bay_id: str
module_id: str
def calculate_transport_constraints(module: PrefabModule) -> Dict:
"""Calculate transport constraints for module"""
L, W, H = module.dimensions
# Standard transport limits (varies by region)
max_width = 4.0 # meters
max_height = 4.5 # meters
max_length = 12.0 # meters
max_weight = 40000 # kg
constraints = {
'within_standard': True,
'requires_escort': False,
'requires_permit': False,
'transport_type': 'standard'
}
if W > max_width or H > max_height:
constraints['within_standard'] = False
constraints['requires_escort'] = True
constraints['requires_permit'] = True
constraints['transport_type'] = 'wide_load'
if L > max_length:
constraints['requires_permit'] = True
constraints['transport_type'] = 'long_load'
if module.weight_kg > max_weight:
constraints['requires_permit'] = True
constraints['transport_type'] = 'heavy_load'
return constraints
# Example
module = PrefabModule(
module_id="MOD-001",
name="Bathroom Pod Type A",
module_type="bathroom",
dimensions=(4.5, 3.0, 3.2),
weight_kg=8500,
production_hours=40
)
constraints = calculate_transport_constraints(module)
print(f"Module {module.name}: {constraints}")
Comprehensive Prefab System
Module Definition and Analysis
from dataclasses import dataclass, field
from datetime import date, datetime, timedelta
from typing import List, Dict, Tuple, Optional, Set
from enum import Enum
import numpy as np
class ModuleCategory(Enum):
BATHROOM_POD = "bathroom_pod"
KITCHEN_POD = "kitchen_pod"
STRUCTURAL = "structural"
FACADE = "facade"
MEP = "mep"
STAIR = "stair"
ELEVATOR = "elevator"
ROOM_MODULE = "room_module"
@dataclass
class ModuleConnection:
connection_id: str
connection_type: str # structural, mep, electrical
from_module: str
to_module: str
from_point: Tuple[float, float, float]
to_point: Tuple[float, float, float]
tolerance_mm: float = 10
@dataclass
class ModuleDesign:
module_id: str
name: str
category: ModuleCategory
version: str
# Dimensions and weight
length_m: float
width_m: float
height_m: float
weight_kg: float
# Production
production_hours: float
required_skills: List[str]
materials_list: List[Dict]
# Connections
connections: List[ModuleConnection] = field(default_factory=list)
# Dependencies
required_modules: List[str] = field(default_factory=list) # Must be installed before
blocks_modules: List[str] = field(default_factory=list) # Cannot install until this is done
# Metadata
floor_level: int = 0
grid_position: Tuple[str, str] = ('', '') # Grid reference
zone: str = ''
@property
def volume_m3(self) -> float:
return self.length_m * self.width_m * self.height_m
@property
def footprint_m2(self) -> float:
return self.length_m * self.width_m
class ModuleAnalyzer:
"""Analyze prefab modules for optimization"""
def __init__(self):
self.transport_limits = {
'standard': {'width': 2.55, 'height': 4.0, 'length': 12.0, 'weight': 25000},
'wide_load': {'width': 4.0, 'height': 4.5, 'length': 16.0, 'weight': 40000},
'special': {'width': 6.0, 'height': 5.0, 'length': 25.0, 'weight': 100000}
}
def analyze_transportability(self, module: ModuleDesign) -> Dict:
"""Analyze module transportability"""
dims = (module.length_m, module.width_m, module.height_m)
# Check against limits
for transport_type, limits in self.transport_limits.items():
if (max(dims[0], dims[1]) <= limits['length'] and
min(dims[0], dims[1]) <= limits['width'] and
dims[2] <= limits['height'] and
module.weight_kg <= limits['weight']):
analysis = {
'feasible': True,
'transport_type': transport_type,
'orientation': 'length_first' if dims[0] >= dims[1] else 'width_first',
'utilization': {
'length': max(dims[0], dims[1]) / limits['length'],
'width': min(dims[0], dims[1]) / limits['width'],
'height': dims[2] / limits['height'],
'weight': module.weight_kg / limits['weight']
}
}
if transport_type == 'standard':
analysis['cost_factor'] = 1.0
elif transport_type == 'wide_load':
analysis['cost_factor'] = 1.5
analysis['requirements'] = ['escort_vehicle', 'permit', 'route_survey']
else:
analysis['cost_factor'] = 3.0
analysis['requirements'] = ['police_escort', 'special_permit', 'night_transport']
return analysis
return {
'feasible': False,
'reason': 'Exceeds maximum transport dimensions',
'max_dimension': max(dims),
'recommendation': 'Consider splitting into smaller modules'
}
def analyze_lifting(self, module: ModuleDesign) -> Dict:
"""Analyze lifting requirements"""
# Estimate crane capacity needed (with safety factor)
safety_factor = 1.25
required_capacity = module.weight_kg * safety_factor / 1000 # tonnes
# Estimate boom length based on typical building heights
floor_height = 3.5 # meters per floor
estimated_height = module.floor_level * floor_height + 10 # +10m clearance
# Rough crane selection
if required_capacity <= 50 and estimated_height <= 30:
crane_type = 'mobile_50t'
elif required_capacity <= 100 and estimated_height <= 50:
crane_type = 'mobile_100t'
elif required_capacity <= 200:
crane_type = 'crawler_200t'
else:
crane_type = 'tower_crane'
return {
'required_capacity_tonnes': required_capacity,
'estimated_lift_height_m': estimated_height,
'recommended_crane': crane_type,
'lift_points': self._calculate_lift_points(module),
'center_of_gravity': (module.length_m / 2, module.width_m / 2, module.height_m / 3)
}
def _calculate_lift_points(self, module: ModuleDesign) -> List[Tuple[float, float]]:
"""Calculate optimal lift point positions"""
L, W = module.length_m, module.width_m
# Standard 4-point lift
offset = 0.2 # 20% from edges
return [
(L * offset, W * offset),
(L * (1 - offset), W * offset),
(L * offset, W * (1 - offset)),
(L * (1 - offset), W * (1 - offset))
]
Production Scheduling
from datetime import datetime, timedelta
from typing import List, Dict, Optional
import heapq
@dataclass
class ProductionBay:
bay_id: str
bay_type: str # assembly, finishing, storage
capacity_m2: float
available_from: datetime
skills_available: List[str]
@dataclass
class ProductionOrder:
module_id: str
required_date: date
priority: int # 1 = highest
production_hours: float
required_bay_type: str
required_skills: List[str]
class ProductionScheduler:
"""Schedule prefab module production"""
def __init__(self, work_hours_per_day: float = 8):
self.bays: Dict[str, ProductionBay] = {}
self.schedule: Dict[str, List[ProductionSlot]] = {}
self.work_hours = work_hours_per_day
def add_bay(self, bay: ProductionBay):
"""Add production bay"""
self.bays[bay.bay_id] = bay
self.schedule[bay.bay_id] = []
def schedule_production(self, orders: List[ProductionOrder]) -> Dict:
"""Schedule all production orders"""
# Sort by priority and required date
sorted_orders = sorted(orders, key=lambda o: (o.priority, o.required_date))
scheduled = []
unscheduled = []
for order in sorted_orders:
slot = self._find_best_slot(order)
if slot:
self.schedule[slot.bay_id].append(slot)
scheduled.append({
'module_id': order.module_id,
'bay_id': slot.bay_id,
'start': slot.start_time.isoformat(),
'end': slot.end_time.isoformat(),
'duration_hours': order.production_hours
})
else:
unscheduled.append(order.module_id)
return {
'scheduled': scheduled,
'unscheduled': unscheduled,
'utilization': self._calculate_utilization()
}
def _find_best_slot(self, order: ProductionOrder) -> Optional[ProductionSlot]:
"""Find best production slot for order"""
best_slot = None
best_end_time = datetime.max
for bay_id, bay in self.bays.items():
if bay.bay_type != order.required_bay_type:
continue
if not set(order.required_skills).issubset(set(bay.skills_available)):
continue
# Find earliest available time
existing_slots = self.schedule.get(bay_id, [])
if existing_slots:
last_end = max(s.end_time for s in existing_slots)
start_time = max(bay.available_from, last_end)
else:
start_time = bay.available_from
# Calculate end time
production_days = order.production_hours / self.work_hours
end_time = start_time + timedelta(days=production_days)
# Check if this meets deadline
required_datetime = datetime.combine(order.required_date, datetime.min.time())
if end_time <= required_datetime and end_time < best_end_time:
best_end_time = end_time
best_slot = ProductionSlot(
slot_id=f"SLOT-{bay_id}-{len(existing_slots)}",
start_time=start_time,
end_time=end_time,
bay_id=bay_id,
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.
