Claude Code Skills for Architects, Part 2: Advanced Templates and Team Workflows

This is Part 2 of a two-part series. If you are new to Claude Code skills, start with Part 1: Setup and Your First Automation Skills.

If you have used Claude Code for any architectural task, you already know it can generate scripts, answer technical questions, and help you work through complex problems. But there is a feature most architects overlook that transforms Claude Code from a general-purpose assistant into a specialized architecture automation tool: Skills.

Skills are reusable instruction files that teach Claude Code exactly how to perform specific tasks in your workflow. Instead of explaining your Revit export process, your firm’s documentation standards, or your BIM audit checklist every single time you start a conversation, you write it once as a skill. From that point forward, Claude Code follows your process precisely, every time, without deviation.

This guide walks you through everything you need to know about Claude Code skills, with concrete examples built specifically for architectural practice.

What Is Claude Code and Why Should Architects Care

Claude Code is Anthropic’s command-line AI assistant that runs directly in your terminal. Unlike browser-based AI chat tools, Claude Code operates inside your project directories. It can read your files, write new ones, run scripts, and interact with your codebase or project structure in real time.

For architects, this matters because your work involves structured data, repetitive documentation, and complex file management. Consider these everyday scenarios:

• You need to audit a Revit model export for missing parameters across 200 families
• A specification package requires consistent formatting across 15 sections
• Your drawing set needs standardized title block information propagated across 40 sheets
• Material schedules need to be generated from model data and cross-referenced against supplier databases

Each of these tasks follows a predictable pattern. Claude Code can execute these patterns, but only if it understands your specific requirements. That is where skills come in.

The key advantage over browser-based AI tools is persistence and context. Claude Code sees your actual project files, understands your directory structure, and can chain multiple operations together. You are not copying and pasting data back and forth between a chat window and your applications.

What Are Skills in Claude Code

Skills are markdown files (.md) that live inside your project directory. They contain structured instructions that Claude Code reads automatically when you invoke them. Think of a skill as a detailed standard operating procedure that Claude Code follows without needing you to re-explain it.

Here is the core concept: when you type a slash command like /audit-model in Claude Code, it loads the corresponding skill file, reads your instructions, and executes the workflow you defined. The skill can include:

• Step-by-step procedures for completing a task
• Rules and constraints (naming conventions, formatting standards, required fields)
• Code templates or script patterns to generate
• Validation criteria for checking outputs
• File paths and directory conventions specific to your project

A skill is not a script or a macro. It is a set of instructions that Claude Code interprets intelligently. If your BIM audit skill says “check all door families for the FireRating parameter,” Claude Code will figure out how to parse the exported data, locate door families, and verify the parameter exists. You describe the what and the why; Claude Code handles the how.

The practical difference: without a skill, you spend the first five minutes of every Claude Code session explaining your requirements. With a skill, you type one command and the work begins immediately.

How Skills Work Technically

Skills live in a .claude/skills/ directory at the root of your project. Each skill is a markdown file that follows a specific structure. When you invoke a skill using a slash command, Claude Code reads the file and treats its contents as authoritative instructions.

Here is the directory structure:

my-architecture-project/
├── .claude/
│   └── skills/
│       ├── audit-model/
│       │   └── SKILL.md
│       ├── write-spec/
│       │   └── SKILL.md
│       ├── sheet-setup/
│       │   └── SKILL.md
│       └── material-schedule/
│           └── SKILL.md
├── exports/
├── specs/
└── drawings/

Each SKILL.md file contains the instructions for that skill. The folder name becomes the slash command. So audit-model/SKILL.md is invoked with /audit-model in your Claude Code session.

How Claude Code discovers skills:

1. When you start a Claude Code session in a project directory, it scans for .claude/skills/
2. Each subfolder with a SKILL.md file registers as an available skill
3. You invoke a skill with a slash command matching the folder name
4. Claude Code reads the entire SKILL.md and follows the instructions

You can also reference skills in your project’s CLAUDE.md file (the main instruction file for Claude Code) to make them load automatically when relevant context appears.

