Claude Code Skills for Architects, Part 1: Setup and Your First Automation Skills

This is Part 1 of a two-part series. This post covers setup and your first five practical skills. Part 2 dives into advanced skill templates, team workflows, and chaining skills together.

What Are Claude Code Skills and Why Should Architects Care?

Claude Code is Anthropic’s AI-powered coding assistant that runs directly in your terminal. While most developers use it for writing software, its skills system opens up something far more interesting for architects and AEC professionals - the ability to create reusable, domain-specific automation workflows that understand your exact project conventions, file structures, and design standards.

A skill in Claude Code is a markdown file that acts as a detailed instruction set. When you invoke a skill (by typing a slash command like /generate-schedule or /check-specs), Claude Code reads those instructions and executes a complex, multi-step workflow automatically. Think of it like creating a highly knowledgeable assistant who already knows your firm’s standards, your project folder structure, your BIM template conventions, and your deliverable requirements.

For architects, this is transformative. Instead of spending hours on repetitive documentation, specification cross-referencing, or drawing set coordination, you can encode those workflows into skills that execute in seconds. The key difference between a skill and a simple prompt is persistence - skills live as files in your project repository, they can be versioned with git, shared across your team, and refined over time as your workflows evolve.

Here is what makes skills particularly powerful for architecture work:

• Context awareness - Skills can read your project files, understand folder structures, and reference existing documents
• Multi-step execution - A single skill can read a spec, cross-reference it against drawings, generate a report, and save the output
• Tool access - Skills can run shell commands, read/write files, search codebases, and interact with APIs
• Team standardization - Once a skill works, every team member gets the same consistent output

Understanding the Skill File Structure

Every Claude Code skill is a markdown file stored in your project’s .claude/skills/ directory. The file has a simple structure that combines metadata with natural-language instructions. Here is the anatomy of a skill file:

# Skill Name

Description of what this skill does and when to use it.

## Instructions

Step-by-step instructions that Claude Code follows when
the skill is invoked. These are written in plain English
but can be very specific about file paths, formats, and
validation rules.

## Output Format

What the skill should produce - file locations, formats,
naming conventions.

The skill file itself has a YAML frontmatter section (in the skill’s SKILL.md or the skill directory’s configuration) that defines:

• Name - The slash command that triggers it (e.g., /generate-schedule)
• Description - When Claude Code should suggest this skill
• Trigger patterns - Keywords or phrases that auto-activate the skill

For architecture projects, you would typically organize your skills directory like this:

your-project/
  .claude/
    skills/
      generate-room-schedule/
        SKILL.md
      check-spec-compliance/
        SKILL.md
      export-drawing-list/
        SKILL.md
      update-door-schedule/
        SKILL.md

Each SKILL.md file contains the complete instructions for that workflow. The beauty of this approach is that skills are just text files - they live alongside your project, they are version-controlled, and any team member can read, modify, or extend them.

Setting Up Claude Code for Architecture Projects

Before creating your first skill, you need to set up Claude Code in a way that makes sense for architecture work. Most architecture projects are not traditional software repositories, but Claude Code works with any folder structure.

Step 1 - Initialize your project directory. Navigate to your project folder in the terminal and run:

claude

This starts a Claude Code session in that directory. Claude Code will automatically read any .claude/ configuration files if they exist.

Step 2 - Create the CLAUDE.md file. This is the project-level instruction file that gives Claude Code context about your project. For an architecture project, it might look like:

# Project: Mixed-Use Development - Block 7

## Project Structure
- /drawings/ - AutoCAD and Revit files
- /specs/ - Technical specifications (CSI MasterFormat)
- /schedules/ - Door, window, finish, and room schedules
- /reports/ - Generated reports and checklists
- /standards/ - Firm design standards and templates

## Conventions
- All schedules use CSV format with headers in Row 1
- Spec sections follow CSI MasterFormat 2018 numbering
- Drawing numbers follow the format: A-[Level][Sheet] (e.g., A-201)
- Room numbers are [Floor][Sequential] (e.g., 301, 302)

## Team
- Project Architect: handles design decisions
- BIM Manager: handles model coordination
- Spec Writer: handles technical specifications

This context file is critical because every skill you create will inherit this project knowledge automatically. When a skill references “the schedules folder,” Claude Code already knows that means /schedules/ and that those files use CSV format.

Step 3 - Create the skills directory:

