SketchUp Automation with Claude Code Skills: Streamline Your Design Workflow

Why SketchUp Workflows Benefit from Claude Code Skills

SketchUp has always been the architect’s sketchpad - fast, intuitive, and forgiving. But that flexibility creates its own problems. Unlike Revit or ArchiCAD, SketchUp does not enforce naming conventions, layer structures, or component standards. The result is that every firm (and often every person within a firm) develops their own way of organizing models, and those inconsistencies compound over time into messy handoffs, broken exports, and rendering headaches.

This is exactly where Claude Code skills fit in. A Claude Code skill is a reusable markdown instruction file stored in your project’s .claude/skills/ directory. When you invoke a skill with a slash command - something like /check-model or /generate-ruby - Claude Code reads those instructions and executes a multi-step workflow across your project files. Skills can read exported model data, validate it against your standards, generate Ruby scripts, and produce reports.

For SketchUp specifically, skills solve several pain points that are unique to the platform:

• No built-in standards enforcement. SketchUp will happily let you create 47 layers named “Layer1 copy” without complaint. Skills catch this before it becomes a coordination problem.
• Ruby scripting has a steep learning curve. The SketchUp Ruby API is powerful but underdocumented. A skill can generate tested Ruby snippets for common operations based on plain-English descriptions.
• Export quality is unpredictable. DWG exports from SketchUp often produce unexpected layer mappings, missing geometry, or incorrect scales. Skills can validate export files before they leave your desk.
• Material management is manual. SketchUp does not have native material takeoff tools. Skills can parse model data exports and generate material schedules automatically.
• Rendering prep is a checklist nobody follows. Before exporting to V-Ray or Enscape, there are dozens of things to verify - face orientation, proxy placement, texture resolution. Skills turn that checklist into an automated audit.

This guide walks through six production-ready skills for SketchUp automation. Each skill is presented as a complete SKILL.md file that you can copy directly into your .claude/skills/ folder and start using immediately.

Setting Up SketchUp Projects for Claude Code Integration

Claude Code operates on files in your project repository. It cannot connect directly to SketchUp’s internal model database. The bridge between your 3D model and Claude Code is exported data - and the quality of your exports determines how useful your skills can be.

Here is the recommended folder structure:

project-root/
├── .claude/
│   └── skills/
│       ├── component-library-manager/
│       │   └── SKILL.md
│       ├── ruby-script-generator/
│       │   └── SKILL.md
│       ├── model-organization-auditor/
│       │   └── SKILL.md
│       ├── rendering-prep-checker/
│       │   └── SKILL.md
│       ├── export-validator/
│       │   └── SKILL.md
│       └── material-schedule-generator/
│           └── SKILL.md
├── sketchup-exports/
│   ├── components/
│   │   ├── component-list-2026-04-01.csv
│   │   └── component-thumbnails/
│   ├── model-info/
│   │   ├── layers-tags-2026-04-01.csv
│   │   ├── scenes-2026-04-01.csv
│   │   └── materials-2026-04-01.csv
│   ├── dwg-exports/
│   │   ├── floor-plan-level-01.dwg
│   │   └── section-aa.dwg
│   └── ruby-logs/
│       └── last-run-output.txt
├── standards/
│   ├── tag-naming-conventions.md
│   ├── component-naming-rules.csv
│   ├── material-library-standard.csv
│   └── rendering-checklist.md
├── ruby-scripts/
│   └── (generated scripts go here)
└── reports/
    └── (skill outputs go here)

Export conventions that make skills reliable:

1. Date-stamp every export. Use YYYY-MM-DD in filenames so skills can always locate the most recent file by sorting alphabetically.
2. Use CSV for model data. Component lists, tag structures, scene lists, and material data should all export as CSV with headers. You can use free plugins like Attribute Reporter or write a simple Ruby snippet to export this data.
3. Export component metadata separately. Component names, definition counts, nesting levels, and bounding box dimensions are all valuable for auditing. A Ruby export script (which the Ruby Script Generator skill can create for you) captures this in seconds.
4. Keep a standards folder. Your firm’s conventions for tag naming, component organization, and material libraries should be documented in machine-readable formats. Markdown tables and CSVs both work well.
5. Commit your exports to git. This gives you model health history and lets the whole team access current exports without opening SketchUp.

