ArchiCAD Workflow Automation with Claude Code Skills

Build Claude Code skills to automate ArchiCAD workflows - zone management, property exports, IFC validation, and GDL scripting.

Why ArchiCAD Workflows Benefit from Claude Code Automation

ArchiCAD is a deeply structured BIM environment. Every project carries zones with calculated areas, property definitions assigned across hundreds of elements, layer combinations controlling visibility, renovation filters managing phasing, and GDL objects with parametric scripting. All of this data follows rules - your firm’s BIM Execution Plan, national classification standards, IFC export requirements, and internal naming conventions.

The challenge is never about knowing the rules. Every experienced ArchiCAD user knows that zones should have a Category, that IFC Property Sets need to map correctly for handover, or that renovation filters must distinguish between existing, demolished, and new elements. The challenge is enforcement at scale. When a project has 400 zones, 30 layer combinations, and 50 custom GDL objects, manual auditing becomes a full-day exercise that nobody can justify on a weekly basis.

Claude Code skills solve this by turning your firm’s rules into executable, repeatable workflows. A skill is a markdown file stored in your project’s .claude/skills/ directory. When you type a slash command like /check-zones or /audit-layers, Claude Code reads the skill instructions and processes your exported ArchiCAD data against your defined standards. The result is a detailed report, generated in seconds, that catches the same issues a senior BIM manager would find during a manual review.

ArchiCAD is particularly well-suited for this approach because:

ArchiCAD exports structured data natively. Zone schedules, element lists, and property assignments can all be exported to CSV, TXT, or XML. The interactive schedule system makes it straightforward to create custom listing schemes that export exactly the data a skill needs.
GDL is a text-based scripting language. Unlike compiled family definitions in other BIM tools, GDL scripts are plain text. Claude Code can read, validate, generate, and refactor GDL code directly.
IFC export produces machine-readable logs. ArchiCAD’s IFC translator settings and export logs can be captured as text, making IFC compliance checking fully automatable.
Property Manager definitions are rule-based. ArchiCAD’s property system uses explicit definitions with data types, default values, and availability rules. These translate directly into validation logic.

This guide presents six production-ready Claude Code skills built specifically for ArchiCAD workflows. Each one is a complete SKILL.md file you can drop into your project repository and start using immediately.

Setting Up ArchiCAD Data for Claude Code

Claude Code works with files on disk. It cannot connect to the ArchiCAD API or read .pln files directly. The bridge between ArchiCAD and your automation skills is a well-organized export pipeline. Before building any skills, establish this folder structure in your project repository:

project-root/
├── .claude/
│   └── skills/
│       ├── zone-validator/
│       │   └── SKILL.md
│       ├── property-auditor/
│       │   └── SKILL.md
│       ├── ifc-checker/
│       │   └── SKILL.md
│       ├── gdl-assistant/
│       │   └── SKILL.md
│       ├── layer-auditor/
│       │   └── SKILL.md
│       └── renovation-checker/
│           └── SKILL.md
├── archicad-exports/
│   ├── zones/
│   │   └── zone-schedule-2026-04-01.csv
│   ├── properties/
│   │   └── property-definitions-2026-04-01.csv
│   ├── ifc-logs/
│   │   └── ifc-export-log-2026-04-01.txt
│   ├── layers/
│   │   └── layer-combinations-2026-04-01.csv
│   └── renovation/
│       └── renovation-status-2026-04-01.csv
├── gdl-scripts/
│   ├── custom-door/
│   │   ├── scripts/
│   │   │   ├── 2d-script.gdl
│   │   │   ├── 3d-script.gdl
│   │   │   └── parameter-script.gdl
│   │   └── parameters.csv
│   └── custom-window/
│       ├── scripts/
│       │   ├── 2d-script.gdl
│       │   ├── 3d-script.gdl
│       │   └── parameter-script.gdl
│       └── parameters.csv
├── standards/
│   ├── zone-categories.csv
│   ├── property-standards.csv
│   ├── layer-template.csv
│   ├── ifc-mapping-rules.csv
│   ├── renovation-rules.md
│   └── gdl-coding-standards.md
└── reports/
    └── (skill outputs go here)

