The Coordination Bottleneck in BIM Projects

BIM coordination is one of the most time-intensive phases of any construction project. On a typical mid-size commercial building, the coordination team might process 2,000 to 10,000 clash detection results from Navisworks or Solibri, track hundreds of open issues across mechanical, electrical, plumbing, and structural disciplines, generate dozens of RFIs, and produce weekly coordination meeting minutes that somehow need to capture every decision made in a two-hour session.

The bottleneck is not the detection itself. Modern clash detection software finds geometric conflicts reliably. The bottleneck is everything that happens after the software spits out a report - categorizing clashes by severity, identifying which discipline owns the resolution, drafting RFIs with enough context for subcontractors to act on, tracking which issues have been resolved across coordination rounds, and maintaining a clear audit trail for the project record.

Most coordination teams handle this with spreadsheets, manual copy-paste workflows, and sheer willpower. A BIM coordinator might spend four to six hours preparing for a single coordination meeting - exporting clash reports, filtering duplicates, writing up issue summaries, and updating tracking spreadsheets. Multiply that across weekly meetings over an 18-month project, and you are looking at hundreds of hours spent on administrative coordination tasks that follow predictable, rule-based patterns.

This is precisely where Claude Code skills become powerful. A skill is a reusable markdown instruction file stored in your project’s .claude/skills/ directory. When invoked, Claude Code reads the instructions and executes a multi-step workflow - parsing clash reports, categorizing issues, generating documents, and updating tracking files. The key advantage over generic AI prompting is that skills encode your firm’s specific conventions, discipline assignments, severity criteria, and document formats, so the output is consistent every time.

Setting Up BIM Coordination Data for Claude Code

Claude Code operates on files in your project repository. It cannot connect directly to Navisworks or Solibri. The bridge between your clash detection software and Claude Code is exported data. Here is the folder structure that works well for coordination projects:

project-root/
├── .claude/
│   └── skills/
│       ├── clash-report-analyzer/
│       │   └── SKILL.md
│       ├── rfi-generator/
│       │   └── SKILL.md
│       ├── model-audit-checker/
│       │   └── SKILL.md
│       ├── coordination-tracker/
│       │   └── SKILL.md
│       ├── bcf-issue-manager/
│       │   └── SKILL.md
│       └── meeting-minutes-generator/
│           └── SKILL.md
├── coordination/
│   ├── clash-reports/
│   │   ├── navisworks-export-2026-04-01.xml
│   │   ├── navisworks-export-2026-04-01.html
│   │   └── solibri-export-2026-04-01.csv
│   ├── bcf/
│   │   ├── round-12-issues.bcf
│   │   └── round-12-issues/
│   │       ├── markup.bcf
│   │       └── viewpoint/
│   ├── rfis/
│   │   └── (generated RFIs go here)
│   ├── meeting-minutes/
│   │   └── (generated minutes go here)
│   └── tracking/
│       ├── coordination-log.csv
│       └── discipline-status.csv
├── standards/
│   ├── discipline-contacts.csv
│   ├── clash-severity-rules.md
│   ├── rfi-template.md
│   └── model-audit-checklist.md
└── reports/
    └── (skill outputs go here)

The critical data sources you need to export from your coordination tools:

• Navisworks clash reports - Export as XML or HTML. XML is preferred because it preserves structured data that Claude Code can parse field by field. HTML works but requires more parsing logic.
• Solibri reports - Export as CSV for tabular clash data or PDF for presentation reports.
• BCF files - BIM Collaboration Format files (.bcf or .bcfzip) contain issue markup, viewpoints, and comments. These are ZIP archives containing XML files that Claude Code can extract and read.
• Discipline contact lists - A CSV mapping discipline codes to responsible parties, email addresses, and company names.
• Severity rules - A markdown file defining your project’s clash severity criteria (critical, major, minor, informational).

Skill: Clash Report Analyzer