Here is a minimal Ruby snippet you can paste into SketchUp’s Ruby Console to export your model’s tag structure as CSV:

# Export all tags to CSV
model = Sketchup.active_model
today = Time.now.strftime('%Y-%m-%d')
path = File.join(model.path.chomp('.skp'), '..', 'sketchup-exports',
                 'model-info', "layers-tags-#{today}.csv")
File.open(path, 'w') do |f|
  f.puts "TagName,Visible,Color,LineStyle"
  model.layers.each do |tag|
    f.puts "#{tag.name},#{tag.visible?},#{tag.color.to_a.join('-')},default"
  end
end
puts "Exported #{model.layers.count} tags to #{path}"

With this structure in place, every skill follows the same pattern: read the latest export from sketchup-exports/, compare it against the corresponding standard in standards/, and write a report to reports/.

Skill: Component Library Manager

SketchUp components are the building blocks of efficient modeling, but they become a liability when they are duplicated, poorly named, or nested inconsistently. This skill audits your component exports and validates them against your firm’s component naming rules.

# Component Library Manager

Audit exported SketchUp component data against the project's
naming conventions and organizational standards. Flags
duplicates, naming violations, oversized components, and
improper nesting.

## When to Use

Invoke with `/component-library` before sharing models with
consultants, before submission milestones, or after importing
components from external libraries.

## Instructions

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

2. Read the component naming standard from
   `standards/component-naming-rules.csv`. Expected columns:
   Category, Prefix, NamingPattern, MaxNestingDepth,
   MaxPolygonCount.

3. Parse the component export CSV. Expected columns:
   ComponentName, DefinitionName, InstanceCount, NestingLevel,
   PolygonCount, BoundingBoxVolume, TagAssignment, IsFromLibrary.

4. Run these validation checks:

   a. NAMING VIOLATIONS: Check each DefinitionName against the
      NamingPattern for its Category. Pattern rules:
      - Must start with the category Prefix (e.g., "FUR_" for
        furniture, "FIX_" for fixtures, "VEG_" for vegetation)
      - Must use underscores as separators, not spaces
      - Must not contain special characters except underscores
        and hyphens
      - Must not exceed 50 characters

   b. DUPLICATE DEFINITIONS: Flag DefinitionNames that appear
      more than once with different polygon counts or bounding
      box volumes. This indicates modified copies that were not
      made unique.

   c. EXCESSIVE NESTING: Flag any component where NestingLevel
      exceeds the MaxNestingDepth for its category. Deep nesting
      causes performance problems and makes editing difficult.

   d. OVERSIZED COMPONENTS: Flag any component where
      PolygonCount exceeds the MaxPolygonCount for its category.
      Common culprit: imported furniture with subdivision
      surfaces still intact.

   e. UNTAGGED COMPONENTS: Flag components where TagAssignment
      is empty or set to "Untagged". Every component instance
      should have a tag assignment for visibility control.

   f. ORPHAN DEFINITIONS: Flag DefinitionNames where
      InstanceCount is 0. These inflate file size without
      contributing to the model.

5. Group findings by severity:
   - CRITICAL: Duplicate definitions, orphan definitions
   - WARNING: Oversized components, excessive nesting
   - INFO: Naming violations, untagged components

## Output Format

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

### Component Library Audit - [Date]

**Export file:** [filename]
**Components scanned:** [count]
**Unique definitions:** [count]
**Issues found:** [count by severity]

#### Critical Issues
- [DefinitionName]: Duplicate definition with [N] variations
  (polygon counts: [list])

#### Warnings
- [DefinitionName]: Polygon count [actual] exceeds limit
  [max] for category [category]

