Supercharging Terraform Development with Claude Code and Terraform MCP Server

As Infrastructure as Code (IaC) becomes increasingly complex, developers need smarter tools that understand not just syntax, but the entire ecosystem of providers, modules, and best practices. In this post, I'll walk you through my experience using Claude Code with HashiCorp's Terraform MCP Server to generate production-ready Terraform configurations.

📌 Note: This article references AWS provider version 6.30.0 and S3 module version 5.10.0, which were the latest versions at the time of writing (January 2026). When you use the Terraform MCP Server, Claude will automatically fetch the current latest versions for you — that's the whole point!

What is MCP (Model Context Protocol)?

MCP (Model Context Protocol) is an open protocol that allows AI assistants to connect with external tools and data sources. Think of it as a bridge that gives AI models access to real-time information and specialized capabilities.

For Terraform, this means Claude can query the Terraform Registry directly to get:

• Latest provider versions
• Module documentation
• Input/output specifications
• Usage examples

The Problem: AI Without Real-Time Context

Before diving into the solution, let's understand what happens when you use an AI assistant for Terraform without MCP integration:

Without Terraform MCP Server

# Claude might generate this based on training data
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 4.16"  # Outdated! Current version is 6.30.0
    }
  }
}

module "s3_bucket" {
  source  = "terraform-aws-modules/s3-bucket/aws"
  version = "3.6.0"  # Outdated! Current version is 5.10.0

  # May use deprecated arguments or miss new features
  bucket_name = "my-bucket"  # Wrong! Should be 'bucket'
  acl         = "private"    # Deprecated in newer versions
}

Issues you might encounter:

• Outdated versions: AI models have knowledge cutoffs and may suggest old provider/module versions
• Deprecated arguments: Module APIs change over time
• Missing security features: Newer versions often include security improvements
• Incompatibility: Old module versions may not work with newer providers

With Terraform MCP Server

# Claude generates this with real-time registry data
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 6.28"  # Current and compatible
    }
  }
}

module "s3_bucket" {
  source  = "terraform-aws-modules/s3-bucket/aws"
  version = "5.10.0"  # Latest version

  bucket_prefix = "my-app-"

  # Modern security defaults
  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true

  server_side_encryption_configuration = {
    rule = {
      apply_server_side_encryption_by_default = {
        sse_algorithm = "AES256"
      }
    }
  }
}

Installing Terraform MCP Server in Claude Code

Prerequisites

• Claude Code CLI installed
• Docker installed and running

Step 1: Add the MCP Server

Run the following command to add HashiCorp's Terraform MCP server to your Claude Code configuration:

claude mcp add terraform -s user -t stdio -- docker run -i --rm hashicorp/terraform-mcp-server

Let's break down this command:

Step 2: Verify Installation

Check that the server is configured and connected:

claude mcp list

You should see:

terraform: docker run -i --rm hashicorp/terraform-mcp-server - Connected

Step 3: Start Using It

Start a new Claude Code session to load the MCP tools:

claude

You can verify the available tools by asking Claude:

What terraform tools are available?

Available Terraform MCP Tools

Once connected, Claude has access to these tools:

Real-World Example: Creating an S3 Module

Let me walk you through what happened when I asked Claude to create an S3 module:

My Request

please create s3 module using terraform modules from the community

What Claude Did Behind the Scenes

1. Searched for S3 Modules

Claude used search_modules to query the Terraform Registry:

{
  "module_query": "aws s3 bucket"
}

This returned 15+ modules, ranked by downloads and relevance:

2. Retrieved Module Details

Claude used get_module_details to fetch complete documentation:

{
  "module_id": "terraform-aws-modules/s3-bucket/aws/5.10.0"
}

This returned:

• All input variables with types and defaults
• All outputs with descriptions
• Provider requirements (AWS >= 6.28)
• Usage examples for different scenarios

3. Generated the Module Wrapper