Important technical details:

• Skills are plain markdown, so they work with version control (Git). Your whole team can share and update them.
• Skills can reference other files in your project, including templates, checklists, and configuration files.
• You can pass arguments to skills. For example, /audit-model --family doors could tell the skill to focus only on door families.

Architecture-Specific Skills You Can Create

Let us walk through five practical skills that solve real problems in architectural practice. Each example includes the actual skill file content you can adapt for your own projects.

BIM Model Audit Skill

This skill checks exported Revit model data for completeness, parameter consistency, and standards compliance.

# BIM Model Audit

Audit exported Revit model data for parameter completeness
and naming convention compliance.

## Trigger

Use this skill when the user says "audit model", "check model",
or "run BIM audit".

## Inputs

- Export directory: `exports/revit/` (IFC or CSV schedule exports)
- Standards file: `standards/parameter-requirements.json`

## Procedure

1. Scan the export directory for the latest export files
2. Load the parameter requirements from the standards file
3. For each family category (Doors, Windows, Walls, Floors):
   a. Check that every required parameter exists
   b. Verify parameter values are not empty or "None"
   c. Flag any parameter names that do not match the naming convention
   d. Check for duplicate type names within the same category
4. Generate an audit report as markdown in `reports/audit-YYYY-MM-DD.md`

## Required Parameters by Category

### Doors
- FireRating (cannot be empty)
- AcousticRating
- Width, Height (must be numeric, in mm)
- Mark (must follow pattern: D-[Level]-[Number])

### Windows
- UValue (must be numeric)
- SHGC (must be between 0 and 1)
- Width, Height (must be numeric, in mm)
- Mark (must follow pattern: W-[Level]-[Number])

### Walls
- FireRating
- AcousticRating (STC value, numeric)
- ThermalResistance (R-value, numeric)
- TypeName (must not contain spaces or special characters)

## Output Format

The audit report must include:
- Summary: total families checked, pass count, fail count
- Table of failures with: Category, Family Name, Parameter, Issue
- Recommendations section with suggested fixes

## Rules

- Never modify the export files; this is a read-only audit
- If the standards file is missing, list all parameters found
  and flag any that are empty, rather than failing silently
- Sort failures by severity: missing parameters first,
  then format violations, then warnings

Specification Writing Skill

This skill generates specification sections following your firm’s template and CSI format.

# Specification Writer

Generate specification sections following CSI MasterFormat
and firm documentation standards.

## Trigger

Use when the user says "write spec", "generate specification",
or "spec section [number]".

## Inputs

- Section number (e.g., "08 11 00" for Steel Doors and Frames)
- Project data file: `project/project-info.json`
- Spec template: `templates/spec-section-template.md`

## Procedure

1. Read the project info file for project name, number,
   and location details
2. Load the spec template for consistent formatting
3. Generate the specification section with these parts:
   a. PART 1 - GENERAL (references, submittals, quality assurance)
   b. PART 2 - PRODUCTS (manufacturers, materials, fabrication)
   c. PART 3 - EXECUTION (installation, field quality control)
4. Save to `specs/[section-number]-[section-name].md`

## Formatting Rules

- Use CSI SectionFormat structure (three-part format)
- All measurements in both imperial and metric
- Manufacturer names should use "or approved equal" language
- Cross-references to other sections use format: "Section XX XX XX"
- Paragraph numbering: 1.01, 1.02 for Part 1; 2.01, 2.02 for Part 2
- Never use proprietary language without "or equal" qualifier

## Quality Standards References

Always include references to:
- ASTM standards (material-specific)
- ADA/ICC A117.1 (accessibility)
- Local building code (from project-info.json)
- LEED or sustainability requirements (if applicable)

## Rules

- Ask the user for clarification if the section number
  is ambiguous or non-standard
- Include "[ARCHITECT TO VERIFY]" placeholder for any
  value that requires project-specific confirmation
- Never fabricate specific product model numbers

Drawing Sheet Setup Automation

This skill automates the tedious process of setting up and validating drawing sheet data.