mkdir -p .claude/skills

Now you are ready to build architecture-specific skills.

Skill 1: Automated Room Schedule Generator

One of the most tedious tasks in architecture is maintaining room schedules. Every time a room changes - name, number, area, finish - the schedule needs updating. Here is a skill that reads your project’s room data and generates a formatted schedule:

# Generate Room Schedule

Generate or update the project room schedule from source data.

## When to Use
Use when room data has changed, after design revisions, or
when preparing deliverables for a submission milestone.

## Instructions

1. Read all CSV files in /schedules/rooms/ directory
2. For each room entry, validate:
   - Room number follows [Floor][Sequential] format
   - Area is a positive number in square meters
   - Finish codes reference valid entries in /standards/finish-codes.csv
3. Sort rooms by floor, then by room number
4. Generate a formatted room schedule with these columns:
   Room No | Room Name | Floor | Area (sqm) | Floor Finish |
   Wall Finish | Ceiling Finish | Ceiling Height | Notes
5. Save output to /schedules/room-schedule-[YYYY-MM-DD].csv
6. Also generate a summary showing:
   - Total rooms per floor
   - Total area per floor
   - Any validation warnings (missing finishes, unusual areas)
7. Save summary to /reports/room-schedule-summary.md

## Validation Rules
- Flag any room with area < 3 sqm or > 500 sqm as unusual
- Flag any room without all three finish codes assigned
- Flag duplicate room numbers

When you type /generate-room-schedule, Claude Code reads your room data files, validates everything against your standards, generates the formatted schedule, and produces a summary report - all in one step. What used to take 30-45 minutes of manual spreadsheet work happens in seconds.

Skill 2: Specification Cross-Reference Checker

Specifications and drawings must stay synchronized. A common source of errors in construction documents is when a specification references a material or system that does not match what appears on the drawings. Here is a skill that catches these discrepancies:

# Check Spec Compliance

Cross-reference specifications against drawing schedules
to identify discrepancies before issuing documents.

## Instructions

1. Read all specification sections in /specs/ directory
2. Extract all material references, product names, and
   system descriptions from each section
3. Read all schedules in /schedules/ (door, window, finish,
   equipment schedules)
4. For each material/product mentioned in specs:
   - Check if it appears in the relevant schedule
   - Check if quantities are consistent
   - Check if performance criteria match
5. Generate a discrepancy report with severity levels:
   - CRITICAL: Material in spec not found in any schedule
   - WARNING: Quantities differ between spec and schedule
   - INFO: Spec references a product by brand name
     (verify with spec writer if this is intentional)
6. Save report to /reports/spec-compliance-[date].md

## Output Format

### Discrepancy Report - [Date]

| Severity | Spec Section | Reference | Issue | Schedule |
|----------|-------------|-----------|-------|----------|
| CRITICAL | 08 11 13   | HM Door Frame Type B | Not in door schedule | door-schedule.csv |

### Summary
- Total issues: X
- Critical: X
- Warnings: X
- Info: X

This skill is particularly valuable before major submissions. Instead of manually scanning hundreds of pages of specifications against dozens of schedule sheets, the skill does the cross-referencing automatically and flags only the items that need human attention.

Skill 3: Drawing Set Coordination Checker

Drawing coordination between disciplines is where many projects lose time and money. This skill helps verify that your architectural drawings are internally consistent:

# Drawing Coordination Check

Verify internal consistency across the architectural
drawing set before issuing for coordination or construction.

## Instructions

1. Read the drawing index in /drawings/drawing-index.csv
2. For each drawing listed, verify:
   - The file exists in /drawings/
   - The title block information matches the index
   - Cross-references to other drawings are valid
     (e.g., "See A-501 for detail" - verify A-501 exists)
3. Check for common coordination issues:
   - Plans reference details that do not exist
   - Section marks on plans do not match section drawings
   - Door/window tags on plans match schedule entries
   - Room numbers on plans match room schedule
4. Read the plan drawings and extract:
   - All door tags (compare against door schedule)
   - All room numbers (compare against room schedule)
   - All detail callouts (verify detail drawings exist)
5. Generate coordination report grouped by drawing

## Special Rules
- Ignore drawings marked as "PRELIMINARY" in the index
- Flag any drawing not updated in the last 30 days
  as potentially stale
- Check that revision numbers are sequential

Skill 4: Project Documentation Generator