This skill parses exported clash detection reports from Navisworks or Solibri, categorizes each clash by severity and responsible discipline, removes duplicate and pseudo-clash entries, and produces a structured summary ready for coordination meetings.

# Clash Report Analyzer

Parses Navisworks XML/HTML or Solibri CSV clash reports,
categorizes clashes by severity and discipline, filters
duplicates, and generates a prioritized coordination summary.

## Trigger

Use when the user says "analyze clashes", "parse clash report",
"categorize clashes", or "prepare clash summary".

## Instructions

### Step 1: Locate the clash report

1. Check `coordination/clash-reports/` for the most recent
   export file (by date in filename or file modification time).
2. Identify format: XML (.xml), HTML (.html), or CSV (.csv).
3. If no file found, ask the user to specify the file path.

### Step 2: Parse the report

**For Navisworks XML:**
- Extract each `<ClashResult>` element.
- Pull fields: Name, Status, ClashPoint (XYZ coordinates),
  Distance (penetration depth), Item1 (element path + layer),
  Item2 (element path + layer), CreatedDate.
- Map element paths to disciplines using these rules:
  - Path contains "Mechanical" or "HVAC" or "Duct" = MEP-Mech
  - Path contains "Electrical" or "Cable" or "Conduit" = MEP-Elec
  - Path contains "Plumbing" or "Pipe" or "Sanitary" = MEP-Plumb
  - Path contains "Structural" or "Framing" or "Column" = STRUCT
  - Path contains "Architecture" or "Wall" or "Floor" = ARCH
  - Path contains "Fire" or "Sprinkler" = MEP-FP

**For Navisworks HTML:**
- Parse the HTML table rows from the clash report.
- Extract: Clash Name, Status, Distance, Item 1 details,
  Item 2 details, Image reference.

**For Solibri CSV:**
- Read CSV headers and map columns to standard fields.
- Extract: Issue ID, Category, Severity, Element 1, Element 2,
  Location, Description.

### Step 3: Categorize by severity

Read `standards/clash-severity-rules.md` for project-specific
rules. If not found, use these defaults:

- **Critical** (penetration > 50mm OR involves structural
  elements OR involves fire-rated assemblies): Must resolve
  before next coordination round.
- **Major** (penetration 15-50mm OR involves MEP main runs):
  Should resolve within two coordination rounds.
- **Minor** (penetration 5-15mm OR involves branch connections):
  Track for resolution, low priority.
- **Informational** (penetration < 5mm OR duplicate/tolerance
  clashes): Log and dismiss unless pattern indicates a
  systemic modeling issue.

### Step 4: Remove duplicates

Clashes are duplicates if they share:
- Same two disciplines involved AND
- Clash points within 300mm of each other AND
- Same element types involved.

Keep the clash with the greatest penetration depth from each
duplicate group.

### Step 5: Generate the summary report

Save to `reports/clash-summary-YYYY-MM-DD.md` with format:

Clash Analysis Summary - [Date]

Source: [filename] Total clashes found: [count] After deduplication: [count]

By Severity

Severity	Count	% of Total
Critical	X	X%
Major	X	X%
Minor	X	X%
Info	X	X%

By Discipline Pair

Disciplines	Critical	Major	Minor	Info
MEP-Mech / STRUCT	X	X	X	X
MEP-Elec / ARCH	X	X	X	X
…

Critical Clashes (Requires Immediate Action)

1. [Clash Name] - [Discipline A] vs [Discipline B]
   • Penetration: Xmm
   • Location: Level [X], Grid [X-X]
   • Elements: [description]
   • Recommended owner: [discipline]

Major Clashes

…

### Step 6: Update the tracking log

Append new clashes to `coordination/tracking/coordination-log.csv`
with columns: Date, ClashID, Severity, Discipline1, Discipline2,
Status (Open), Owner, Notes.

Skill: RFI Generator

When clashes require design clarification or a decision from the architect or engineer of record, an RFI needs to go out. This skill takes the categorized clash data and drafts RFI documents automatically.

# RFI Generator

