Terraform Patterns Skill for Claude

> This skill should be used when the user asks to "analyze Terraform modules", "scan IaC for security issues", "review Terraform configurations", "check infrastructure code for misconfigurations", or "audit cloud resources".

11k tokens

context cost

the whole folder, loaded on every use

files

ships runnable scripts

copies elsewhere

how many repositories repackaged it

447

stars on the repo

on the repository, not the skill itself

Install

one command, takes just this skill from the repository

npx skills add https://github.com/borghei/Claude-Skills --skill terraform-patterns

What comes with it

39 782 bytes besides the instruction

examples/main.tf

references/terraform-patterns.md

scripts/tf_module_analyzer.py

scripts/tf_security_scanner.py

The instruction itself

16 sections, as written by the author

Terraform Patterns

> Category: Engineering

> Domain: Infrastructure as Code

Overview

The Terraform Patterns skill provides automated analysis of Terraform configurations for module complexity, security misconfigurations, and infrastructure best practices. It catches open ports, public buckets, missing encryption, and overly permissive IAM policies before they reach production.

Clarify First

Before analyzing or scanning, confirm these inputs. If any is unknown or vague, ASK — do not assume:

[ ] Target path — the module or environment directory to analyze (--path; the subject)
[ ] Task — module complexity/quality analysis vs security misconfiguration scan (selects tf_module_analyzer vs tf_security_scanner)
[ ] Minimum severity / gate — the severity bar for findings and whether it blocks a PR (--min-severity; changes the report and CI pass/fail)

Stop rule: ask only the 2-3 that most change the output. If the user says "just draft it," proceed and list your assumptions at the top of the artifact.

Quick Start

# Analyze Terraform module structure and complexity
python scripts/tf_module_analyzer.py --path ./modules/vpc

# Scan for security misconfigurations
python scripts/tf_security_scanner.py --path ./environments/production

# JSON output for CI pipelines
python scripts/tf_security_scanner.py --path . --format json

# Recursive analysis of all modules
python scripts/tf_module_analyzer.py --path . --recursive

Tools Overview

tf_module_analyzer.py

Analyzes Terraform modules for complexity, structure, dependencies, and documentation quality.

| Feature | Description |

|---------|-------------|

| Complexity scoring | Scores modules by resource count, variable count, nesting |

| Dependency mapping | Maps module dependencies and data source usage |

| Variable analysis | Checks for missing types, defaults, descriptions |

| Output completeness | Validates output documentation and coverage |

| Naming conventions | Checks resource and variable naming patterns |

tf_security_scanner.py

Scans Terraform configurations for security misconfigurations and compliance violations.

| Feature | Description |

|---------|-------------|

| Open ports | Detects 0.0.0.0/0 CIDR in security groups |

| Public access | Flags public S3 buckets, databases, instances |

| Encryption gaps | Checks for missing encryption at rest and in transit |

| IAM overreach | Identifies wildcard actions and overly broad policies |

| Logging gaps | Verifies CloudTrail, flow logs, access logging |

Workflows

Security Review Workflow

Scan - Run tf_security_scanner.py across all environments
Triage - Prioritize critical findings (public data, open access)
Remediate - Apply recommended fixes per finding
Verify - Re-scan to confirm fixes resolved issues
Gate - Add scanner to PR checks for continuous enforcement

Module Quality Workflow

Analyze - Run tf_module_analyzer.py on each module
Score - Review complexity scores, identify modules over threshold
Refactor - Break down modules scoring above 70/100 complexity
Document - Fill in missing variable and output descriptions
Standardize - Apply consistent naming and file organization

CI Integration

# Security gate
python scripts/tf_security_scanner.py --path . --format json --min-severity high
if [ $? -ne 0 ]; then
  echo "Security scan failed - blocking merge"
  exit 1
fi

# Module quality check
python scripts/tf_module_analyzer.py --path . --recursive --format json

Reference Documentation

Terraform Patterns - Module design, state management, naming conventions

Common Patterns Quick Reference

Module Structure

modules/vpc/
  main.tf           # Primary resources
  variables.tf      # Input variables with descriptions
  outputs.tf        # Module outputs
  versions.tf       # Required providers and versions
  locals.tf         # Local values and computed expressions

Security Checklist

| Resource | Check | Rule |

|----------|-------|------|

| Security Groups | No 0.0.0.0/0 ingress | Restrict to known CIDRs |