# Drawing Sheet Setup

Automate drawing sheet numbering, title block data,
and sheet index generation.

## Trigger

Use when the user says "set up sheets", "sheet setup",
"generate sheet index", or "update title blocks".

## Inputs

- Sheet list CSV: `drawings/sheet-list.csv`
  (columns: SheetNumber, SheetName, Discipline, Scale, DrawnBy)
- Project info: `project/project-info.json`

## Procedure

1. Read the sheet list CSV
2. Validate all sheet numbers follow the discipline prefix convention:
   - A = Architectural
   - S = Structural
   - M = Mechanical
   - E = Electrical
   - P = Plumbing
   - L = Landscape
   - C = Civil
3. Check for duplicate sheet numbers
4. Check for missing required fields (SheetName, Scale)
5. Generate a formatted sheet index document
6. Generate a Revit Dynamo script (Python) that can update
   title block parameters from the validated CSV

## Sheet Number Format

Pattern: [Discipline][Series].[Number]
Examples:
- A1.01 (Architectural, Floor Plans, Sheet 01)
- A2.01 (Architectural, Elevations, Sheet 01)
- S1.01 (Structural, Floor Plans, Sheet 01)

Series codes:
- 0 = General (cover, abbreviations, symbols)
- 1 = Plans
- 2 = Elevations
- 3 = Sections
- 4 = Details
- 5 = Schedules
- 6 = Ceiling Plans
- 7 = Interior Elevations
- 8 = 3D Views / Renderings

## Output

- Validated sheet list: `drawings/sheet-list-validated.csv`
- Sheet index document: `drawings/sheet-index.md`
- Dynamo Python script: `scripts/update-title-blocks.py`

## Rules

- Flag sheets with numbers that skip (e.g., A1.01, A1.03 with no A1.02)
- Never renumber sheets automatically; only flag issues
- The Dynamo script must include error handling
  for missing sheets in the Revit model

Material Schedule Generation

# Material Schedule Generator

Generate material schedules from exported model data,
cross-referenced with specification requirements.

## Trigger

Use when the user says "generate schedule", "material schedule",
or "create material list".

## Inputs

- Model export: `exports/revit/material-takeoff.csv`
- Spec requirements: `specs/material-requirements.json`

## Procedure

1. Parse the material takeoff CSV
2. Group materials by CSI division
3. For each material:
   a. Match to specification section
   b. Pull required performance criteria from spec requirements
   c. Calculate total quantities (area, volume, or count as appropriate)
   d. Flag materials with no matching spec section
4. Generate the schedule in both markdown and CSV formats

## Output Columns

| Column | Description |
|--------|-------------|
| CSI Division | 2-digit division number |
| Material Name | As exported from model |
| Spec Section | Matched specification section number |
| Quantity | Total with unit |
| Performance Criteria | Key requirements from spec |
| Status | Matched, Unmatched, or Review |

## Rules

- Quantities must use consistent units within each material type
- Round quantities: areas to nearest 0.1 sq ft,
  volumes to nearest 0.1 cu ft, counts as integers
- Materials appearing in fewer than 3 instances
  should be flagged for verification
- Group "similar" materials (e.g., "Concrete 4000psi"
  and "Concrete - 4000 PSI") and flag for consolidation

Code Compliance Checking

# Code Compliance Checker

Verify project data against building code requirements
for common compliance areas.

## Trigger

Use when the user says "check code", "compliance check",
"code review", or "verify code compliance".

## Inputs

- Project info: `project/project-info.json`
  (includes occupancy type, construction type, building area)
- Room schedule: `exports/revit/room-schedule.csv`
- Door schedule: `exports/revit/door-schedule.csv`
- Code reference: `standards/ibc-requirements.json`

## Procedure

1. Load project parameters (occupancy, construction type, stories)
2. Check allowable building area against IBC Table 506.2
3. For each room in the schedule:
   a. Verify occupant load calculation (area / load factor)
   b. Check required number of exits based on occupant load
   c. Verify egress width requirements