Generates RFI documents from clash analysis results. Each RFI
includes the clash context, affected disciplines, location
reference, and a clear question for resolution.

## Trigger

Use when the user says "generate RFIs", "draft RFIs from
clashes", "create RFI for clash", or "write RFIs".

## Instructions

### Step 1: Load clash data

1. Read the most recent `reports/clash-summary-*.md` file.
2. Extract all Critical and Major clashes.
3. Read `standards/discipline-contacts.csv` for responsible
   party information (columns: Discipline, Company, Contact,
   Email, Phone).

### Step 2: Group clashes into RFI topics

Not every clash needs its own RFI. Group clashes that:
- Involve the same two disciplines AND
- Occur on the same level AND
- Relate to the same system (e.g., all duct/beam conflicts
  on Level 3 become one RFI).

Each group becomes one RFI.

### Step 3: Read the RFI template

Load `standards/rfi-template.md`. If not found, use the
built-in format below.

### Step 4: Generate each RFI

For each group, create a file at
`coordination/rfis/RFI-[number]-YYYY-MM-DD.md`:

RFI-[sequential number]

Project: [Read from project-info.md or ask user] Date: [today] From: BIM Coordination Team To: [Company and Contact from discipline-contacts.csv] Discipline: [Primary discipline responsible] Priority: [Critical/Major] Response Needed By: [Critical: 3 business days, Major: 5 business days]

Subject

[System type] coordination conflict - [Location summary]

Description

During clash detection round [read from clash report], the following conflicts were identified between [Discipline A] ([Company A]) and [Discipline B] ([Company B]) at [Level/Area]:

Clash ID	Elements	Penetration	Grid Location
[id]	[desc]	[Xmm]	[grid ref]

Question

Please advise on the preferred resolution approach:

1. Can [element type] be rerouted to avoid [element type]?
2. Is there flexibility in the [dimension/elevation] of [element] at this location?
3. Are there alternative routing paths that maintain required clearances?

Attachments

• Clash report excerpt: [reference]
• Viewpoint images: [reference if available from BCF]

Response

(To be completed by respondent)

### Step 5: Generate RFI log entry

Append each generated RFI to
`coordination/tracking/rfi-log.csv` with columns:
RFI Number, Date, Subject, To (Discipline), Priority,
Status (Open), Response Due, Linked Clash IDs.

Skill: Model Audit Checklist Runner

Before a coordination meeting, each discipline model should pass a quality gate. This skill runs a pre-coordination audit checklist against exported model data and flags issues that would waste coordination time if left unresolved.

# Model Audit Checklist Runner

Runs pre-coordination model quality checks against exported
BIM data. Flags issues that should be fixed before the
coordination round proceeds.

## Trigger

Use when the user says "run model audit", "pre-coordination
check", "model quality check", or "audit before coordination".

## Instructions

### Step 1: Load the checklist

Read `standards/model-audit-checklist.md`. If not found,
use these default checks:

**Geometric Checks:**
- [ ] No elements modeled at Level 0 / Origin (within 1m
      of 0,0,0 without justification)
- [ ] No elements extending beyond the building footprint
      by more than 500mm
- [ ] All MEP systems properly connected (no disconnected
      duct/pipe segments in exports)
- [ ] No overlapping elements within the same discipline

**Metadata Checks:**
- [ ] All elements have a valid Level assignment
- [ ] All elements have a valid Workset assignment
- [ ] System classifications match project standards
- [ ] Mark/Type naming follows BEP conventions

**File Health Checks:**
- [ ] Export file is not older than 48 hours
- [ ] File size is within expected range for the discipline
      (flag if >20% different from previous export)
- [ ] All expected discipline files are present

### Step 2: Scan available exports

Look in `coordination/clash-reports/` and `revit-exports/`
for the latest files from each discipline. Build a list of
what is available and what is missing.

### Step 3: Run automated checks

For each available export file:
1. Parse the file to extract element data.
2. Run each applicable checklist item.
3. Record pass/fail/warning for each check.
4. Collect specific elements that failed each check.