Every architecture project needs status reports, meeting minutes templates, and milestone documentation. This skill automates the generation of these documents:

# Generate Project Report

Create a formatted project status report pulling data
from multiple project sources.

## Instructions

1. Read the project info from /CLAUDE.md
2. Scan /drawings/drawing-index.csv for:
   - Total drawings per discipline
   - Drawings modified in the last 7 days
   - Drawings at each revision level
3. Scan /specs/ for:
   - Total specification sections
   - Sections marked as draft vs final
4. Scan /schedules/ for:
   - Last modified dates on each schedule
   - Any schedules not updated in 14+ days
5. Check /reports/ for recent coordination reports
   and extract summary statistics
6. Generate a project status report with sections:
   - Project Overview (from CLAUDE.md)
   - Drawing Progress (table with discipline breakdown)
   - Specification Status (table with section status)
   - Schedule Currency (which schedules need attention)
   - Outstanding Issues (from most recent coord report)
   - Upcoming Milestones (from /schedules/milestones.csv)
7. Save to /reports/project-status-[YYYY-MM-DD].md

## Formatting
- Use markdown tables for all tabular data
- Include percentage complete where calculable
- Highlight items needing immediate attention in bold

Skill 5: BIM Model Audit Skill

For firms using Revit or other BIM tools, model quality is critical. While this skill cannot open Revit files directly, it can work with exported data (schedules, parameter exports, warnings logs) to provide automated quality checks:

# BIM Model Audit

Audit BIM model exports for quality and standards
compliance.

## Prerequisites
Export the following from Revit before running:
- Warnings list (export from Manage > Warnings)
- Room schedule (CSV export)
- Door schedule (CSV export)
- Model element count (from Revit DB Link or Dynamo)

Place exports in /bim-exports/[date]/

## Instructions

1. Read the warnings export file
2. Categorize warnings by type:
   - Duplicate instances
   - Room bounding issues
   - Overlapping elements
   - Unresolved references
3. Read room schedule export and check:
   - All rooms have valid areas (not 0 or "Not Enclosed")
   - Room names follow naming convention from /standards/
   - No duplicate room numbers exist
4. Read door schedule and verify:
   - All doors have assigned fire ratings where required
   - Door widths comply with minimum accessibility standards
     (900mm for accessible routes)
   - Hardware groups are assigned to all doors
5. Generate audit report with:
   - Warning count by category (trend if previous audit exists)
   - Room data quality score (percentage of rooms passing all checks)
   - Door compliance percentage
   - Specific action items sorted by priority
6. Save to /reports/bim-audit-[date].md
7. If a previous audit exists, include a comparison section
   showing improvement or regression

This workflow is especially powerful when combined with a Dynamo script or Revit macro that auto-exports the required data. The architect or BIM manager exports once, runs the skill, and gets a comprehensive audit report in seconds.

Building Advanced Skills: Chaining and Conditional Logic

Once you are comfortable with basic skills, you can create more sophisticated workflows that chain multiple operations together. Here are patterns that work well for architecture:

Pattern 1: Pre-Submission Checklist

# Pre-Submission Check

Run all quality checks before a document submission.

## Instructions

1. Run the drawing coordination check (follow instructions
   from /check-drawing-coordination skill)
2. Run the spec compliance check
3. Run the BIM model audit (if exports exist)
4. Compile all results into a single pre-submission report
5. At the top of the report, add a GO/NO-GO recommendation:
   - GO: Zero critical issues, fewer than 5 warnings
   - CONDITIONAL: Zero critical issues, 5+ warnings
   - NO-GO: Any critical issues exist
6. Save to /reports/pre-submission-[milestone]-[date].md

Pattern 2: Client Presentation Prep

# Prep Client Presentation

Prepare supporting documentation for a client presentation.

## Instructions

1. Read the meeting agenda from /admin/upcoming-meetings.csv
   to identify the next client meeting
2. Generate an updated project status summary (abbreviated)
3. List all design changes since the last client meeting
   by scanning git history or file modification dates
4. Create a list of decision items that need client input
   (scan /admin/decision-log.csv for items with status "Pending")
5. Generate a formatted meeting brief saved to
   /admin/meeting-brief-[date].md

Pattern 3: Code Compliance Quick Check

# Code Compliance Check

Verify key building code requirements against project data.

## Instructions

