AI Agents for Automated Terraform Code Review — The Future of IaC Quality

# .github/workflows/terraform-review.yml
- name: Trivy IaC Scan
  uses: aquasecurity/trivy-action@master
  with:
    scan-type: config
    scan-ref: ./terraform
    severity: HIGH,CRITICAL
    exit-code: 1

- name: Checkov Scan
  uses: bridgecrewio/checkov-action@master
  with:
    directory: ./terraform
    framework: terraform
    output_format: sarif
    soft_fail: false

- name: Infracost Cost Estimation
  uses: infracost/actions/setup@v3
  with:
    api-key: ${{ secrets.INFRACOST_API_KEY }}
- run: |
    infracost diff --path=./terraform \
      --format=json \
      --out-file=/tmp/infracost.json
    infracost comment github \
      --path=/tmp/infracost.json \
      --repo=${{ github.repository }} \
      --pull-request=${{ github.event.pull_request.number }} \
      --github-token=${{ secrets.GITHUB_TOKEN }}

# terraform_reviewer.py
import subprocess
import json
from anthropic import Anthropic
 
client = Anthropic()
 
def get_terraform_diff() -> str:
    """Get the Terraform changes in the current PR."""
    result = subprocess.run(
        ["git", "diff", "origin/main...HEAD", "--", "*.tf", "*.tfvars"],
        capture_output=True, text=True
    )
    return result.stdout
 
def get_terraform_plan() -> str:
    """Run terraform plan and capture output."""
    subprocess.run(["terraform", "init", "-backend=false"], capture_output=True)
    result = subprocess.run(
        ["terraform", "plan", "-no-color", "-json"],
        capture_output=True, text=True
    )
    return result.stdout
 
def review_terraform(diff: str, plan: str) -> str:
    """Send Terraform changes to Claude for review."""
    prompt = f"""You are a senior infrastructure engineer reviewing a Terraform pull request.
 
Analyze the following Terraform changes and plan output. Provide a review covering:
 
## Security Review
- IAM policies: are they least-privilege? Flag any `*` in actions or resources
- Network security: are security groups, NACLs, or firewall rules too permissive?
- Encryption: are all data stores encrypted at rest and in transit?
- Secrets: are any credentials, API keys, or sensitive values hardcoded?
- Public exposure: are any resources unnecessarily public?
 
## Cost Review
- Identify the most expensive resources being created/modified
- Suggest cheaper alternatives where appropriate (e.g., reserved instances, smaller instance types, S3 storage classes)
- Flag any resources that might scale unexpectedly
 
## Best Practices
- Are resources properly tagged?
- Is the code modular and DRY?
- Are variables used for configurable values?
- Is state management appropriate?
- Are `count` and `for_each` used correctly?
 
## Blast Radius
- What resources are being destroyed or replaced?
- Are there any unexpected cascading changes?
- Is `prevent_destroy` set on critical resources?
 
## Summary
- Overall risk assessment: LOW / MEDIUM / HIGH
- Top 3 issues to address before merge
- Approval recommendation: APPROVE / REQUEST CHANGES / BLOCK
 
---
 
Terraform Diff:
{diff}
 
Terraform Plan Output:
{plan[:50000]}
"""
 
    response = client.messages.create(
        model="claude-sonnet-4-5-20250514",
        max_tokens=4096,
        messages=[{"role": "user", "content": prompt}]
    )
    return response.content[0].text
 
 
def post_review_comment(review: str, pr_number: str):
    """Post the review as a PR comment."""
    import os
    subprocess.run([
        "gh", "pr", "comment", pr_number,
        "--body", f"## AI Terraform Review\n\n{review}"
    ], env=dict(os.environ))
 
 
if __name__ == "__main__":
    import sys
 
    diff = get_terraform_diff()
    if not diff.strip():
        print("No Terraform changes detected.")
        sys.exit(0)
 
    plan = get_terraform_plan()
 
    print("Running AI review...")
    review = review_terraform(diff, plan)
 
    pr_number = sys.argv[1] if len(sys.argv) > 1 else None
    if pr_number:
        post_review_comment(review, pr_number)
        print(f"Review posted to PR #{pr_number}")
    else:
        print(review)

# .github/workflows/ai-terraform-review.yml
name: AI Terraform Review
on:
  pull_request:
    paths:
      - 'terraform/**'
      - '*.tf'
 
jobs:
  ai-review:
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
      contents: read
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - uses: hashicorp/setup-terraform@v3
 
      - name: Install dependencies
        run: pip install anthropic
 
      - name: Run AI Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: python terraform_reviewer.py ${{ github.event.pull_request.number }}

def check_with_context(violation: dict, diff: str) -> dict:
    """Use AI to add context to policy violations."""
    prompt = f"""A Terraform policy check found this violation:
 
Rule: {violation['rule']}
Resource: {violation['resource']}
Message: {violation['message']}
 
Here's the full Terraform diff for context:
{diff}
 
Analyze this violation:
1. Is this a genuine issue or a false positive? (Consider the resource type and use case)
2. What's the severity? (Critical / High / Medium / Low)
3. How should it be fixed? (Provide the corrected HCL code)
4. What's the business risk if not fixed?
 
Be concise and practical."""
 
    response = client.messages.create(
        model="claude-sonnet-4-5-20250514",
        max_tokens=1024,
        messages=[{"role": "user", "content": prompt}]
    )
 
    result = dict(violation)
    result["ai_analysis"] = response.content[0].text
    return result

# digger.yml
projects:
  - name: production
    dir: terraform/production
    ai_summary: true  # LLM summarizes plan changes

# atlantis.yaml
workflows:
  default:
    plan:
      steps:
        - init
        - plan
        - run: python /scripts/ai-review.py $PLANFILE