How to Use AI (Claude + ChatGPT) for DevOps Automation in 2026

By Roland Ndah | NdaKum Consulting Services

If you are a DevOps engineer in 2026, AI is no longer optional. It is the difference between a team that ships confidently and a team that is constantly fighting fires. In this post, I will show you exactly how I use Claude and ChatGPT to automate real DevOps tasks — from reviewing pull requests to monitoring CI/CD pipelines and writing infrastructure code.

This is not a theoretical overview. These are tools and workflows I use daily as a Cloud and DevSecOps engineer.

Why AI + DevOps Is the Biggest Shift Since the Cloud

Five years ago, the biggest shift in DevOps was moving infrastructure to the cloud. Today, the shift is wiring AI into every layer of the software delivery pipeline.

According to the 2026 State of DevOps Report, over 90% of software professionals now use AI tools at work. And 63% of security professionals report that AI has become a helpful copilot for writing more secure code and automating application security testing.

The engineers who learn to work with AI tools now will be the senior engineers and consultants of 2028.

The Two AI Tools Every DevOps Engineer Should Know

Claude (by Anthropic)

Claude is the AI I reach for when I need precise, reasoning-heavy tasks — writing Terraform modules, reviewing complex pull requests, analyzing incident logs, and building AI agents that connect to my internal tools via the API.

Claude excels at:

Writing and reviewing infrastructure as code (Terraform, CloudFormation, Ansible)
Building agentic workflows using function calling and MCP
Analyzing long log files and incident reports
Writing and explaining CI/CD pipeline YAML

ChatGPT (by OpenAI)

ChatGPT is strong for brainstorming, drafting runbooks, and quick code generation. Where Claude tends to be more precise and cautious, ChatGPT is faster for first drafts.

First-draft runbooks and documentation
Quick Python and Bash scripts
Explaining errors in plain English
Generating test cases fast

Bottom line: Use both. They complement each other. Claude for depth and agents, ChatGPT for speed and drafting.

5 Real Ways I Use AI in My DevOps Workflow

1. AI-Powered Pull Request Reviews

Manually reviewing every PR is time-consuming and inconsistent. I built a Claude-powered agent that automatically reviews pull requests when they are opened — checking for security issues, hardcoded secrets, missing tests, and code quality problems.

Here is the core Python pattern:

import anthropic
import requests

client = anthropic.Anthropic()

def review_pull_request(repo, pr_number):
    response = requests.get(
        f"https://api.github.com/repos/{repo}/pulls/{pr_number}/files",
        headers={"Authorization": f"Bearer {GITHUB_TOKEN}"}
    )
    diff = response.json()

    review = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": f"""Review this pull request diff for:
            1. Security vulnerabilities or hardcoded secrets
            2. Missing error handling
            3. Missing tests
            4. Code quality issues
            Diff: {diff}
            Provide a structured review with severity ratings."""
        }]
    )
    return review.content[0].text

This runs automatically via a GitHub Actions workflow. Every PR gets a structured AI review within 60 seconds of being opened — before a human reviewer even looks at it.

2. CI/CD Pipeline Monitoring and Auto-Issue Creation

Failed pipelines at 3am are painful. I built a monitoring agent that checks GitHub Actions every morning, identifies failures, and automatically creates GitHub issues with the error details — tagged and assigned to the right person. It reduces mean time to resolution (MTTR) by getting the right information to the right person immediately.

3. AI-Assisted Infrastructure as Code

Writing Terraform from scratch is slow. I use Claude to generate first-draft modules which I then review and refine. Here is a real example prompt I use:

“Write a Terraform module that creates an EKS cluster on AWS with node groups, IAM roles with least privilege, CloudWatch logging enabled, and a security group that only allows traffic from within the VPC. Include variables for environment name, region, and instance type.”

Claude generates a complete, production-ready module in seconds. This alone saves me 2 to 3 hours per infrastructure task.

4. Incident Analysis and Root Cause Identification

When an incident happens, I paste CloudWatch logs or Splunk output directly into Claude with this prompt:

“Analyze these logs. Identify the root cause, timeline of events, and suggest immediate remediation steps and long-term fixes.”

What used to take 30 minutes of manual log digging now takes 2 minutes.

5. Runbook Generation and Documentation

I describe a process to Claude in plain English and it generates a formatted runbook with numbered steps, warnings, rollback procedures, and verification steps. This increased our team runbook coverage from 40% to over 90% in three months.

How to Connect Claude to Your Internal DevOps Tools

Option 1 — Function Calling (Python SDK)

Define your internal tools as a JSON schema. Claude decides when to call them. Your code executes the actual API calls. Best for connecting to GitHub, AWS, Jira, or Splunk.

tools = [
    {
        "name": "get_pipeline_status",
        "description": "Get the current status of a CI/CD pipeline run",
        "input_schema": {
            "type": "object",
            "properties": {
                "repo": {"type": "string"},
                "branch": {"type": "string"}
            },
            "required": ["repo"]
        }
    }
]

Option 2 — MCP (Model Context Protocol)

MCP lets you wrap your internal tools as a server that Claude Code connects to natively — no glue code needed per tool. Best for multi-tool agent systems.

claude mcp add github \
  --env GITHUB_TOKEN=$GITHUB_TOKEN \
  -- npx -y @modelcontextprotocol/server-github

Common Mistakes to Avoid

Blindly trusting AI output. Always review generated Terraform, pipeline configs, and scripts before running them in production. AI is a fast first draft — not a final answer.

Not giving enough context. “Write a CI/CD pipeline” gets you a generic result. The more specific your prompt, the more usable the output.

Ignoring security. Never paste production secrets, customer data, or proprietary code into a public AI tool. Use the API with your own secure environment instead.

Getting Started Today

Install Claude Code and use it for your next Terraform module
Use Claude to write your next runbook from a verbal description
Paste your next failed pipeline log into Claude and ask it to identify the root cause
Write one Python function calling agent that connects Claude to your most-used internal API

Each of these is a 30-minute project. In a month you will have an AI-augmented workflow that makes you measurably faster and more effective.

Final Thoughts

AI is not replacing DevOps engineers. It is multiplying them. The engineers who learn to work with Claude and ChatGPT today will accomplish in an hour what used to take a day — and they will be the ones companies pay top dollar for.

Start with one task. Automate it with AI. Then do another. That is the path from DevOps engineer to AI-powered DevOps engineer.

About the Author: Roland Ndah is a Cloud and DevSecOps Engineer specializing in AI automation, AWS, Kubernetes, and CI/CD pipelines. He helps organizations build faster, more secure software delivery pipelines through NdaKum Consulting Services.

Want to automate your DevOps pipeline with AI? Book a free 30-minute strategy session and let us talk about what is possible for your team.

Have Questions?

Visit us