#### Info
- [DefinitionName]: Missing category prefix, expected
  "[Prefix]_" for [Category] components

#### Summary Table
| Definition | Instances | Polygons | Nesting | Tag | Status |
|-----------|-----------|----------|---------|-----|--------|
| Name      | count     | count    | level   | tag | PASS/FAIL |

This skill catches the component bloat that silently kills SketchUp performance. One firm discovered they had 340 orphan component definitions adding 120MB to every model file. A single audit cleaned up months of accumulated debris.

Skill: Ruby Script Generator

The SketchUp Ruby API gives you programmatic access to nearly every modeling operation, but writing Ruby scripts from scratch requires memorizing an API that has limited documentation and some non-obvious quirks. This skill generates tested Ruby scripts based on plain-English task descriptions.

# SketchUp Ruby Script Generator

Generate SketchUp Ruby API scripts based on task descriptions.
Produces copy-paste-ready scripts with error handling, undo
wrapping, and console output.

## When to Use

Invoke with `/generate-ruby` followed by a description of
what the script should do. Examples:
- /generate-ruby select all faces on Tag "Roof" and reverse
  any that face inward
- /generate-ruby export all material names and texture
  file paths to CSV
- /generate-ruby create a grid of 10x10 component instances
  spaced 3 meters apart

## Instructions

1. Read the user's task description.

2. Determine which SketchUp Ruby API modules are needed.
   Common modules:
   - Sketchup::Model, Sketchup::Entities (model access)
   - Sketchup::ComponentDefinition, ComponentInstance
   - Sketchup::Face, Edge, Group (geometry)
   - Sketchup::Layer (tags in newer versions)
   - Sketchup::Material, Texture (materials)
   - Sketchup::Pages, Page (scenes)
   - Geom::Transformation, Geom::Point3d (transforms)
   - UI.savepanel, UI.openpanel (file dialogs)

3. Generate the Ruby script following these conventions:

   a. UNDO WRAPPING: All geometry modifications must be
      wrapped in model.start_operation / commit_operation:
      ```ruby
      model = Sketchup.active_model
      model.start_operation('Operation Name', true)
      # ... modifications ...
      model.commit_operation
      ```

   b. ERROR HANDLING: Wrap the entire script in a
      begin/rescue/end block. On error, call abort_operation
      and print the error to the Ruby Console.

   c. UNIT AWARENESS: SketchUp internally uses inches.
      If the user specifies meters or millimeters, include
      conversion. Use these constants:
      - 1.m = 39.3701 inches
      - 1.mm = 0.0393701 inches
      - Or use .to_l method with string: "3m".to_l

   d. SELECTION AWARENESS: If the task involves "selected"
      entities, use model.selection. If it involves "all"
      entities, use model.active_entities.

   e. CONSOLE OUTPUT: Print progress messages using puts
      so the user can see what the script is doing in the
      Ruby Console.

   f. FILE OUTPUT: If the script exports data, default to
      the `sketchup-exports/ruby-logs/` folder relative to
      the model file location. Use UI.savepanel if the user
      might want to choose the location.

4. Add inline comments explaining non-obvious API calls.

5. Test the script mentally for edge cases:
   - Empty selection
   - No active model open
   - Groups vs component instances
   - Nested entities (recursive traversal needed?)

## Output Format

Write the script to `ruby-scripts/[task-slug]-YYYY-MM-DD.rb`.

Also print the script to the console with instructions on
how to run it:
1. Open SketchUp
2. Open the Ruby Console (Window > Ruby Console)
3. Copy and paste the script
4. Press Enter

Include a header comment in the script:
```ruby
# Script: [Task description]
# Generated: [Date]
# Usage: Paste into SketchUp Ruby Console
# Undo: Ctrl+Z will undo all changes made by this script

The real value of this skill is not just script generation - it is the conventions it enforces. Every generated script gets undo wrapping, error handling, and unit conversion. These are the three things that trip up architects who occasionally write Ruby snippets but do not do it often enough to remember the boilerplate.

## Skill: Model Organization Auditor

A well-organized SketchUp model has a clear tag structure, consistent use of groups and components, properly configured scenes, and no stray geometry floating on Layer0/Untagged. This skill checks all of those things at once.

```markdown
# SketchUp Model Organization Auditor

