Skip to main content
skill CX Codex

bim-to-schedule-4d — Claude Code skill for BIM scheduling

bim-to-schedule-4d is a Claude Code skill that links BIM elements to schedule activities and tracks their status by date for 4D construction simulation.

MIT 120 installs ★ 434 updated 2026-10-19

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill bim-to-schedule-4d -a claude-code
Open on GitHub

What bim-to-schedule-4d does

This skill describes a Python class for importing schedule activities and BIM elements, linking them, and checking link coverage. You can create links directly or assign every element on a chosen level to one activity. For a target date, the class returns the linked elements whose activities are in progress.

The summary reports activity, element, and link counts, plus the share of linked elements. Links can also be exported to Excel. The implementation uses pandas, and its metadata lists python3 as a requirement.

Level-based linking takes every element on that level, so check the selection before assigning it to an activity. A link can only be created for an existing activity; if some requested element IDs are missing, the link is marked partial.

What it helps with

  • connect BIM elements to schedule activities
  • find elements or activities without links
  • list elements active on a chosen date
  • export a link summary to Excel

Example prompts for the agent

  • Link the elements on Level 1 to activity A200 and show the link status.
  • Find BIM elements that have no schedule activity linked to them.
  • Create a link summary and export it to Excel.

How to install bim-to-schedule-4d

1Skills CLI (Vercel)

npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill bim-to-schedule-4d -a claude-code

2Manually: put the files in place

~/.claude/skills/bim-to-schedule-4d/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/bim-to-schedule-4d/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about bim-to-schedule-4d

How do I install bim-to-schedule-4d in Claude Code?

Run npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill bim-to-schedule-4d -a claude-code. The skill file is at ~/.claude/skills/bim-to-schedule-4d/SKILL.md.

What does bim-to-schedule-4d do?

It helps connect BIM elements with schedule activities, inspect missing links, and retrieve elements associated with a date. It can export a link summary to Excel.

What is required to export the summary?

The implementation uses pandas for Excel export, and the skill metadata lists python3 as a requirement.

Source text

SKILL.md · MIT
---
name: "bim-to-schedule-4d"
description: "Link BIM elements to schedule activities for 4D simulation. Visualize construction sequence over time."
homepage: "https://datadrivenconstruction.io"
metadata: {"openclaw": {"emoji": "📅", "os": ["darwin", "linux", "win32"], "homepage": "https://datadrivenconstruction.io", "requires": {"bins": ["python3"]}}}
---
# BIM to Schedule 4D Integration

## Technical Implementation

```python
import pandas as pd
from datetime import date, timedelta
from typing import Dict, Any, List, Optional
from dataclasses import dataclass, field
from enum import Enum


class LinkStatus(Enum):
    LINKED = "linked"
    UNLINKED = "unlinked"
    PARTIAL = "partial"


@dataclass
class ScheduleActivity:
    activity_id: str
    activity_name: str
    start_date: date
    end_date: date
    duration_days: int
    wbs_code: str
    predecessors: List[str] = field(default_factory=list)


@dataclass
class BIMElement:
    element_id: str
    element_name: str
    category: str
    level: str
    zone: str
    volume: float = 0
    area: float = 0


@dataclass
class BIMScheduleLink:
    link_id: str
    activity_id: str
    element_ids: List[str]
    link_type: str  # install, remove, temporary
    status: LinkStatus


class BIMSchedule4D:
    def __init__(self, project_name: str):
        self.project_name = project_name
        self.activities: Dict[str, ScheduleActivity] = {}
        self.elements: Dict[str, BIMElement] = {}
        self.links: Dict[str, BIMScheduleLink] = {}
        self._link_counter = 0

    def import_schedule(self, schedule_data: List[Dict[str, Any]]):
        for act in schedule_data:
            activity = ScheduleActivity(
                activity_id=act['id'],
                activity_name=act['name'],
                start_date=act['start'],
                end_date=act['end'],
                duration_days=(act['end'] - act['start']).days,
                wbs_code=act.get('wbs', ''),
                predecessors=act.get('predecessors', [])
            )
            self.activities[activity.activity_id] = activity

    def import_elements(self, element_data: List[Dict[str, Any]]):
        for elem in element_data:
            element = BIMElement(
                element_id=elem['id'],
                element_name=elem['name'],
                category=elem['category'],
                level=elem.get('level', ''),
                zone=elem.get('zone', ''),
                volume=elem.get('volume', 0),
                area=elem.get('area', 0)
            )
            self.elements[element.element_id] = element

    def create_link(self, activity_id: str, element_ids: List[str],
                   link_type: str = "install") -> BIMScheduleLink:
        if activity_id not in self.activities:
            return None

        self._link_counter += 1
        link_id = f"LNK-{self._link_counter:05d}"

        # Verify elements exist
        valid_elements = [eid for eid in element_ids if eid in self.elements]

        status = LinkStatus.LINKED if valid_elements else LinkStatus.UNLINKED
        if valid_elements and len(valid_elements) < len(element_ids):
            status = LinkStatus.PARTIAL

        link = BIMScheduleLink(
            link_id=link_id,
            activity_id=activity_id,
            element_ids=valid_elements,
            link_type=link_type,
            status=status
        )
        self.links[link_id] = link
        return link

    def auto_link_by_level(self, level: str, activity_id: str):
        """Auto-link all elements on a level to an activity."""
        level_elements = [e.element_id for e in self.elements.values()
                        if e.level == level]
        if level_elements:
            return self.create_link(activity_id, level_elements)
        return None

    def get_elements_for_date(self, target_date: date) -> List[BIMElement]:
        """Get elements that should be visible on a specific date."""
        visible_elements = []
        for link in self.links.values():
            activity = self.activities.get(link.activity_id)
            if activity and activity.start_date <= target_date <= activity.end_date:
                for elem_id in link.element_ids:
                    if elem_id in self.elements:
                        visible_elements.append(self.elements[elem_id])
        return visible_elements

    def get_unlinked_elements(self) -> List[BIMElement]:
        linked_ids = set()
        for link in self.links.values():
            linked_ids.update(link.element_ids)
        return [e for e in self.elements.values() if e.element_id not in linked_ids]

    def get_unlinked_activities(self) -> List[ScheduleActivity]:
        linked_activities = {link.activity_id for link in self.links.values()}
        return [a for a in self.activities.values() if a.activity_id not in linked_activities]

    def get_link_summary(self) -> Dict[str, Any]:
        total_elements = len(self.elements)
        linked_elements = len(set(
            eid for link in self.links.values() for eid in link.element_ids
        ))

        return {
            'total_activities': len(self.activities),
            'total_elements': total_elements,
            'linked_elements': linked_elements,
            'unlinked_elements': total_elements - linked_elements,
            'total_links': len(self.links),
            'link_coverage': round(linked_elements / total_elements * 100, 1) if total_elements > 0 else 0
        }

    def export_links(self, output_path: str):
        data = []
        for link in self.links.values():
            activity = self.activities.get(link.activity_id)
            data.append({
                'Link ID': link.link_id,
                'Activity': activity.activity_name if activity else '',
                'Start': activity.start_date if activity else None,
                'End': activity.end_date if activity else None,
                'Elements': len(link.element_ids),
                'Type': link.link_type,
                'Status': link.status.value
            })
        pd.DataFrame(data).to_excel(output_path, index=False)
```