Export conventions that make your skills reliable:

Date-stamp every export. Use YYYY-MM-DD in filenames so skills can always find the most recent file by sorting alphabetically.
Use ArchiCAD’s listing schemes for CSV exports. Create dedicated listing schemes for zone data, property definitions, and element classifications. Save and reuse them so the column structure remains consistent across exports.
Export layer combinations from Layer Settings. You can copy layer combination data from the Layer Settings dialog or use an add-on like Param-O to extract it programmatically.
Capture IFC export logs. After running an IFC export with the IFC Translator, save the log output. ArchiCAD displays translation warnings and errors that skills can parse.
Keep GDL scripts in version control. Extract GDL scripts from your custom objects (using the GDL Editor or LP_XMLConverter) and store them as plain text files. This enables both AI-assisted editing and git history tracking.
Maintain a standards folder. Your firm’s BIM standards should be machine-readable files - CSV tables, JSON definitions, or markdown with structured content. Skills reference these as the single source of truth.

With this pipeline in place, every skill follows the same execution pattern: read the latest export from archicad-exports/, validate it against standards/, and write findings to reports/.

Skill: Zone Schedule Validator

Zone management is one of ArchiCAD’s strongest features, but it is also where data quality problems accumulate silently. Zones without categories, zones with zero area (indicating geometry issues), zones missing required custom properties for compliance - these issues only surface when someone runs a manual check or, worse, when a client receives an incorrect area report.

This skill reads your exported zone schedule and validates every zone against your project’s zone category standards.

# Zone Schedule Validator

Validate exported ArchiCAD zone schedule data against project
zone category standards. Catches missing categories, zero-area
zones, naming violations, and missing required zone properties.

## When to Use

Invoke with `/check-zones` before generating area reports,
before IFC export, or as part of weekly model hygiene.

## Instructions

1. Find the most recent CSV file in `archicad-exports/zones/`
   by sorting filenames (date-stamped YYYY-MM-DD format).

2. Read the zone category standard from
   `standards/zone-categories.csv`. This file has columns:
   ZoneCategory, RequiredStamp, MinArea_sqm, MaxArea_sqm,
   RequiredProperties, NamingPrefix.

3. Parse the zone export CSV. Expected columns:
   ZoneName, ZoneNumber, ZoneCategory, ZoneArea_sqm,
   FloorNumber, HomeStory, ZoneStamp, CustomProps.

4. For each zone in the export, run these checks:

   a. MISSING CATEGORY: Flag any zone where ZoneCategory
      is empty or not found in the standard's category list.

   b. ZERO OR NEGATIVE AREA: Flag any zone where
      ZoneArea_sqm is 0, negative, or non-numeric. This
      indicates a zone boundary geometry problem in the
      model that needs manual repair.

   c. AREA OUT OF RANGE: For zones with a valid category,
      check if ZoneArea_sqm falls between MinArea_sqm and
      MaxArea_sqm from the standard. Flag outliers as
      warnings - they may indicate zone boundary errors
      or misclassification.

   d. MISSING ZONE STAMP: For categories where
      RequiredStamp is TRUE in the standard, flag zones
      with an empty or default ZoneStamp value.

   e. NAMING PREFIX VIOLATION: Check that ZoneName starts
      with the NamingPrefix defined for its category.
      Example: if category "Office" requires prefix "OFF-",
      then "Meeting Room 3" would be flagged.

   f. DUPLICATE ZONE NUMBERS: Flag any two zones on the
      same FloorNumber that share the same ZoneNumber.

   g. MISSING REQUIRED PROPERTIES: Parse the
      RequiredProperties column from the standard (comma-
      separated list) and verify each property exists in
      the zone's CustomProps field.