Audit the model's organizational structure including tags,
groups vs components usage, scene configuration, and
stray geometry. Produces a health report with actionable
fix recommendations.

## When to Use

Invoke with `/audit-model` weekly during active design
phases, before sharing models externally, or when model
performance degrades.

## Instructions

1. Read the latest exports from `sketchup-exports/model-info/`:
   - `layers-tags-YYYY-MM-DD.csv` (TagName, Visible, Color)
   - `scenes-YYYY-MM-DD.csv` (SceneName, TagVisibilityState,
     CameraPosition, StyleName, HasSectionCut)
   - Read the model summary from `model-info/summary.txt`
     if it exists (total entities, groups, components, faces,
     edges, file size).

2. Read tag naming standards from
   `standards/tag-naming-conventions.md`. Expected format:
   a markdown table with columns: Pattern, Example, Purpose.

3. Run these organizational checks:

   a. TAG NAMING: Check all tag names against the standard
      patterns. Common standard patterns:
      - "A-WALL-EXT" (discipline-element-modifier)
      - "01_Structure" (number prefix for ordering)
      Flag tags that match none of the accepted patterns.

   b. EMPTY TAGS: Flag tags that exist but have zero entities
      assigned. These clutter the Tags panel.

   c. DEFAULT TAG GEOMETRY: Check if any raw geometry (faces,
      edges) is reported on "Untagged" / "Layer0" outside of
      any group or component. Stray geometry on the default
      tag is the most common SketchUp modeling mistake.

   d. GROUPS VS COMPONENTS: Calculate the ratio of group
      instances to component instances. If groups exceed 60%
      of all containers, flag a warning - groups should be
      the exception, not the rule, because they cannot be
      updated globally.

   e. SCENE COMPLETENESS: For each scene, check:
      - Does it have a descriptive name (not "Scene 1")?
      - Is a style applied?
      - Is the tag visibility state intentional (not all
        tags visible)?
      Flag scenes that appear to be defaults rather than
      intentionally configured views.

   f. SCENE NAMING CONSISTENCY: Check if scene names follow
      a consistent pattern (e.g., "01-Floor Plan L1",
      "02-Section AA"). Flag scenes that break the pattern
      of the majority.

   g. FILE SIZE WARNING: If the model summary reports a file
      size exceeding 100MB, flag it and recommend a purge
      of unused components and materials.

4. Score the model from 0-100:
   - Tag compliance: 25 points
   - Group/component ratio: 20 points
   - Scene organization: 25 points
   - No stray geometry: 20 points
   - File size under threshold: 10 points

## Output Format

Write to `reports/model-organization-YYYY-MM-DD.md`.

### Model Organization Audit - [Date]

**Model:** [filename]
**Health Score:** [score]/100 - [EXCELLENT/GOOD/FAIR/POOR]
  (90+ Excellent, 70-89 Good, 50-69 Fair, below 50 Poor)

#### Tag Structure
- [count] tags found, [count] compliant, [count] violations
- Empty tags: [list]
- Non-standard names: [list with suggested corrections]

#### Geometry Organization
- Groups: [count] | Components: [count] | Ratio: [%]
- Stray geometry on default tag: [YES/NO] ([count] entities)

#### Scene Configuration
- [count] scenes, [count] properly configured
- Issues: [list]

#### Recommendations
1. [Highest priority fix]
2. [Second priority fix]
3. [Third priority fix]

The 0-100 scoring system is intentional. It turns an abstract “is this model clean?” question into a concrete number that teams can track over time. One studio started including the score in their weekly project reports, and average model health went from 45 to 82 within two months.

Skill: Rendering Prep Checklist Validator