With accurate, up-to-date information, Claude created a module wrapper with:

• Correct provider version constraints
• Modern security defaults (public access blocks, encryption)
• Properly typed variables
• Comprehensive outputs

The Result

modules/s3/
├── main.tf       # Uses terraform-aws-modules/s3-bucket/aws v5.10.0
├── variables.tf  # All inputs properly typed with secure defaults
├── outputs.tf    # All module outputs exposed
└── versions.tf   # Correct provider constraints (>= 6.28)

Visualizing the Flow

Here's how Claude Code, the Terraform MCP Server, and the Terraform Registry worked together during this process:

┌─────────────────────┐     ┌────────────────────────┐     ┌─────────────────────┐
│    Claude Code      │────▶│  Terraform MCP Server  │────▶│  Terraform Registry │
│    (Assistant)      │     │  (Docker Container)    │     │        API          │
└─────────────────────┘     └────────────────────────┘     └─────────────────────┘
          │                           │                              │
          │  1. get_latest_provider   │                              │
          │     version (aws)         │─────────────────────────────▶│
          │                           │◀─────────────────────────────│
          │                           │        Returns: 6.30.0       │
          │                           │                              │
          │  2. search_modules        │                              │
          │     (aws s3 bucket)       │─────────────────────────────▶│
          │                           │◀─────────────────────────────│
          │                           │   Returns: 15 modules ranked │
          │                           │                              │
          │  3. get_module_details    │                              │
          │     (terraform-aws-       │─────────────────────────────▶│
          │      modules/s3-bucket)   │◀─────────────────────────────│
          │                           │   Returns: Full docs, inputs │
          │                           │   outputs, examples          │
          ▼                           │                              │
┌─────────────────────┐               │                              │
│   Generated Code    │               │                              │
│   with correct      │               │                              │
│   versions &        │               │                              │
│   configurations    │               │                              │
└─────────────────────┘

Comparison: With vs Without MCP

claude mcp add-json terraform '{
  "command": "docker",
  "args": ["run", "-i", "--rm", "hashicorp/terraform-mcp-server"],
  "env": {}
}'

claude mcp add terraform -s project -t stdio -- docker run -i --rm hashicorp/terraform-mcp-server

claude mcp add terraform -s user -t stdio \
  -e TFE_TOKEN=your-token-here \
  -- docker run -i --rm hashicorp/terraform-mcp-server

Using with Other MCP Clients

This post focuses on Claude Code, but the Terraform MCP server works with any MCP-compatible client including Claude Desktop, VS Code extensions, and custom applications. For detailed installation instructions for other clients, check out the official Terraform MCP Server documentation.

Key Takeaways

• MCP bridges the knowledge gap — AI models have training cutoffs, but MCP provides real-time access to current information.
• Better code quality — With accurate documentation, Claude generates code that follows current best practices and uses modern security features.
• Reduced debugging — No more hunting for deprecated arguments or version conflicts.
• Faster development — Claude can search the entire Terraform Registry to find the best modules for your use case.
• Easy setup — One command to install, and you're ready to go.

Conclusion

The combination of Claude Code and Terraform MCP Server transforms how we write infrastructure code. Instead of relying on potentially outdated training data, Claude can query the Terraform Registry in real-time to ensure your configurations use the latest versions, follow current best practices, and leverage the best community modules available.

If you're working with Terraform regularly, I highly recommend setting up the MCP server. The few minutes it takes to install will save you hours of debugging version conflicts and deprecated arguments.

Have questions about Terraform, AWS infrastructure, or DevOps automation? I'm a Senior DevOps Engineer specializing in cloud infrastructure and IaC. Get in touch — I'd love to help!

Resources

• Terraform MCP Server - HashiCorp Developer
• Terraform MCP Server - GitHub
• Terraform MCP Server - Docker Hub
• Claude Code Documentation
• Model Context Protocol Specification