5. Group findings by severity:
   - CRITICAL: Zero area, missing category, duplicate numbers
   - WARNING: Area out of range, missing stamp
   - INFO: Naming prefix violations

## Output Format

Write the report to `reports/zone-audit-YYYY-MM-DD.md` using
today's date.

Summary table at the top:
| Severity | Count |
| CRITICAL | X     |
| WARNING  | Y     |
| INFO     | Z     |

Then list each finding grouped by severity, including the
ZoneName, ZoneNumber, FloorNumber, and specific issue
description for each entry.

The zone validator catches issues that directly impact area calculations, fire compartment compliance, and IFC data quality. Running it before every major export saves hours of manual cross-checking and eliminates the risk of delivering incorrect area schedules to clients.

Skill: ArchiCAD Property Manager Auditor

ArchiCAD’s Property Manager is powerful but complex. Over the life of a project, properties get created ad hoc, assigned inconsistently, or left with incorrect data types. A property defined as “Text” when it should be “Number” will not break the model, but it will break data extraction workflows and IFC mappings downstream.

This skill audits your exported property definitions against your firm’s property standards.

# ArchiCAD Property Manager Auditor

Audit property definitions and assignments exported from
ArchiCAD's Property Manager. Validates data types, default
values, availability settings, and naming conventions against
the project's property standards.

## When to Use

Invoke with `/audit-properties` after adding new properties,
before IFC export configuration, or during monthly model
health reviews.

## Instructions

1. Find the most recent CSV in `archicad-exports/properties/`
   by sorting filenames (date-stamped YYYY-MM-DD).

2. Read the property standard from
   `standards/property-standards.csv`. Expected columns:
   PropertyGroup, PropertyName, DataType, DefaultValue,
   AvailableFor, IsRequired, IFCMapping.

3. Parse the property export CSV. Expected columns:
   PropertyGroup, PropertyName, DataType, DefaultValue,
   AvailableFor, IsCustom, ValueCount.

4. Run these validation checks:

   a. MISSING REQUIRED PROPERTIES: For each row in the
      standard where IsRequired = TRUE, verify a matching
      PropertyGroup + PropertyName exists in the export.
      Report any missing required properties.

   b. DATA TYPE MISMATCH: Where a property exists in both
      files, compare DataType values. Common problems:
      - "String" in export vs "Text" in standard (synonyms
        are acceptable - treat these as equivalent)
      - "Integer" vs "Number" (flag as warning)
      - "Boolean" vs "Option Set" (flag as critical)

   c. AVAILABILITY GAPS: Compare AvailableFor columns.
      If the standard says a property should be available
      for "Wall, Slab, Roof" but the export shows only
      "Wall, Slab", flag the missing element type.

   d. ORPHANED PROPERTIES: Flag any property in the export
      where IsCustom = TRUE and no matching entry exists
      in the standard. These are undocumented properties
      that may have been created ad hoc.

   e. UNUSED PROPERTIES: Flag properties where
      ValueCount = 0. These are defined but never assigned
      to any element, which adds clutter to the Property
      Manager.

   f. IFC MAPPING GAPS: For properties in the standard
      that have an IFCMapping value, verify they exist in
      the export. Missing IFC-mapped properties will cause
      data loss during IFC handover.

   g. NAMING CONVENTION: Verify property names follow
      these rules:
      - PropertyGroup uses PascalCase with no spaces
      - PropertyName uses Title Case with spaces allowed
      - No special characters except hyphens and periods
      - No trailing spaces

5. Group findings:
   - CRITICAL: Missing required properties, IFC mapping gaps
   - WARNING: Data type mismatches, availability gaps
   - INFO: Orphaned properties, unused properties, naming

## Output Format

Write to `reports/property-audit-YYYY-MM-DD.md`.