The gap between a SketchUp model that looks good on screen and one that renders correctly in V-Ray or Enscape is filled with invisible problems - reversed faces, missing textures, incorrect proxy settings, and scenes that do not match the render engine’s requirements. This skill automates the pre-rendering audit.

# Rendering Prep Checklist Validator

Validate model readiness for rendering with V-Ray, Enscape,
or other render engines. Checks face orientation, materials,
textures, proxy objects, and scene configuration.

## When to Use

Invoke with `/render-prep` before starting any rendering
batch. Specify the render engine as an argument:
- /render-prep vray
- /render-prep enscape
- /render-prep lumion

## Instructions

1. Read the render engine argument. Default to "vray" if
   not specified.

2. Read the latest material export from
   `sketchup-exports/model-info/materials-YYYY-MM-DD.csv`.
   Expected columns: MaterialName, HasTexture, TexturePath,
   TextureWidth, TextureHeight, Opacity, IsUsed.

3. Read the rendering checklist from
   `standards/rendering-checklist.md`. This contains
   engine-specific requirements under markdown headers
   matching the engine name.

4. Run these validation checks:

   a. REVERSED FACES: Check the face orientation report
      (if available in model exports) for faces where the
      back material is visible to camera in any scene.
      In SketchUp, reversed faces render with the back
      material in most engines, causing grey or incorrect
      color patches.

   b. MISSING TEXTURES: Flag any material where HasTexture
      is TRUE but TexturePath points to a file that does not
      exist. Texture paths break when models move between
      machines or when texture folders are not included.

   c. TEXTURE RESOLUTION: Flag textures where either
      dimension exceeds 4096px (excessive for most
      architectural renders) or where either dimension is
      below 512px (will appear blurry at close range).
      Recommended range: 1024px to 2048px for most surfaces.

   d. DEFAULT MATERIAL USAGE: Flag any visible geometry
      that uses the SketchUp default material (the grey-blue
      front face color). This always indicates unfinished
      material assignment.

   e. UNUSED MATERIALS: Flag materials where IsUsed is
      FALSE. These add to file size and clutter the material
      editor. Recommend purging before rendering.

   f. ENGINE-SPECIFIC CHECKS (V-Ray):
      - Verify V-Ray proxy components are referenced
        correctly (proxy file paths exist)
      - Check that V-Ray material overrides are documented
      - Flag any SketchUp-native materials on objects that
        should have V-Ray materials applied

   g. ENGINE-SPECIFIC CHECKS (Enscape):
      - Verify Enscape asset placements are on visible tags
      - Check that Enscape material keywords (glass, water,
        metal, self-illumination) are used correctly
      - Flag scenes without Enscape visual settings saved

   h. SCENE-CAMERA VALIDATION: For each scene intended as
      a render view, verify:
      - Field of view is between 40-80 degrees (standard
        architectural range)
      - Camera is not clipping through geometry
      - The scene name includes a view identifier
        (e.g., "R01-Living Room" for render view 01)

5. Categorize issues:
   - BLOCKER: Will cause render failures (missing textures,
     proxy path errors)
   - WARNING: Will cause visual artifacts (reversed faces,
     default materials, resolution issues)
   - OPTIMIZATION: Will improve render time (unused materials,
     oversized textures)

## Output Format

Write to `reports/render-prep-YYYY-MM-DD.md`.

### Rendering Prep Report - [Date]

**Render Engine:** [engine]
**Materials checked:** [count]
**Scenes checked:** [count]
**Verdict:** [READY / NOT READY - X blockers found]

#### Blockers (Must Fix)
- [MaterialName]: Texture file not found at [path]

#### Warnings (Should Fix)
- [count] faces with reversed normals in scene [SceneName]
- [MaterialName]: Default material on [count] faces

#### Optimizations (Nice to Fix)
- [count] unused materials - recommend purging
- [MaterialName]: Texture resolution [WxH] exceeds 4096px