### Step 4: Generate the audit report

Save to `reports/model-audit-YYYY-MM-DD.md`:

Pre-Coordination Model Audit - [Date]

Audit Summary

Discipline	Files Found	Pass	Warn	Fail
ARCH	Yes/No	X	X	X
STRUCT	Yes/No	X	X	X
MEP-Mech	Yes/No	X	X	X
MEP-Elec	Yes/No	X	X	X
MEP-Plumb	Yes/No	X	X	X

Recommendation

[PROCEED / PROCEED WITH CAUTION / HOLD - fix issues first]

Detailed Results

Architecture Model

• [PASS] Level assignments: All elements assigned
• [WARN] 3 elements near origin - verify intentional
• [FAIL] 12 elements missing Workset assignment
  • Wall-001 (Level 2, Grid B-3)
  • Wall-002 (Level 2, Grid B-4) …

Structural Model

…

### Step 5: Notify about blockers

If any discipline has FAIL items that would cause false
clashes in coordination (like elements at origin or
missing level assignments), highlight these at the top
of the report with a clear recommendation to fix before
running clash detection.

Skill: Multi-Discipline Coordination Tracker

Coordination is not a one-time event. It happens in rounds, and tracking which clashes have been resolved, which are still open, and which disciplines are falling behind is crucial for keeping the project on schedule.

# Multi-Discipline Coordination Tracker

Tracks coordination status across disciplines and rounds.
Compares current clash results against previous rounds to
measure resolution progress and identify stalled issues.

## Trigger

Use when the user says "update coordination tracker",
"coordination status", "compare clash rounds", "discipline
progress", or "who is behind on coordination".

## Instructions

### Step 1: Load tracking history

Read `coordination/tracking/coordination-log.csv`.
Parse columns: Date, ClashID, Severity, Discipline1,
Discipline2, Status, Owner, Notes, Round.

### Step 2: Load current round data

Read the most recent `reports/clash-summary-*.md` file
to get the current round's clash data.

### Step 3: Compare rounds

For each clash in the tracking log:
1. If the clash ID appears in the current round with
   Status = "Active" - mark as STILL OPEN.
2. If the clash ID does NOT appear in the current round -
   mark as RESOLVED.
3. If a new clash ID appears that was not in previous
   rounds - mark as NEW.

Calculate per-discipline metrics:
- Total open clashes (current)
- Clashes resolved since last round
- Clashes unresolved for 3+ rounds (STALLED)
- New clashes introduced this round
- Net change (resolved minus new)

### Step 4: Generate the status dashboard

Save to `reports/coordination-status-YYYY-MM-DD.md`:

Coordination Status Dashboard - [Date]

Current Round: [number] Previous Round: [date] Days Between Rounds: [count]

Overall Progress

Metric	Count
Total Open	X
Resolved This Round	X
New This Round	X
Net Change	+/- X
Stalled (3+ rounds)	X

Discipline Performance

Discipline	Open	Resolved	New	Stalled	Trend
MEP-Mech	X	X	X	X	up/down
MEP-Elec	X	X	X	X	up/down
STRUCT	X	X	X	X	up/down
ARCH	X	X	X	X	up/down

Stalled Issues (Requires Escalation)

These clashes have been open for 3+ coordination rounds without resolution:

1. [ClashID] - [Discipline A] vs [Discipline B]
   • First identified: Round [X] ([date])
   • Owner: [discipline]
   • Current status: [notes]
   • Action needed: Escalate to project manager

Discipline Pair Heatmap

Pair	Open Clashes	Resolution Rate
MEP-Mech / STRUCT	X	X%
MEP-Elec / ARCH	X	X%
…

### Step 5: Update the tracking log

Write the updated status back to
`coordination/tracking/coordination-log.csv` with
the latest round data and status changes.

Skill: BCF Issue Manager

The BIM Collaboration Format (BCF) is an open standard for communicating issues between BIM tools. BCF files contain viewpoints, markup, and comments that provide rich context for coordination issues. This skill parses BCF files and organizes them into actionable issue lists.