Start with a summary count by severity. Then list findings
grouped by PropertyGroup for easier navigation. Include the
specific standard expectation vs actual value for each issue.

Property auditing is especially critical before IFC exports. A missing IFC Property Set mapping means the receiving party - whether that is a structural engineer, an energy consultant, or a facility manager - will not see the data they need. Catching these gaps before export avoids costly re-exports and coordination delays.

Skill: IFC Export Quality Checker

IFC is the universal exchange format in openBIM workflows, and ArchiCAD has one of the strongest IFC translators in the industry. But “strong” does not mean “automatic.” Translator settings need to be configured correctly, and export logs frequently contain warnings about unmapped elements, missing property sets, or geometry conversion issues that users ignore because the export “completed successfully.”

This skill parses IFC export logs and flags quality issues that could cause problems for receiving applications.

# IFC Export Quality Checker

Parse ArchiCAD IFC export logs and validate against project
IFC requirements. Catches unmapped elements, missing property
sets, geometry warnings, and translator configuration issues.

## When to Use

Invoke with `/check-ifc` after every IFC export, before
sharing IFC files with consultants, or as part of openBIM
coordination milestones.

## Instructions

1. Find the most recent log file in `archicad-exports/ifc-logs/`
   by sorting filenames (date-stamped YYYY-MM-DD).

2. Read the IFC mapping rules from
   `standards/ifc-mapping-rules.csv`. Expected columns:
   ArchiCADElement, ExpectedIFCEntity, RequiredPsets,
   RequiredAttributes, MVDProfile.

3. Parse the IFC export log. Look for these patterns:

   a. WARNING lines: Lines containing "Warning:" or "WARNING"
      followed by a description. Extract the warning category
      and affected element.

   b. ERROR lines: Lines containing "Error:" or "ERROR".
      These indicate export failures for specific elements.

   c. UNMAPPED ELEMENT lines: Lines mentioning "not mapped",
      "no mapping", "skipped", or "excluded". Extract the
      element type and count.

   d. PROPERTY SET lines: Lines referencing "PropertySet",
      "Pset_", or "property mapping". Note which property
      sets were included and which had warnings.

   e. GEOMETRY lines: Lines mentioning "geometry",
      "tessellation", "BREP", or "conversion". Flag geometry
      fallback warnings where solid geometry fell back to
      tessellated representation.

4. Cross-reference with the mapping rules:

   a. MISSING IFC ENTITIES: For each ArchiCADElement in the
      standard, check if the log mentions any warnings or
      skips for that element type. If elements were expected
      but not found in the export, flag as critical.

   b. MISSING PROPERTY SETS: Check the log for each
      RequiredPsets entry. If a required Pset was not
      included in the export, flag it. Common issues:
      Pset_WallCommon missing, Pset_SpaceCommon missing.

   c. MVD COMPLIANCE: If the standard specifies an
      MVDProfile (e.g., "CV2.0", "SG", "Reference View"),
      check the log header for the translator profile used.
      Flag if the export used a different MVD than required.

5. Generate a quality score (0-100):
   - Start at 100
   - Subtract 10 per ERROR
   - Subtract 5 per WARNING about missing property sets
   - Subtract 3 per unmapped element type
   - Subtract 2 per geometry fallback warning

6. Group findings:
   - CRITICAL: Errors, missing required property sets
   - WARNING: Geometry fallbacks, unmapped elements
   - INFO: MVD profile notes, general warnings

## Output Format

Write to `reports/ifc-quality-YYYY-MM-DD.md`.

Start with the quality score in bold. Then a summary table
of issue counts by category. Then detailed findings with
the relevant log line excerpted for each issue.

The quality score is particularly useful for establishing team benchmarks. You can set a policy that IFC exports must score above 85 before sharing with consultants. Over time, the score trends upward as the team addresses recurring issues in their translator configurations.

Skill: GDL Script Assistant