#### Per-Scene Readiness
| Scene | Blockers | Warnings | Optimizations | Status |
|-------|----------|----------|---------------|--------|
| Name  | count    | count    | count         | READY/NOT READY |

The distinction between Blockers, Warnings, and Optimizations is critical here. Architects under deadline pressure need to know what will actually break the render versus what is just suboptimal. A missing texture file is a blocker. A slightly oversized texture is an optimization. Treating everything as equally urgent leads to nothing getting fixed.

Skill: SketchUp-to-CAD Export Validator

SketchUp’s DWG and DXF exports are notoriously unpredictable. Geometry that looks perfect in 3D can produce garbled line work in AutoCAD. Layers may not map correctly. Dimensions may shift. This skill validates export files before you send them to anyone.

# SketchUp-to-CAD Export Validator

Validate DWG/DXF files exported from SketchUp for layer
mapping accuracy, geometry integrity, scale correctness,
and file structure. Compares exports against the source
model's expected output.

## When to Use

Invoke with `/validate-export` after exporting DWG or DXF
files from SketchUp for coordination with consultants or
for CAD-based deliverables.

## Instructions

1. Scan `sketchup-exports/dwg-exports/` for all .dwg and
   .dxf files modified within the last 24 hours.

2. For each export file, perform these checks using the
   file metadata and any accompanying export log:

   a. FILE SIZE SANITY: Compare the export file size against
      the source SKP file size. DWG exports should typically
      be 10-30% of the SKP size. If significantly larger,
      the export may include unnecessary 3D geometry. If
      significantly smaller, geometry may be missing.

   b. LAYER MAPPING: Read the tag-to-layer mapping report
      from `sketchup-exports/model-info/layers-tags-*.csv`.
      Check that every SketchUp tag appears as a layer in
      the export. Common issues:
      - SketchUp tags with special characters get renamed
      - Tags with spaces get truncated at 31 characters
        (AutoCAD layer name limit)
      - Nested component tags may not export correctly

   c. EXPORT SETTINGS VERIFICATION: Check the export log
      (if generated) for these settings:
      - AutoCAD version: 2013 or later recommended
      - Export type: Should match intent (2D for plans,
        3D for coordination models)
      - Units: Must match project units
      - Edge export: "Polylines with width" recommended
        over "Lines" for cleaner line work

   d. KNOWN ISSUE FLAGS: Flag filenames or configurations
      that match known SketchUp export bugs:
      - Curved surfaces exporting as thousands of small
        line segments (suggest reducing curve segments
        before export)
      - Section cut fills not exporting (SketchUp limitation
        in some versions)
      - Hidden geometry becoming visible in export

   e. NAMING CONVENTION: Verify export filenames follow the
      project standard: [project]-[view-type]-[level].dwg
      Example: "PROJ-FP-L01.dwg" for Floor Plan Level 01.

3. Generate a validation summary for each file.

## Output Format

Write to `reports/export-validation-YYYY-MM-DD.md`.

### CAD Export Validation - [Date]

**Files checked:** [count]
**Issues found:** [total count]

#### Per-File Results
##### [filename.dwg]
- File size: [size] ([ratio]% of SKP)
- Layer count: [exported] / [expected]
- Missing layers: [list or "None"]
- Export type: [2D/3D]
- Issues: [list or "None - PASS"]

#### Common Issues Detected
- [Summary of patterns across all exports]

#### Recommendations
1. [Most impactful fix]
2. [Second priority]

The layer mapping check alone prevents a problem that wastes hours during coordination. When a structural engineer receives a DWG where “A-WALL-EXT” has been silently renamed to “A-WALL-E” because of the character limit, they end up recreating layer filters from scratch. Catching this before the file leaves your office is worth the 30 seconds it takes to run the skill.

Skill: Material Schedule Generator

SketchUp does not have native material takeoff capabilities, which means architects either estimate material quantities manually or purchase third-party plugins. This skill bridges that gap by parsing exported material and geometry data to produce formatted material schedules.