1. Read project parameters from /standards/project-parameters.csv
   (occupancy type, construction type, building height, area)
2. Read the applicable code requirements from
   /standards/code-requirements.csv
3. Cross-reference:
   - Maximum building height vs proposed height
   - Maximum area per floor vs proposed area
   - Required fire rating by construction type
   - Egress width requirements vs corridor widths in schedule
   - Plumbing fixture counts vs occupant load
4. Generate a compliance matrix showing PASS/FAIL/REVIEW
   for each requirement
5. Flag any items that are within 10% of the maximum
   allowed as "MARGINAL - verify with code consultant"
6. Save to /reports/code-compliance-[date].md

Practical Tips for Getting Started

If you are an architect or BIM professional considering Claude Code skills, here are concrete recommendations based on what works well in practice:

1. Start with your most repetitive task. Do not try to automate everything at once. Pick the one workflow you do most often - maybe it is updating room schedules, or generating weekly status reports, or cross-checking door hardware against specs. Build one skill for that task, use it for two weeks, refine it, and then move on to the next.

2. Standardize your file structure first. Skills work best when they know where to find things. If your project folders are inconsistent across projects, spend an hour creating a standard template. This investment pays off enormously because every skill you build will work on every project that follows the template.

3. Use CSV for data interchange. When exporting data from Revit, ArchiCAD, or other BIM tools for skill consumption, CSV is the most reliable format. It is human-readable, easy for Claude Code to parse, and trivial to re-import. Avoid PDF exports for data that needs to be processed - they are much harder to work with reliably.

4. Version your skills with git. Keep your .claude/skills/ directory in version control. This means you can track changes, roll back if a skill breaks, and share skills across your team through your normal git workflow.

5. Include validation in every skill. Always have your skills check for common errors before producing output. A skill that silently produces wrong data is worse than no skill at all. Build in sanity checks - “flag rooms with zero area,” “warn if door count differs by more than 10% from last audit” - so that you catch issues early.

6. Write skills for your juniors. The biggest productivity gain often comes from encoding senior knowledge into skills that junior staff can run. A graduate architect with a good room-schedule-checker skill produces more reliable output than one without, because the skill catches the mistakes that experience would normally catch.

7. Keep skills focused. A skill that tries to do everything will be fragile and hard to maintain. Build small, focused skills that do one thing well, then create a “meta-skill” that chains them together for comprehensive checks (like the pre-submission checklist above).

Common Mistakes to Avoid

When architects first start building Claude Code skills, these are the pitfalls that come up most frequently:

Overcomplicating the first skill. Your first skill should be embarrassingly simple. Generate a report from one CSV file. Once that works reliably, add complexity incrementally.

Assuming Claude Code can open proprietary files. Claude Code works with text-based files - markdown, CSV, JSON, XML, plain text. It cannot open .rvt, .dwg, .pln, or other binary files directly. You need an export step (manual or scripted) to convert BIM data into a text format first.

Not testing with real project data. A skill that works on a three-room test file might break on a 200-room real project. Test your skills with production-scale data before relying on them.

Forgetting to handle missing data gracefully. Real project data is messy. Rooms without finish codes, doors without hardware groups, specs referencing products that have been substituted. Your skill instructions should include handling for these cases - “if finish code is blank, add to warnings list” rather than failing silently.

Skipping the CLAUDE.md file. Without project context, skills have to guess at your conventions. A well-written CLAUDE.md file makes every skill smarter because it provides the project-specific knowledge that skills need to make good decisions.

What’s Next: The Future of AI-Assisted Architecture

Claude Code skills represent a shift in how architects can interact with their project data. Today, the primary use case is automating document-heavy workflows - schedules, specs, reports, coordination checks. But the pattern extends further as the industry evolves.

Firms that start building skills now are developing two assets simultaneously: the skills themselves (which save time immediately) and the institutional knowledge encoded in those skills (which captures how the firm does things, making onboarding faster and output more consistent).

The architects who will benefit most from this technology are not the ones who wait for perfect tools. They are the ones who start with a simple room-schedule generator, discover what works, and gradually build a library of skills that transforms how their practice operates.

If you are ready to explore AI-powered workflows for your architecture practice, start with one repetitive task, write one skill, and see what happens. The learning curve is gentle, and the productivity gains compound quickly.

For architects looking to build deeper technical skills alongside AI proficiency, explore our courses on BIM and computational design at Archgyan Academy.