GDL (Geometric Description Language) is ArchiCAD’s parametric scripting language for creating custom library parts. It is powerful but notoriously difficult to learn. The syntax is unique, error messages are cryptic, and debugging requires cycling between the GDL Editor and 3D preview repeatedly. Claude Code can dramatically speed up GDL development by generating boilerplate, validating syntax, and suggesting fixes for common errors.

# GDL Script Assistant

Help generate, validate, and refactor GDL parameter scripts
for ArchiCAD library parts. Provides syntax checking, best
practice suggestions, and boilerplate generation for common
parametric object patterns.

## When to Use

Invoke with `/gdl-help` when creating new GDL objects,
debugging script errors, or refactoring legacy GDL code.

## Instructions

1. Ask the user which GDL task they need help with:
   a. GENERATE - Create a new GDL script from a description
   b. VALIDATE - Check an existing script for errors
   c. REFACTOR - Improve an existing script's structure

2. For GENERATE tasks:

   a. Ask for: object type (door, window, furniture, 2D
      symbol), required parameters (name, type, default),
      and behavioral requirements.

   b. Generate the following script files:
      - Master Script: Parameter declarations and global
        variable initialization
      - 3D Script: geometry generation using BLOCK, PRISM,
        REVOLVE, EXTRUDE, or SWEEP operations
      - 2D Script: plan view representation using LINE2,
        RECT2, ARC2, POLY2 commands
      - Parameter Script: value list definitions, parameter
        visibility rules using VALUES and LOCK commands

   c. Follow these GDL best practices:
      - Use meaningful variable names (not a, b, c)
      - Add comments explaining each parameter's purpose
      - Use IF-THEN-ELSE for conditional geometry
      - Use GOSUB for repeated geometry patterns
      - Always define bounding box in 3D Script header
      - Handle SYMB_MIRRORED for mirrored instances

3. For VALIDATE tasks:

   a. Read all .gdl files in the specified object folder
      under `gdl-scripts/`.

   b. Check for these common issues:
      - Undeclared parameters used in scripts
      - GOSUB calls to non-existent subroutine numbers
      - Missing BODY or END commands
      - Unmatched IF/ENDIF, FOR/NEXT, GROUP/ENDGROUP
      - Division by zero risks (parameters used as
        divisors without zero-checks)
      - Hardcoded dimensions that should be parameters
      - Missing HOTSPOT definitions in 2D Script
      - GLOB_SCALE not handled for multi-scale behavior

   c. Cross-reference the parameter list (parameters.csv)
      against actual parameter usage in all scripts. Flag
      parameters that are defined but never referenced, and
      parameters referenced but not defined.

4. For REFACTOR tasks:

   a. Read the existing scripts and identify:
      - Repeated code blocks that should be subroutines
      - Deeply nested IF statements that could be simplified
      - Magic numbers that should be named parameters
      - Missing error handling for edge-case parameter values
      - Opportunities to use TUBE or MASS for complex geometry
        instead of manual vertex calculations

   b. Present the proposed changes with before/after
      comparisons before applying them.

## Output Format

For GENERATE: Write scripts to
`gdl-scripts/[object-name]/scripts/` directory.

For VALIDATE: Write report to
`reports/gdl-validation-YYYY-MM-DD.md`.

For REFACTOR: Show proposed changes inline, then apply
after user approval.

GDL scripting is one of the areas where Claude Code provides the most dramatic productivity improvement. A senior GDL developer might spend two hours building a parametric door object from scratch. With this skill, the boilerplate generation takes seconds, and the developer can focus on fine-tuning the parametric behavior and visual quality rather than writing plumbing code.

Skill: Layer Organization Auditor

ArchiCAD’s layer system is the primary organizational tool for element visibility, editing permissions, and output control. Every firm has a layer template - often based on national standards like the AIA Layer Guidelines, BS 1192, or local classification systems. Over time, projects drift from the template as team members create ad hoc layers, misspell layer names, or assign elements to incorrect layer combinations.