# Material Schedule Generator

Generate material schedules from exported SketchUp model
data. Calculates approximate surface areas per material
and organizes them by building element category.

## When to Use

Invoke with `/material-schedule` during schematic design
for preliminary material estimates, during DD for material
specification coordination, or for client presentations
requiring material quantity summaries.

## Instructions

1. Read the latest material export from
   `sketchup-exports/model-info/materials-YYYY-MM-DD.csv`.
   Expected columns: MaterialName, HasTexture, TexturePath,
   ColorHex, Opacity, AppliedArea_sqft, FaceCount, TagName.

2. Read the material library standard from
   `standards/material-library-standard.csv` if it exists.
   Expected columns: MaterialName, CSIDivision, Specification,
   UnitCost, Unit, Supplier.

3. Process the material data:

   a. GROUP BY CATEGORY: Use the TagName column to group
      materials by building element. Map tags to categories:
      - Tags containing "WALL" -> Walls
      - Tags containing "FLOOR" -> Floors
      - Tags containing "ROOF" -> Roofing
      - Tags containing "CEIL" -> Ceilings
      - Tags containing "FUR" or "FURN" -> Furniture (exclude
        from building material schedule)
      - All others -> Miscellaneous

   b. AGGREGATE AREAS: Sum AppliedArea_sqft for each unique
      MaterialName within each category. Convert to square
      meters if the project uses metric (check for a
      `project-settings.json` file in the project root).

   c. COST ESTIMATION: If the material library standard
      includes UnitCost data, multiply the aggregated area
      by the unit cost to produce preliminary cost estimates.
      Mark these clearly as PRELIMINARY ESTIMATES.

   d. SPECIFICATION MAPPING: If the standard includes
      CSIDivision and Specification columns, map each
      material to its specification reference. Flag any
      model materials that have no matching specification
      entry - these need spec coordination.

   e. TEXTURE QUALITY NOTES: For each material, note
      whether the texture file exists and its resolution.
      Flag materials relying on solid colors only - these
      may need texture assignment before rendering or
      presentation.

4. Generate the schedule in two formats: markdown report
   and CSV for import into spreadsheets.

## Output Format

Write the report to `reports/material-schedule-YYYY-MM-DD.md`
and the CSV to `reports/material-schedule-YYYY-MM-DD.csv`.

### Material Schedule - [Date]

**Model:** [filename]
**Total materials:** [count]
**Total applied area:** [area] sq ft / sq m
**Estimated cost:** $[total] (PRELIMINARY)

#### Walls
| Material | Area (sq ft) | Spec Ref | Unit Cost | Est. Cost |
|----------|-------------|----------|-----------|-----------|
| Name     | area        | 09 21 16 | $X.XX/sf  | $X,XXX    |

#### Floors
| Material | Area (sq ft) | Spec Ref | Unit Cost | Est. Cost |
|----------|-------------|----------|-----------|-----------|

(Continue for each category)

#### Unmatched Materials
Materials in the model with no specification reference:
- [MaterialName] - [area] sq ft on [TagName]
  Action: Coordinate with spec writer

#### CSV Export
The full schedule has also been exported to:
`reports/material-schedule-YYYY-MM-DD.csv`

Material schedules produced during schematic design give clients early visibility into material costs and help spec writers know which materials actually exist in the model. The “Unmatched Materials” section is particularly valuable because it surfaces the gap between what has been modeled and what has been specified - a gap that normally is not discovered until construction documents.

Tips for SketchUp-Specific Skill Development

Building skills for SketchUp workflows requires some platform-specific thinking that differs from skills for Revit or ArchiCAD. Here are the patterns that produce the best results.

Design skills around export-then-validate, not live model access. Claude Code cannot interact with SketchUp directly. Your workflow should always be: export data from SketchUp (via Ruby Console or plugin), then run the skill against the exported files. Build a small Ruby snippet library for common exports and keep those snippets in your ruby-scripts/ folder.