# BCF Issue Manager

Parses BCF (BIM Collaboration Format) files, extracts issues
with viewpoints and comments, organizes by discipline and
priority, and generates a structured issue register.

## Trigger

Use when the user says "parse BCF", "import BCF issues",
"read BCF file", "organize BCF", or "BCF to issue list".

## Instructions

### Step 1: Locate BCF files

1. Check `coordination/bcf/` for .bcf or .bcfzip files.
2. BCF files are ZIP archives. Extract them to a temporary
   folder or read the extracted XML directly if already
   unzipped.

### Step 2: Parse BCF structure

A BCF archive contains:
- `bcf.version` - BCF version identifier
- `project.bcfp` - Optional project info
- One folder per issue (named by GUID), each containing:
  - `markup.bcf` - Issue metadata, comments, viewpoints
  - `viewpoint.bcfv` - Camera position and component visibility
  - `snapshot.png` - Optional screenshot

For each issue folder, extract from `markup.bcf`:
- **Topic:** Title, Description, CreationDate, ModifiedDate,
  AssignedTo, TopicStatus, TopicType, Priority, DueDate,
  Stage, Labels
- **Comments:** Author, Date, Comment text, Viewpoint ref
- **Viewpoints:** Camera position, component selection,
  component coloring

### Step 3: Categorize issues

Map BCF TopicType values to coordination categories:
- "Clash" or "Conflict" = Clash Issue
- "Request" or "Question" = RFI Candidate
- "Remark" or "Comment" = General Note
- "Error" or "Fault" = Model Error

Map Priority values:
- "Critical" or "High" = Critical
- "Normal" or "Medium" = Major
- "Low" or "Minor" = Minor

### Step 4: Cross-reference with existing tracking

If `coordination/tracking/coordination-log.csv` exists,
check whether any BCF issue GUIDs already appear in the
log. Mark matches as EXISTING and new GUIDs as NEW.

### Step 5: Generate the issue register

Save to `reports/bcf-issue-register-YYYY-MM-DD.md`:

BCF Issue Register - [Date]

Source file: [filename] BCF Version: [version] Total Issues: [count] New Issues: [count] Updated Issues: [count]

Issues by Category

Category	Critical	Major	Minor	Total
Clash	X	X	X	X
RFI Cand.	X	X	X	X
Model Error	X	X	X	X
General Note	X	X	X	X

Critical Issues

1. [Title] (GUID: [short guid])
   • Type: [category]
   • Assigned: [person/discipline]
   • Created: [date]
   • Status: [status]
   • Description: [text]
   • Comments: [count] ([latest comment excerpt])

All Issues (Sorted by Priority)

#	Title	Type	Priority	Assigned	Status	Comments
…

### Step 6: Merge into coordination log

Add new BCF issues to `coordination/tracking/coordination-log.csv`
using the BCF GUID as the ClashID, preserving all existing entries.

Skill: Coordination Meeting Minutes Generator

Coordination meetings produce decisions, action items, and status updates that need to be captured accurately and distributed quickly. This skill generates structured meeting minutes from notes taken during the session.

# Coordination Meeting Minutes Generator

Creates structured coordination meeting minutes from
rough notes. Extracts action items, decisions, and
links them to specific clash IDs and disciplines.

## Trigger

Use when the user says "generate minutes", "write up
meeting notes", "coordination meeting minutes", or
"format meeting notes".

## Instructions

### Step 1: Load meeting notes

1. Look for a recent file in `coordination/meeting-minutes/`
   named `notes-YYYY-MM-DD.md` or `raw-notes-*.md`.
2. If not found, ask the user to paste or specify the notes.

### Step 2: Parse the notes

Extract from the raw notes:
- **Attendees** - Names, companies, disciplines
- **Decisions** - Any statement that resolves a clash or
  sets a direction (look for phrases like "agreed to",
  "will proceed with", "decided", "approved")