This skill checks your project’s layer structure against your firm’s template.

# ArchiCAD Layer Organization Auditor

Audit the project's layer structure and layer combinations
against the firm's standard layer template. Catches missing
layers, unauthorized additions, naming violations, and layer
combination inconsistencies.

## When to Use

Invoke with `/audit-layers` during project setup, before
milestones, or when onboarding new team members to verify
they have not created non-standard layers.

## Instructions

1. Find the most recent CSV in `archicad-exports/layers/`
   by sorting filenames (date-stamped YYYY-MM-DD).

2. Read the layer template from `standards/layer-template.csv`.
   Expected columns: LayerName, LayerDescription, Extension,
   ConnectionClass, IsLocked, Combinations.

   The Combinations column is a pipe-separated list of layer
   combination names where this layer should be visible
   (e.g., "A-Working|A-Floor Plan|A-Sections").

3. Parse the export CSV. Expected columns:
   LayerName, IsLocked, IsHidden, IsWireframe,
   AssignedCombinations, ElementCount.

4. Run these checks:

   a. MISSING STANDARD LAYERS: For each layer in the
      template, verify it exists in the export. Missing
      layers indicate the template was not applied
      correctly or layers were accidentally deleted.

   b. UNAUTHORIZED LAYERS: For each layer in the export
      that does NOT exist in the template, flag it as
      unauthorized. Include the ElementCount so the team
      knows how many elements would be affected by
      removing or merging the layer.

   c. NAMING CONVENTION: Verify all layer names follow
      the firm's prefix convention. Common patterns:
      - "A-" for architectural layers
      - "S-" for structural layers
      - "M-" for MEP layers
      - "G-" for general/shared layers
      Flag layers missing the prefix or using non-standard
      prefixes.

   d. LAYER COMBINATION DRIFT: For each layer in the
      template, compare the expected Combinations against
      the actual AssignedCombinations in the export. Flag
      layers that are visible in combinations where they
      should be hidden (and vice versa).

   e. EMPTY LAYERS: Flag layers with ElementCount = 0 that
      are not part of the standard template. These are
      clutter and should be removed.

   f. LOCK STATUS: Check IsLocked against the template's
      IsLocked column. Flag layers that should be locked
      (e.g., reference layers, grid layers) but are
      currently unlocked.

5. Group findings:
   - CRITICAL: Missing standard layers, combination drift
   - WARNING: Unauthorized layers with elements on them
   - INFO: Naming violations, empty layers, lock status

## Output Format

Write to `reports/layer-audit-YYYY-MM-DD.md`.

Summary table showing total layers (template vs actual),
unauthorized count, and missing count. Then detailed
findings grouped by check category.

Layer auditing is especially valuable in multi-user teamwork environments where several architects work in the same project file via Teamwork (BIMcloud). Without regular audits, layer proliferation is inevitable. Running this skill weekly keeps the layer structure clean and prevents view output problems that only surface at printing time.

Skill: Renovation Filter Compliance Checker

ArchiCAD’s renovation workflow is a core feature for any project involving existing buildings - additions, renovations, adaptive reuse, and heritage projects. The system uses three states (Existing, Demolished, New) assigned to individual elements, combined with Renovation Filters that control how those elements appear in different views. Getting the status assignments wrong leads to incorrect demolition plans, wrong quantity takeoffs, and conflicting drawing sets.

This skill validates renovation status assignments against your project’s renovation rules.

# Renovation Filter Compliance Checker

Validate renovation status assignments across all elements
to ensure compliance with project renovation rules. Catches
status conflicts, missing assignments, and filter
configuration issues.

## When to Use

Invoke with `/check-renovation` before generating demolition
drawings, before quantity takeoffs on renovation projects,
or during design review milestones.

## Instructions

1. Find the most recent CSV in
   `archicad-exports/renovation/` by sorting filenames
   (date-stamped YYYY-MM-DD).