4. For each door in the schedule:
   a. Verify minimum clear width (32" for accessibility)
   b. Check fire rating requirements based on wall rating
   c. Verify hardware requirements (panic hardware
      where occupant load exceeds 50)
5. Generate compliance report

## Code Reference Tables

### Occupant Load Factors (IBC Table 1004.5)
- Assembly (concentrated): 7 sq ft net per person
- Assembly (standing): 5 sq ft net per person
- Business: 150 sq ft gross per person
- Educational: 20 sq ft net per person
- Mercantile (ground floor): 30 sq ft gross per person
- Storage: 300 sq ft gross per person

### Minimum Exits Required (IBC Table 1006.3.1)
- 1-500 occupants: 2 exits
- 501-1000 occupants: 3 exits
- Over 1000 occupants: 4 exits

## Output

- Compliance report: `reports/code-compliance-YYYY-MM-DD.md`
- Summary: pass/fail counts by category
- Detail: each check with result, reference code section, and notes

## Rules

- Always cite the specific IBC section for each check
- Note that this is a preliminary automated check,
  not a substitute for professional code review
- Include "[VERIFY WITH AHJ]" flag for jurisdiction-specific items
- Never state that a project "passes code" as a blanket statement;
  only report individual check results

Step by Step: Creating Your First Architecture Skill

Let us walk through creating a skill from scratch. We will build a simple skill that generates a project directory structure for new architecture projects.

Step 1: Create the skills directory.

In your terminal, navigate to your project root and create the folder structure:

mkdir -p .claude/skills/new-project

Step 2: Create the SKILL.md file.

Create .claude/skills/new-project/SKILL.md with your text editor or directly in Claude Code:

# New Project Setup

Create a standardized directory structure for a new
architecture project.

## Trigger

Use when the user says "new project", "set up project",
or "create project structure".

## Inputs

- Project number (format: YYYY-NNN)
- Project name
- Project type: residential, commercial, institutional, mixed-use

## Procedure

1. Ask the user for project number, name, and type if not provided
2. Create the following directory structure:

project-root/
├── 01-admin/
│   ├── contracts/
│   ├── meeting-notes/
│   └── correspondence/
├── 02-design/
│   ├── concept/
│   ├── schematic/
│   ├── dd/
│   └── cd/
├── 03-drawings/
│   ├── architectural/
│   ├── structural/
│   ├── mep/
│   └── landscape/
├── 04-specs/
├── 05-submittals/
├── 06-field/
│   ├── photos/
│   ├── reports/
│   └── rfi/
├── 07-models/
│   ├── revit/
│   ├── exports/
│   └── renders/
└── project-info.json

3. Generate `project-info.json` with project metadata
4. Create a `README.md` with project overview

## Rules

- Verify the project number follows the YYYY-NNN format
- Never overwrite an existing directory structure
- All folder names must be lowercase with hyphens (no spaces)

Step 3: Test the skill.

Open Claude Code in your project directory and type:

/new-project

Claude Code will read the skill file and walk you through the process, asking for the project number, name, and type, then generating the entire directory structure.

Step 4: Iterate and refine.

After testing, you will likely discover improvements. Maybe you need additional folders for a specific project type, or you want the project-info.json to include more fields. Edit the SKILL.md file and test again. Since it is just a markdown file, changes take effect immediately on the next invocation.

How to Structure a Skill File for Maximum Effectiveness

The quality of your skill output depends entirely on how well you write the skill file. Here is a breakdown of what makes a skill file effective:

Essential sections every skill file needs:

Section	Purpose	Example
Title (H1)	Names the skill	# BIM Model Audit
Trigger	When to activate	”Use when the user says ‘audit model‘“
Inputs	What data it needs	File paths, parameters, user-provided values
Procedure	Step-by-step workflow	Numbered steps with clear actions
Output	What it produces	File paths, formats, structure
Rules	Constraints and guardrails	”Never modify source files”

Tips for writing effective procedures:

1. Be specific about file formats. Do not say “read the export file.” Say “read the CSV file at exports/revit/door-schedule.csv with columns: FamilyName, TypeName, Width, Height, FireRating.”

2. Include validation steps. Before Claude Code processes data, tell it what to check. “Verify the CSV has a header row. If columns are missing, report the error and stop.”

3. Define output format precisely. Show the exact structure of tables, reports, or files you expect. Include sample output if possible.

4. Add fallback instructions. What should happen if an input file is missing? If data is malformed? If a required parameter is empty? Explicit fallback handling prevents unexpected behavior.

5. Use constraints to prevent overreach. “Never modify source files” or “Do not create directories outside the project root” are important guardrails.

Here is an example of a poorly written versus well-written procedure step:

Weak: “Check the doors for fire rating compliance.”

Strong: “For each row in the door schedule CSV where the WallFireRating column is not empty, verify that the DoorFireRating value meets or exceeds the WallFireRating value. A 2-hour rated wall requires a minimum 90-minute rated door assembly. A 1-hour rated wall requires a minimum 45-minute rated door. Log each non-compliant door with its Mark, Location, WallFireRating, and DoorFireRating in the report.”

The difference is that the strong version gives Claude Code everything it needs to execute correctly without asking follow-up questions.

Combining Multiple Skills Into a Workflow

Individual skills are powerful, but the real efficiency gains come from chaining them together. You can create a “meta-skill” that orchestrates multiple skills in sequence.

For example, a project milestone review skill that runs before every client submission:

# Milestone Review

Run a complete project review before client submission.

## Trigger

Use when the user says "milestone review", "pre-submission check",
or "review for [milestone name]".

## Procedure

1. Run the BIM Model Audit skill (`/audit-model`)
   - If critical failures exist, stop and report
2. Run the Code Compliance Checker (`/check-code`)
   - Log all findings
3. Run the Material Schedule Generator (`/generate-schedule`)
   - Verify all materials have matching spec sections
4. Run the Drawing Sheet Setup validator (`/sheet-setup`)
   - Verify sheet numbering is complete and sequential
5. Compile all reports into a single milestone review document
   at `reports/milestone-review-YYYY-MM-DD.md`

## Output

The combined report should have these sections:
- Executive Summary (pass/fail status for each check)
- BIM Audit Results (from step 1)
- Code Compliance Results (from step 2)
- Material Schedule Status (from step 3)
- Drawing Set Status (from step 4)
- Action Items (combined list of all issues, sorted by priority)

## Rules

- Each sub-skill runs independently; a failure in one
  does not prevent others from running (except step 1 critical failures)
- The combined report must clearly attribute each finding
  to its source skill
- Include timestamps for each skill execution

This approach transforms Claude Code from a tool that handles individual tasks into a system that manages your quality assurance workflow end to end.

Practical tip: start with individual skills and combine them only after each one works reliably on its own. Debugging a meta-skill is much harder if the component skills have not been tested independently.

Skills for Team Collaboration

Skills stored in your project’s .claude/skills/ directory are part of your project files. This means they can be version-controlled with Git and shared across your entire team.

Benefits of shared skill libraries:

Individual Skills	Shared Team Skills
One person’s workflow	Standardized firm-wide process
Knowledge stays in one head	Knowledge encoded and transferable
Inconsistent output between team members	Consistent output across the firm
Lost when someone leaves	Persists with the project
No quality baseline	Built-in quality checks

How to set up shared skills for your team:

1. Create a firm-wide skills repository. This is a separate Git repository containing skills that apply to all projects: specification formatting, code compliance checks, firm standards.

2. Use Git submodules or copy scripts. You can include the shared skills repository as a Git submodule in each project, or use a setup script that copies the latest skills into a new project.

3. Establish a skill review process. Before adding a skill to the shared library, have another team member test it on a different project. Skills that work only for one specific project structure should stay local, not shared.

4. Version your skills. Include a version comment at the top of each skill file. When you update a shared skill, increment the version so team members know to pull the latest.

<!-- Skill Version: 2.3 | Last Updated: 2026-03-15 -->
# BIM Model Audit
...

5. Document skill dependencies. If a skill requires specific export formats, directory structures, or external tools, document those requirements clearly at the top of the skill file.

A word on onboarding: new team members can learn your firm’s workflows by reading the skill files. Each skill is essentially a documented procedure. This creates a form of institutional knowledge that survives staff turnover.

Common Mistakes When Creating Skills

After working with architects who build their own skills, these are the most frequent issues that lead to poor results:

1. Instructions that are too vague.

“Check the model for errors” gives Claude Code no actionable criteria. What counts as an error? What data is it checking? Where are the files? Vague instructions produce vague results.

2. No defined output format.

If you do not specify whether the output should be a markdown file, a CSV, a JSON document, or a terminal printout, Claude Code will choose for you. That choice may not match what you need.

3. Assuming Claude Code knows your firm’s conventions.

Claude Code does not know that your firm uses “A-” prefixes for architectural sheets or that door marks follow a specific pattern. Everything project-specific must be spelled out in the skill.

4. Missing error handling.

What happens when the input CSV has the wrong columns? When a file path does not exist? Without explicit fallback instructions, Claude Code may either guess (incorrectly) or fail without a clear error message.

5. Skills that are too large.

A 500-line skill file that tries to cover every possible scenario becomes hard to maintain and debug. Break complex workflows into smaller, focused skills and combine them with a meta-skill.

6. No test data.

Create sample input files that you can use to verify a skill works correctly. Without test data, you are testing skills on live project files, which is risky.

7. Forgetting to update skills when workflows change.

Skills are living documents. When your firm updates its BIM standards, the model audit skill needs to be updated too. Treat skill maintenance the same way you treat template maintenance.

Getting Started Checklist

Here is a practical checklist to start using skills in your architectural practice:

Week 1: Setup

• Install Claude Code if you have not already (official documentation)
• Create the .claude/skills/ directory in your current project
• Create your first skill: start with something simple like project directory setup or a file naming validator
• Test the skill with sample data and refine the instructions

Week 2: Core Skills

• Identify your three most repetitive tasks (documentation formatting, schedule generation, standards checking)
• Write a skill for each one
• Test each skill on at least two different data sets
• Refine based on results

Week 3: Integration

• Create a meta-skill that chains your core skills together
• Set up version control for your skills (add .claude/ to your Git repository)
• Share skills with one team member and get feedback
• Document any firm-specific conventions that skills depend on

Week 4: Expansion

• Roll out tested skills to the wider team
• Create a shared skills repository for firm-wide standards
• Set up a process for proposing and reviewing new skills
• Track time savings to quantify the investment

Resources to explore:

• Claude Code official documentation for the latest features and updates
• Our practical guide to Claude Code for architects for foundational workflows
• Your firm’s BIM execution plan as a starting point for audit skill criteria

The Future of AI-Assisted Architectural Practice

Skills represent a fundamental shift in how architects interact with AI tools. Rather than treating AI as a conversation partner you re-educate every session, skills turn AI into a trained team member that knows your processes, your standards, and your expectations.

The trajectory is clear. Firms that encode their workflows as skills will compound their efficiency advantages over time. Each new skill builds on previous ones. Each refinement makes the system more reliable. The institutional knowledge that typically lives in senior staff members’ heads becomes executable, testable, and transferable.

In practical terms, this means a junior architect with well-crafted skills can produce specification documents, audit models, and validate drawing sets at a quality level that previously required years of experience. The skills encode the experience; Claude Code executes it.

Looking ahead, the architecture firms that will benefit most from AI are not necessarily the ones with the biggest technology budgets. They are the ones that invest time in building high-quality skill libraries tailored to their specific practice. A 20-person firm with 50 well-written skills will outperform a 200-person firm using generic AI prompts.

The barrier to entry is low. You need Claude Code, a text editor, and a willingness to document your workflows in structured markdown. The skills you build today will continue to deliver value for years, evolving alongside your practice and the capabilities of the underlying AI.

Start with one skill. Test it. Refine it. Then build the next one. Within a few weeks, you will wonder how you ever worked without them.