| S3 Buckets | No public ACLs | Use bucket policies instead |

| RDS | No public access | Set publicly_accessible = false |

| EBS/S3/RDS | Encryption enabled | Add encryption configuration |

| IAM | No wildcard actions | Use least-privilege policies |

| CloudTrail | Enabled in all regions | is_multi_region_trail = true |

| VPC | Flow logs enabled | Create flow log resources |

Complexity Scoring

| Score | Rating | Action |

|-------|--------|--------|

| 0-30 | Low | No action needed |

| 31-60 | Medium | Consider splitting |

| 61-80 | High | Should refactor |

| 81-100 | Critical | Must refactor |

Other skills for the same job

different authors, same section of the catalogue

Azure Kubernetes Automatic Readiness

by microsoft

vendor ×3

Assess Kubernetes workloads and cluster configuration for AKS Automatic compatibility. Identifies incompatibilities, generates fixes, and guides migration from AKS Standard to AKS Automatic. WHEN: migrate to AKS Automatic, check AKS Automatic readiness, validate manifests for Automatic, assess cluster for Automatic compatibility, fix deployment for Automatic compatibility, identify AKS Automatic migration blockers, is my cluster ready for AKS Automatic.

Discovers available Azure OpenAI model capacity across regions and projects. Analyzes quota limits, compares availability, and recommends optimal deployment locations based on capacity requirements. USE FOR: find capacity, check quota, where can I deploy, capacity discovery, best region for capacity, multi-project capacity search, quota analysis, model availability, region comparison, check TPM availability. DO NOT USE FOR: actual deployment (hand off to preset or customize after discovery), quota increase requests (direct user to Azure Portal), listing existing deployments.

Interactive guided deployment flow for Azure OpenAI models with full customization control. Step-by-step selection of model version, SKU (GlobalStandard/Standard/ProvisionedManaged), capacity, RAI policy (content filter), and advanced options (dynamic quota, priority processing, spillover). USE FOR: custom deployment, customize model deployment, choose version, select SKU, set capacity, configure content filter, RAI policy, deployment options, detailed deployment, advanced deployment, PTU deployment, provisioned throughput. DO NOT USE FOR: quick deployment to optimal region (use preset).

Unified Azure OpenAI model deployment skill with intelligent intent-based routing. Handles quick preset deployments, fully customized deployments (version/SKU/capacity/RAI policy), and capacity discovery across regions and projects. USE FOR: deploy model, deploy gpt, create deployment, model deployment, deploy openai model, set up model, provision model, find capacity, check model availability, where can I deploy, best region for model, capacity analysis. DO NOT USE FOR: listing existing deployments (use foundry_models_deployments_list MCP tool), deleting deployments, agent creation (use agent/create), project creation (use project/create).

Intelligently deploys Azure OpenAI models to optimal regions by analyzing capacity across all available regions. Automatically checks current region first and shows alternatives if needed. USE FOR: quick deployment, optimal region, best region, automatic region selection, fast setup, multi-region capacity check, high availability deployment, deploy to best location. DO NOT USE FOR: custom SKU selection (use customize), specific version selection (use customize), custom capacity configuration (use customize), PTU deployments (use customize).

This skill should be used when working with LaminDB, an open-source data framework for biology that makes data queryable, traceable, reproducible, and FAIR. Use when managing biological datasets (scRNA-seq, spatial, flow cytometry, etc.), tracking computational workflows, curating and validating data with biological ontologies, building data lakehouses, or ensuring data lineage and reproducibility in biological research. Covers data management, annotation, ontologies (genes, cell types, diseases, tissues), schema validation, integrations with workflow managers (Nextflow, Snakemake) and MLOps platforms (W&B, MLflow), and deployment strategies.

Latch platform for bioinformatics workflows. Build pipelines with Latch SDK, @workflow/@task decorators, deploy serverless workflows, LatchFile/LatchDir, Nextflow/Snakemake integration.

Run Python code in the cloud with serverless containers, GPUs, and autoscaling. Use when deploying ML models, running batch processing jobs, scheduling compute-intensive tasks, or serving APIs that require GPU acceleration or dynamic scaling.

17k tokens

How to use it

Copy the folder

Take borghei/terraform-patterns from the repository into ~/.claude/skills for personal use, or into .claude/skills inside a project.

Check the name does not clash

The agent identifies a skill by the name field in its header. Two skills with the same name cannot sit side by side — one of them will be ignored.