2. Read the renovation rules from
   `standards/renovation-rules.md`. This markdown file
   defines:
   - Which element types MUST have explicit renovation
     status (not "Existing" by default)
   - Valid status transitions (e.g., a "New" element
     cannot be on a story marked as "Existing Only")
   - Story-level renovation scope (which stories contain
     renovation work)
   - Required filter configurations for each phase

3. Parse the export CSV. Expected columns:
   ElementID, ElementType, RenovationStatus, Story,
   Layer, ModifiedDate, CreatedBy.

4. Run these checks:

   a. DEFAULT STATUS ON NEW ELEMENTS: Flag any element
      where RenovationStatus = "Existing" but the element
      was created after the project's renovation baseline
      date (defined in the rules file). These are likely
      new elements that were never assigned proper status.

   b. DEMOLISHED ELEMENTS ON WRONG STORY: Cross-reference
      "Demolished" elements against the story-level scope
      in the rules. If a story is marked as "no demolition
      work" but contains demolished elements, flag it.

   c. STATUS CONFLICTS BY LAYER: Check that elements on
      the same layer have consistent renovation status
      patterns. For example, if layer "A-Wall-New" contains
      elements with status "Existing", flag the mismatch
      between layer naming and element status.

   d. ORPHANED DEMOLISHED ELEMENTS: Flag demolished
      elements that have no corresponding new element in
      the same approximate location (same story, same
      element type). This does not catch all cases but
      flags obvious omissions where something was marked
      for demolition with no replacement planned.

   e. UNASSIGNED ELEMENTS: Flag elements where
      RenovationStatus is empty or null. Every element in
      a renovation project must have an explicit status.

   f. STATUS DISTRIBUTION SUMMARY: Count elements by
      status per story. If any story has an unusually
      high ratio of one status (e.g., 95% Existing on a
      story that should have significant new work), flag
      it as a potential oversight.

5. Group findings:
   - CRITICAL: Unassigned status, wrong-story demolition
   - WARNING: Default status on new elements, layer conflicts
   - INFO: Distribution anomalies, orphaned demolitions

## Output Format

Write to `reports/renovation-audit-YYYY-MM-DD.md`.

Start with a status distribution matrix (stories vs status
counts). Then list findings by severity with ElementID,
ElementType, Story, and specific issue description.

Renovation filter compliance is one of the hardest things to audit manually because the issues are invisible in normal working views. An element with the wrong renovation status looks identical in the plan view - the problem only appears when you switch to a specific renovation filter. This skill catches those hidden issues before they reach the drawing set.

Best Practices for ArchiCAD-Specific Skills

Building effective skills for ArchiCAD workflows requires understanding both the Claude Code skill system and ArchiCAD’s data patterns. Here are the practices that separate reliable skills from fragile ones:

Design your export listing schemes with skills in mind. ArchiCAD’s interactive schedule system lets you create custom listing schemes that export exactly the columns a skill needs. Create dedicated listing schemes for each skill rather than trying to reuse general-purpose schedules. Name them with a “SKILL-” prefix (e.g., “SKILL-Zone-Export”) so the team knows they exist for automation purposes.

Handle ArchiCAD’s encoding quirks. ArchiCAD exports on Windows sometimes use Windows-1252 encoding rather than UTF-8, especially for listing scheme exports. Include a note in your skill instructions to handle non-UTF-8 characters gracefully rather than failing on encoding errors.

Account for Teamwork projects. If your project uses BIMcloud Teamwork, element-level data includes reservation status and owner information. Your skills should ignore or filter out elements that are currently reserved by other users, as their data may be in flux.

Version your standards files alongside your skills. When the firm updates its BIM standards, the corresponding CSV files in standards/ should be updated in the same commit. This ensures skills always validate against the current standard, and git history shows when standards changed.