Use the Ruby Script Generator to bootstrap your export pipeline. The first skill you should build is the Ruby generator, because it produces the scripts that feed data into all your other skills. Start by generating scripts for tag export, component list export, and material data export. Once those three are working, every other skill has the data it needs.

Make standards files the single source of truth. Every validation skill should read its rules from a file in standards/, never from hardcoded values in the skill instructions. This means you can update your firm’s tag naming convention in one CSV file and every skill automatically enforces the new rules.

Handle SketchUp’s version differences explicitly. SketchUp renamed “Layers” to “Tags” in version 2020. Your skills should handle both terms - check the model version (if exported in the summary file) and use the appropriate terminology in reports. This avoids confusion when team members work across different SketchUp versions.

Keep Ruby scripts under version control. Every script the Ruby generator produces should be committed to git. This creates a library of tested snippets that the team can reuse without regenerating them. Over time, this library becomes more valuable than any plugin because it is tailored exactly to your workflows.

Common Mistakes and How to Avoid Them

Even well-designed skills can produce poor results if you fall into these common traps. Here is what to watch for.

Mistake: Writing skills that depend on a specific SketchUp plugin being installed. If your skill assumes that a particular plugin’s export format is available, it breaks for anyone who does not have that plugin. Design skills around data formats you control - CSV files with headers you define. If you need a specific export format, include the Ruby script that generates it as part of the skill documentation.

Mistake: Ignoring nested components in audits. SketchUp models are deeply hierarchical. A component can contain groups that contain other components. If your component audit only looks at top-level entities, it misses the majority of the model’s geometry. Always specify whether the skill should perform recursive traversal or only check the first level, and document that decision in the skill instructions.

Mistake: Hardcoding unit assumptions. SketchUp projects can use inches, feet, millimeters, centimeters, or meters as their default unit. A skill that assumes square feet when the project uses square meters will produce nonsense results. Always check for a project settings file or include the unit system as a skill argument.

Mistake: Not handling the “Untagged” default. In SketchUp best practice, all raw geometry (faces, edges) should be on the “Untagged” tag, and only groups and components should be assigned to specific tags. Many skills mistakenly flag geometry on “Untagged” as an error. The actual error is geometry that is not inside any group or component, regardless of its tag assignment.

Mistake: Treating all issues as equal severity. A reversed face in a rendering view is more important than a slightly non-standard tag name. If your skill reports everything at the same urgency level, users quickly learn to ignore all of it. Always categorize findings into severity levels (Critical, Warning, Info) and put blockers at the top of the report.

Mistake: Not including fix instructions. An audit that says “47 naming violations found” is less useful than one that says “47 naming violations found - run /generate-ruby rename all tags matching pattern X to pattern Y” and includes the corrective action. Where possible, have your audit skills suggest the exact command or Ruby snippet that fixes each issue.

Bringing It All Together

The six skills in this guide form a complete quality assurance pipeline for SketchUp projects. The workflow looks like this in practice:

1. Export model data using Ruby scripts (generated by the Ruby Script Generator)
2. Audit the model with the Component Library Manager and Model Organization Auditor
3. Validate rendering readiness with the Rendering Prep Checklist
4. Generate material schedules for cost coordination
5. Check DWG/DXF exports before sending to consultants

Each step takes seconds to run and catches problems that would otherwise surface hours or days later - typically at the worst possible moment. The skills improve over time as you refine your standards files and add edge cases you discover on real projects.

The key insight behind all of this is that SketchUp’s greatest strength - its flexibility - is also its greatest liability for professional work. By encoding your firm’s standards into Claude Code skills, you get the freedom of SketchUp’s modeling environment with the rigor of a BIM platform’s validation tools.

If you want to deepen your SketchUp skills and learn the modeling techniques that produce clean, audit-friendly models from the start, explore the SketchUp and BIM courses on Archgyan Academy. The courses cover everything from component best practices to rendering workflows, giving you the modeling foundation that makes these automation skills truly effective.