## Quick Start

```python
bim4d = BIMSchedule4D("Office Tower")

# Import schedule
bim4d.import_schedule([
    {'id': 'A100', 'name': 'Foundation', 'start': date(2024, 1, 1), 'end': date(2024, 2, 28)},
    {'id': 'A200', 'name': 'Structure L1', 'start': date(2024, 3, 1), 'end': date(2024, 4, 30)}
])

# Import elements
bim4d.import_elements([
    {'id': 'E001', 'name': 'Footing F1', 'category': 'Foundation', 'level': 'Foundation'},
    {'id': 'E002', 'name': 'Column C1', 'category': 'Structure', 'level': 'Level 1'}
])

# Create links
bim4d.create_link('A100', ['E001'])
bim4d.create_link('A200', ['E002'])

summary = bim4d.get_link_summary()
print(f"Link coverage: {summary['link_coverage']}%")
```

## Resources
- **DDC Book**: Chapter 3.3 - 4D BIM

© datadrivenconstruction · MIT · datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction

Similar skills

SKILL.md skills catalog →

From the same set156

The whole set →
document-classification-nlp document-classification-nlp is a Claude Code skill that classifies construction documents and extracts entities and keywords for sorting RFIs, submittals, specifications, and contracts. CX Codex +1 121installs defect-detection-ai defect-detection-ai identifies cracks, spalling, corrosion and other defects in concrete, steel and finishes from images and video using deep learning. Classifies defect type and severity. CX Codex +1 121installs n8n-workflow-automation n8n-workflow-automation builds automation workflows in n8n from prompts: export Revit to estimates, generate daily reports, monitor BIM model changes. Visual nodes, no code required, integrations built in. CX Codex +1 121installs pptx-construction pptx-construction builds PowerPoint decks for construction projects: progress reports, stakeholder updates, and bid presentations with charts and tables. CX Codex +1 121installs claims-documentation claims-documentation is a Claude Code skill that organizes construction claims for delays, cost overruns, and disputes, tracks notice deadlines, compiles evidence, and calculates damages. CX Codex +1 120installs change-order-manager The change-order-manager skill tracks construction change orders from discovery through approval, including cost breakdowns, schedule effects, and project records. CX Codex +1 120installs bim-classification-ai bim-classification-ai assigns standard classification codes to BIM elements using AI heuristics. Useful when preparing model data for cost estimation and quantity takeoff. CX Codex +1 120installs data-visualization data-visualization is a skill for building charts and exploring construction project data. It examines costs, quantities, schedules, and progress. CX Codex +1 120installs

Project sponsors

Companies that keep this analytics open