Use the reports folder as a project health dashboard. Over time, your reports/ folder accumulates a timestamped history of every audit. You can build a simple summary skill that reads the most recent report from each category and generates a one-page project health overview. This is invaluable for project managers who need a quick status check without running individual audits.

Test skills with known-bad data. Before relying on a skill in production, create a test export file with intentional errors (missing zones, wrong property types, unauthorized layers) and verify the skill catches them all. This is especially important for the IFC checker, where log format variations between ArchiCAD versions can cause parsing issues.

Common Pitfalls and How to Avoid Them

Even well-designed skills can fail if you hit these common issues. Knowing them in advance saves significant debugging time.

Pitfall: Export column order changes. If someone modifies a listing scheme in ArchiCAD and reorders the columns, a skill that relies on column position (rather than column headers) will produce incorrect results. Always instruct skills to match columns by header name, not by position index. Include explicit expected column names in the skill instructions so Claude Code can verify the export format before processing.

Pitfall: Locale-dependent number formatting. ArchiCAD respects the operating system’s locale settings for number formatting. A zone area might export as “25.5” on an English system but “25,5” on a German system. If your team works across locales, add instructions to handle both decimal separators when parsing numeric values.

Pitfall: GDL version differences. GDL syntax has evolved across ArchiCAD versions. A script that works in ArchiCAD 27 might use commands not available in ArchiCAD 25. When building the GDL assistant skill, specify the minimum ArchiCAD version your firm supports and include version-specific notes for commands like TUBE, MASS, or LIGHT that changed behavior between versions.

Pitfall: IFC translator profile assumptions. Different IFC translators produce different log formats. The built-in “General Translator” produces different output than custom translators or the Solibri IFC Optimizer. Your IFC checker skill should specify which translator it was designed for, and include fallback parsing patterns for common alternatives.

Pitfall: Treating all findings as equal. Not every issue a skill finds needs immediate action. A zone naming prefix violation is important for consistency but will not break a deliverable. A missing required IFC Property Set will break an openBIM handover. The severity classification in your skills should reflect real project impact, not abstract rule-following. Tune the severity levels based on your firm’s actual pain points.

Pitfall: Forgetting to update standards files. The most common long-term failure mode is skills validating against outdated standards. When your firm updates its BIM standards document, the corresponding CSV and markdown files in standards/ must be updated at the same time. Assign ownership of the standards folder to the BIM manager and include a “last updated” date in each file header.

Bringing It All Together

The six skills in this guide cover the most impactful ArchiCAD automation targets: zone data quality, property management, IFC compliance, GDL development, layer organization, and renovation workflow integrity. Each one addresses a specific pain point that every ArchiCAD-based practice encounters and that manual auditing struggles to keep up with.

The real power emerges when you run these skills as a coordinated suite. Before a major milestone or IFC delivery, invoke all six in sequence. In under five minutes, you get a comprehensive project health report that would take a BIM manager an entire day to produce manually. Over time, the timestamped reports in your reports/ folder create a longitudinal view of model quality - you can see whether zone errors are trending down, whether IFC quality scores are improving, and whether new team members are following the layer standards.

Claude Code skills are not a replacement for ArchiCAD expertise. They are a force multiplier that lets your team’s existing knowledge scale across every project, every export, and every milestone without burning hours on repetitive manual checks.

If you want to deepen your understanding of BIM workflows, automation tools, and professional ArchiCAD practices, explore the structured courses at Archgyan Academy. The courses are designed for practicing architects who want to move beyond basic tool proficiency into workflow optimization and BIM leadership.

Start with one skill. Pick the audit that causes the most pain in your current project - whether that is zone schedule errors before area reports, property gaps before IFC handover, or layer chaos in a teamwork project. Build the skill, test it with real data, and iterate. Once the first skill saves you an afternoon of manual work, the motivation to build the rest follows naturally.

ArchiCAD Workflow Automation with Claude Code Skills for Architects