- **Action Items** - Tasks assigned to specific people
  or disciplines (look for phrases like "will", "needs to",
  "responsible for", "by [date]")
- **Clash References** - Any mention of clash IDs, RFI
  numbers, or specific clash descriptions
- **Open Questions** - Items that were discussed but not
  resolved (look for "TBD", "to be determined", "pending",
  "need to check")

### Step 3: Cross-reference with coordination data

If `coordination/tracking/coordination-log.csv` exists:
- Link mentioned clash IDs to their full descriptions.
- Verify that action items have valid discipline owners.
- Flag any clash IDs mentioned that are not in the log.

### Step 4: Generate formatted minutes

Save to `coordination/meeting-minutes/minutes-YYYY-MM-DD.md`:

BIM Coordination Meeting Minutes

Date: [date] Time: [time if available] Round: [coordination round number] Location: [physical/virtual]

Attendees

Name	Company	Discipline	Role
…	…	…	…

Decisions Made

1. [Clash/Topic Reference] - [Decision description]
   • Disciplines affected: [list]
   • Effective from: [date/round]

Action Items

#	Action	Owner	Discipline	Due Date	Linked Clash
1	[task]	[name]	[disc]	[date]	[clash ID]

Clash Status Updates

Clash ID	Previous Status	New Status	Notes
…	Open	Resolved	…

Open Questions

1. [Question] - To be resolved by [discipline/person]

Next Meeting

• Date: [date]
• Expected deliverables: [list what each discipline should bring/resolve]

### Step 5: Update tracking data

For each decision that resolves a clash:
- Update the clash status in `coordination/tracking/
  coordination-log.csv` to "Resolved" with the meeting
  date and decision notes.

For each action item:
- Add to `coordination/tracking/action-items.csv` if
  the file exists, or create it.

Integrating Coordination Skills into Your Project Workflow

Individual skills are useful, but the real productivity gain comes from chaining them into a coordination workflow. Here is how a typical weekly coordination cycle looks with these skills in place:

Day before the coordination meeting:

1. Export updated clash reports from Navisworks or Solibri to coordination/clash-reports/.
2. Run /model-audit to check all discipline models for quality issues.
3. Run /analyze-clashes to parse and categorize the new clash results.
4. Run /coordination-tracker to compare against the previous round and generate the status dashboard.

During the coordination meeting:

5. Use the clash summary and status dashboard as the agenda. Take rough notes in a markdown file.

After the coordination meeting:

6. Save rough notes to coordination/meeting-minutes/notes-YYYY-MM-DD.md.
7. Run /meeting-minutes to generate structured minutes with linked action items.
8. Run /generate-rfis for any new clashes that require formal clarification.
9. Run /bcf-manager if any disciplines provided BCF files with issue markup.

This nine-step process replaces what typically takes a coordinator six to eight hours of manual work with roughly 30 minutes of exports and skill invocations. The reports are more consistent, the tracking data stays current, and nothing falls through the cracks between rounds.

You can also create a master orchestration skill that runs several of these in sequence:

# Weekly Coordination Workflow

Runs the full pre-meeting coordination preparation sequence.

## Instructions

1. Run the Model Audit Checklist skill.
2. Run the Clash Report Analyzer skill.
3. Run the Coordination Tracker skill.
4. Generate a combined "Coordination Package" document
   that includes: audit results, clash summary, status
   dashboard, and list of outstanding RFIs.
5. Save the package to `reports/coordination-package-YYYY-MM-DD.md`.

Tips for BIM Coordination Skill Development

Building effective coordination skills takes iteration. Here are practical tips drawn from real project experience:

Start with your biggest time sink. If you spend three hours filtering and categorizing clash reports every week, build the Clash Report Analyzer first. Get one skill working well before building the next. A single well-tuned skill that saves three hours per week is worth more than six half-finished skills.

Standardize your exports early. Skills work best when the input data is consistent. Create a documented export procedure for each discipline - specify the exact format (XML vs HTML vs CSV), the fields to include, and the filename convention. The less variation in your inputs, the more reliable your skills become.

Keep severity rules in a separate file. Every project has different thresholds for what counts as critical versus minor. By storing those rules in standards/clash-severity-rules.md rather than hardcoding them into the skill, you can adjust criteria without editing the skill itself.

Version your tracking files with git. The coordination log and discipline status files are effectively a project database. Committing them to git after each coordination round gives you a complete history of how issues evolved, which is invaluable for project retrospectives and dispute resolution.

Test skills on a small dataset first. Before running a skill against a 5,000-clash report, test it on a subset of 20 to 50 clashes. Verify the categorization logic, the duplicate detection, and the output format. Fix issues when the stakes are low.

Build discipline mapping tables, not hardcoded rules. Instead of embedding discipline detection logic directly in your skill instructions, reference a CSV file that maps model paths, layer names, or workset names to discipline codes. This makes the skills portable across projects that use different model organization conventions.

Common Mistakes and How to Avoid Them

Even well-designed skills can produce poor results if you fall into common traps. Here are the mistakes we see most often in BIM coordination automation:

Mistake: Treating all clashes equally. A 3mm pipe-to-duct tolerance clash and a 200mm beam-through-duct conflict require completely different responses. Without severity categorization, your coordination meeting wastes time discussing issues that do not matter. Always define clear severity thresholds and make sure your Clash Report Analyzer applies them.

Mistake: Not deduplicating before generating RFIs. Navisworks can report the same fundamental conflict as dozens of individual clashes (every segment of a duct run clashing with the same beam, for example). If your RFI Generator does not group related clashes, you will send 15 RFIs about what is really one routing problem. Build grouping logic into your workflow.

Mistake: Ignoring the data freshness problem. A clash report from two weeks ago is nearly useless for coordination. Your skills should check file dates and warn when data is stale. The Model Audit Checklist includes a 48-hour freshness check for exactly this reason.

Mistake: Skipping the model quality audit. Running clash detection against a model with elements at the origin or with missing level assignments produces hundreds of false positives. The model audit step is not optional - it prevents your coordination meeting from being derailed by garbage data.

Mistake: Not linking meeting decisions back to the tracking log. If the coordination meeting resolves 30 clashes but nobody updates the tracking spreadsheet, the next round’s status report will show those clashes as still open. The Meeting Minutes Generator’s tracking update step exists specifically to close this loop.

Mistake: Over-automating at the start. Start with skills that handle the mechanical parts of coordination - parsing, categorizing, formatting. Leave the judgment calls (which routing option to recommend, whether a severity classification should be overridden) to the human coordinators. As you build confidence in the system, you can gradually add more sophisticated logic.

Conclusion

BIM coordination does not have to consume hundreds of hours of manual administrative work per project. The six Claude Code skills covered in this guide - Clash Report Analyzer, RFI Generator, Model Audit Checklist Runner, Multi-Discipline Coordination Tracker, BCF Issue Manager, and Coordination Meeting Minutes Generator - address the most time-intensive parts of the coordination workflow. Each one is a complete, ready-to-customize skill file that you can drop into any project’s .claude/skills/ directory and start using immediately.

The key insight is that coordination work is fundamentally rule-based. Clashes have severity criteria. RFIs follow templates. Tracking requires comparing datasets across rounds. Meeting minutes need structured extraction from notes. These are exactly the kinds of workflows where AI-driven automation delivers the most value - not replacing the coordinator’s judgment, but eliminating the hours of formatting, cross-referencing, and data entry that prevent coordinators from focusing on actual problem-solving.

Start with whichever skill addresses your biggest pain point, refine it over a few coordination rounds, and then expand from there. Within a few weeks, your coordination workflow will be faster, more consistent, and far less dependent on any single team member’s availability.

Want to deepen your BIM coordination and Revit skills? Explore our courses at Archgyan Academy for hands-on training in BIM workflows, Revit modeling, and project coordination techniques.