<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Yogesh VK</title>
    <description>The latest articles on DEV Community by Yogesh VK (@yogesh_vk).</description>
    <link>https://dev.to/yogesh_vk</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F3821385%2Fce580426-0152-47ef-a0df-c1df7d4f33bb.png</url>
      <title>DEV Community: Yogesh VK</title>
      <link>https://dev.to/yogesh_vk</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/yogesh_vk"/>
    <language>en</language>
    <item>
      <title>AI and the Illusion of "Safe" Automation in Kubernetes</title>
      <dc:creator>Yogesh VK</dc:creator>
      <pubDate>Sat, 17 Oct 2026 06:45:44 +0000</pubDate>
      <link>https://dev.to/yogesh_vk/ai-and-the-illusion-of-safe-automation-in-kubernetes-pk</link>
      <guid>https://dev.to/yogesh_vk/ai-and-the-illusion-of-safe-automation-in-kubernetes-pk</guid>
      <description>&lt;p&gt;A few days ago, I was looking at a Kubernetes Deployment manifest generated by an LLM. It was syntactically flawless. Indentation was spot-on, standard API versions were used, and labels were neatly mapped. If you ran &lt;code&gt;kubectl apply --dry-run=client -f deployment.yaml&lt;/code&gt;, the API server wouldn't emit a single warning.&lt;br&gt;
To a junior engineer or a platform team looking to accelerate delivery, this output looks like a victory. The code is clean, valid, and immediately actionable.&lt;br&gt;
Yet, applying that manifest to a live cluster would have silently degraded a production service during the next routine node drain.&lt;br&gt;
This is the central paradox of AI-driven automation in Kubernetes: AI excels at producing syntactically valid manifests, but it is completely blind to operational safety. Because Kubernetes declarative model accepts whatever valid state you define, a "successful" deployment can easily disguise a ticking operational disaster.&lt;/p&gt;


&lt;h2&gt;
  
  
  The Green Checkmark Trap
&lt;/h2&gt;

&lt;p&gt;Imagine asking an AI assistant to generate a production-ready manifest for a microservice:&lt;br&gt;
"Generate a Kubernetes Deployment for a Python API with 3 replicas, resource limits, and a readiness probe."&lt;br&gt;
The model responds instantly with something like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;apiVersion&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;apps/v1&lt;/span&gt;
&lt;span class="na"&gt;kind&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Deployment&lt;/span&gt;
&lt;span class="na"&gt;metadata&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;payment-api&lt;/span&gt;
  &lt;span class="na"&gt;namespace&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;payment&lt;/span&gt;
&lt;span class="na"&gt;spec&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;replicas&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;3&lt;/span&gt;
  &lt;span class="na"&gt;selector&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;matchLabels&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
      &lt;span class="na"&gt;app&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;payment-api&lt;/span&gt;
  &lt;span class="na"&gt;template&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;metadata&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
      &lt;span class="na"&gt;labels&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
        &lt;span class="na"&gt;app&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;payment-api&lt;/span&gt;
    &lt;span class="na"&gt;spec&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
      &lt;span class="na"&gt;containers&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
      &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;api&lt;/span&gt;
        &lt;span class="na"&gt;image&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;internal-registry.net/payment-api:v1.2.3&lt;/span&gt;
        &lt;span class="na"&gt;resources&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
          &lt;span class="na"&gt;requests&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="na"&gt;cpu&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;100m"&lt;/span&gt;
            &lt;span class="na"&gt;memory&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;128Mi"&lt;/span&gt;
          &lt;span class="na"&gt;limits&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="na"&gt;cpu&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;500m"&lt;/span&gt;
            &lt;span class="na"&gt;memory&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;256Mi"&lt;/span&gt;
        &lt;span class="na"&gt;readinessProbe&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
          &lt;span class="na"&gt;httpGet&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="na"&gt;path&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;/healthz&lt;/span&gt;
            &lt;span class="na"&gt;port&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;8080&lt;/span&gt;
          &lt;span class="na"&gt;initialDelaySeconds&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;5&lt;/span&gt;
          &lt;span class="na"&gt;periodSeconds&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;10&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;At first glance, it checks every box. It sets resource bounds, handles health checks, and guarantees high availability across three pods. It passes CI/CD linting, passes client-side validation, and applies without error.&lt;br&gt;
The illusion of safety is complete. But let's look at what the AI doesn't see.&lt;/p&gt;
&lt;h2&gt;
  
  
  What the Manifest Leaves&amp;nbsp;Behind
&lt;/h2&gt;

&lt;p&gt;When Kubernetes applies a manifest, it doesn't evaluate your intent; it evaluates the literal declaration against the current cluster state. The AI generated a valid object, but it ignored the environment.&lt;br&gt;
Here are three hidden operational failure modes embedded in that seemingly "safe" YAML:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;1. The Disruption Budget Blindspot&lt;/strong&gt;&lt;br&gt;
You have three replicas requested, which implies redundancy. However, the AI generated a standalone Deployment object. It didn't generate a PodDisruptionBudget (PDB).&lt;br&gt;
If an automated node auto-scaler or a cluster upgrade drains the node hosting two of those pods simultaneously, Kubernetes will happily evict them. Without a PDB enforcing minAvailable: 2, your high-availability service drops to a single pod-or goes entirely offline-during routine maintenance. The AI saw a Deployment; an SRE sees a missing safety net.&lt;br&gt;
&lt;strong&gt;2. OOMKills and Unseen Workload&amp;nbsp;Profiles&lt;/strong&gt;&lt;br&gt;
The limits are set to 256Mi of memory. Where did that number come from?&lt;br&gt;
The LLM selected a standard, generic default based on general training patterns. But it doesn't know that during peak hours, your Python API spawns worker threads that consume up to 350Mi under burst traffic. The moment traffic spikes, &lt;/p&gt;

&lt;p&gt;the Linux kernel's OOM Killer will step in and terminate the pods. The YAML was syntactically correct, but operationally starved.&lt;br&gt;
&lt;strong&gt;3. Anti-Affinity and Single-Point-of-Failure Scheduling&lt;/strong&gt;&lt;br&gt;
Three replicas sound safe until the default scheduler places all three pods on the exact same underlying worker node because it happens to have available capacity.&lt;br&gt;
Unless explicitly configured with podAntiAffinity or topologySpreadConstraints, those three replicas offer zero real fault tolerance if that underlying AWS EC2 instance suffers a hardware failure.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="c1"&gt;# What an experienced engineer knows to add for real safety:&lt;/span&gt;
&lt;span class="na"&gt;topologySpreadConstraints&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
&lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;maxSkew&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;1&lt;/span&gt;
  &lt;span class="na"&gt;topologyKey&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;topology.kubernetes.io/zone&lt;/span&gt;
  &lt;span class="na"&gt;whenUnsatisfiable&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;DoNotSchedule&lt;/span&gt;
  &lt;span class="na"&gt;labelSelector&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;matchLabels&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
      &lt;span class="na"&gt;app&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;payment-api&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The AI didn't include topology constraints because your prompt didn't explicitly ask for multi-zone fault isolation. It gave you exactly what you asked for, not what your cluster required.&lt;/p&gt;




&lt;h2&gt;
  
  
  Syntactic Validity vs. Operational Correctness
&lt;/h2&gt;

&lt;p&gt;The danger with AI in platform engineering isn't that it generates bad code; it's that it generates convincing code.&lt;br&gt;
In traditional software development, broken logic usually manifests as a compilation error, a failed unit test, or a stack trace. In Kubernetes, invalid operational logic doesn't crash on application - it waits silently until a node fails, a deployment rolls out, or network traffic spikes.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0d6o5hlwsj32e736j3bk.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0d6o5hlwsj32e736j3bk.png" alt=" " width="800" height="709"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;When we rely on AI to generate infrastructure manifests without deep contextual integration, we confuse syntactic validity with operational correctness.&lt;br&gt;
Syntactic validity means the API server can parse the structure.&lt;br&gt;
Operational correctness converter means the workload behaves safely under degraded network conditions, cluster autoscaling, node evictions, and rolling updates.&lt;/p&gt;

&lt;p&gt;AI understands schema; engineers understand behavior under stress.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where AI Actually Belongs in Kubernetes Workflows
&lt;/h2&gt;

&lt;p&gt;Does this mean we shouldn't use AI for Kubernetes? Not at all. It means we need to shift our expectations from generation to contextual evaluation.&lt;br&gt;
Instead of asking AI to write raw manifests from scratch and piping them into kubectl apply, a much safer paradigm leverages AI as a context-aware auditor and reviewer.&lt;br&gt;
&lt;strong&gt;1. Policy Generation Over Manifest Generation&lt;/strong&gt;&lt;br&gt;
Use AI to help author OPA Gatekeeper policies, Kyverno rules, or Datree checks. Instead of relying on the AI to remember to include a PDB or topology spread constraints in every single Deployment, use it to generate the admission control rules that enforce those safety standards cluster-wide.&lt;br&gt;
&lt;strong&gt;2. Explaining State Drift and Rollout&amp;nbsp;Failures&lt;/strong&gt;&lt;br&gt;
AI shines when analyzing dynamic state rather than static text. Feeding a failed kubectl describe pod output, event logs, and deployment specs into an LLM to quickly summarize why a image pull backoff or probe failure is occurring leverages its fast pattern-matching capabilities without granting it execution authority.&lt;br&gt;
&lt;strong&gt;3. Drafting Base Templates for Human Refinement&lt;/strong&gt;&lt;br&gt;
Treat AI-generated YAML as an unverified rough draft. The generation step saves typing time, but the engineering work only begins when an engineer evaluates the draft against live cluster constraints:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What node pool will this land on?&lt;/li&gt;
&lt;li&gt;How does this interact with our cluster autoscaler?&lt;/li&gt;
&lt;li&gt;What happens when this service loses connectivity to its database?&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  The Takeaway
&lt;/h2&gt;

&lt;p&gt;Automation in Kubernetes has always promised to abstract away complexity. But abstracting away the boilerplate is very different from abstracting away the operational reality.&lt;br&gt;
An AI model can write a Deployment, a Service, and an Ingress in seconds. But it doesn't know your cluster's instance types, your cross-AZ data transfer costs, your node upgrade schedule, or your traffic profiles.&lt;br&gt;
AI can write valid Kubernetes YAML; only engineers understand the blast radius of applying it.&lt;/p&gt;

&lt;p&gt;How is your team handling AI-generated configurations in CI/CD pipelines? Are you enforcing admission policies to catch invisible operational gaps? Let me know your thoughts in the comments.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Note: This article was written with the assistance of AI tools for structuring and drafting. The ideas, examples, and perspectives are based on real-world experience in DevOps and cloud engineering.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>devops</category>
      <category>aws</category>
      <category>gcp</category>
    </item>
    <item>
      <title>What Happens When AI Meets Legacy DevOps Pipelines</title>
      <dc:creator>Yogesh VK</dc:creator>
      <pubDate>Sat, 10 Oct 2026 14:00:00 +0000</pubDate>
      <link>https://dev.to/yogesh_vk/what-happens-when-ai-meets-legacy-devops-pipelines-30je</link>
      <guid>https://dev.to/yogesh_vk/what-happens-when-ai-meets-legacy-devops-pipelines-30je</guid>
      <description>&lt;h2&gt;
  
  
  The Pipeline That Nobody Wants to Touch
&lt;/h2&gt;

&lt;p&gt;There is a particular kind of DevOps pipeline that most engineers eventually encounter. It works. Nobody really likes it. Nobody is entirely sure who originally wrote it.&lt;/p&gt;

&lt;p&gt;And everyone knows that changing it before a Friday production deployment is probably a bad idea. Maybe it started as a simple Jenkinsfile.&lt;/p&gt;

&lt;p&gt;Over the years, someone added a security scan. Someone else added a manual approval. Then came a workaround for an old deployment system. A shell script appeared because the Jenkins plugin couldn’t do something reliably. Another script was added because the first script had a problem.&lt;/p&gt;

&lt;p&gt;Eventually, you end up with something like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight groovy"&gt;&lt;code&gt;&lt;span class="n"&gt;stage&lt;/span&gt;&lt;span class="o"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'Deploy'&lt;/span&gt;&lt;span class="o"&gt;)&lt;/span&gt; &lt;span class="o"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;steps&lt;/span&gt; &lt;span class="o"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;sh&lt;/span&gt; &lt;span class="s1"&gt;'./scripts/prepare.sh'&lt;/span&gt;
        &lt;span class="n"&gt;sh&lt;/span&gt; &lt;span class="s1"&gt;'./scripts/deploy.sh'&lt;/span&gt;
        &lt;span class="n"&gt;sh&lt;/span&gt; &lt;span class="s1"&gt;'./scripts/verify.sh'&lt;/span&gt;
    &lt;span class="o"&gt;}&lt;/span&gt;
&lt;span class="o"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;And somewhere inside those scripts are another few hundred lines of Bash.&lt;/p&gt;

&lt;p&gt;Then one day, someone gives the whole thing to an AI coding agent and asks:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“Can you modernize this CI/CD pipeline?”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;And the AI comes back with a beautifully clean pipeline. That’s where things get interesting.&lt;/p&gt;

&lt;h2&gt;
  
  
  AI Sees Technical Debt. Engineers See History.
&lt;/h2&gt;

&lt;p&gt;If I look at an old pipeline and see five shell scripts, duplicated environment variables, strange conditionals and a Jenkins plugin that hasn’t been updated in years, my first reaction might be the same as AI’s.&lt;/p&gt;

&lt;p&gt;Why is this so complicated and why are we doing this manually?&lt;br&gt;
Why aren’t we using the newer deployment mechanism? Why do we have three different scripts doing something that looks like it could be one command?&lt;/p&gt;

&lt;p&gt;From a purely technical perspective, those are reasonable questions. But legacy pipelines have something that source code doesn’t always make obvious: history.&lt;/p&gt;

&lt;p&gt;That strange shell command might exist because a previous version of the deployment tool had a bug. That environment variable might exist because one particular production server doesn’t behave like the others. That manual approval might have been introduced after an incident. That seemingly redundant verification step might be checking something that the deployment tool itself cannot detect. The pipeline may look messy because the system around it is messy. And AI doesn’t automatically know that history.&lt;/p&gt;
&lt;h2&gt;
  
  
  The Modernization Looks Great
&lt;/h2&gt;

&lt;p&gt;Let’s say the original pipeline does something like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;$ ./deploy.sh production
Checking environment...
Loading production variables...
Running database pre-check...
Deploying application...
Waiting for deployment...
Running smoke tests...
Deployment completed successfully.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;An AI agent looks at this and suggests replacing several of those steps with a cleaner deployment stage.&lt;/p&gt;

&lt;p&gt;Maybe:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nv"&gt;$ &lt;/span&gt;kubectl apply &lt;span class="nt"&gt;-f&lt;/span&gt; deployment.yaml
deployment.apps/payments-api configured

&lt;span class="nv"&gt;$ &lt;/span&gt;kubectl rollout status deployment/payments-api
deployment &lt;span class="s2"&gt;"payments-api"&lt;/span&gt; successfully rolled out
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Much cleaner. And technically, that might be exactly what we want. But here’s the question I would ask before merging it: What was deploy.sh actually doing?&lt;/p&gt;

&lt;p&gt;Because the filename doesn’t tell us everything. Maybe it was doing much more than deploying the application. Maybe it was checking whether a database migration was required. Maybe it was updating an external load balancer. Maybe it was waiting for a legacy service to become available. Maybe it was deliberately running things in a specific order because the production environment required it.&lt;/p&gt;

&lt;p&gt;The AI sees a script. The engineer needs to understand the behavior hidden inside the script.&lt;/p&gt;

&lt;h2&gt;
  
  
  Legacy Pipelines Often Contain Invisible Contracts
&lt;/h2&gt;

&lt;p&gt;This is where legacy DevOps systems get particularly difficult. A pipeline can have dependencies that aren’t obvious from the pipeline itself.&lt;/p&gt;

&lt;p&gt;For eg:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;$ grep -R "production" Jenkinsfile scripts/

Jenkinsfile: environment = "production"
scripts/deploy.sh: source /opt/company/env/production.env
scripts/verify.sh: curl https://internal-api/health
scripts/rollback.sh: ./legacy-rollback production

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The pipeline may depend on files, servers, credentials, APIs, naming conventions and operational procedures that exist outside Git.&lt;/p&gt;

&lt;p&gt;That’s an invisible contract and AI can only reason about what it can actually see. If you give an AI agent the Jenkinsfile but not the scripts it calls, it might confidently recommend removing something that looks unnecessary. If you give it the repository but not the operational documentation, it may miss why a particular step exists.&lt;/p&gt;

&lt;p&gt;If you give it the code but not the history of production incidents, it has no way of knowing that a strange-looking workaround may actually be protecting the system. This is where context becomes more important than code quality.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Most Dangerous Changes May Be the Cleanest Ones
&lt;/h2&gt;

&lt;p&gt;This is probably the part of legacy modernization that I find most interesting. When AI improves a piece of code, the result often looks better.&lt;/p&gt;

&lt;p&gt;The pipeline becomes shorter and configuration becomes more consistent. The number of steps goes down and scripts disappear. The deployment process becomes easier to understand and that can make the change look safer.&lt;/p&gt;

&lt;p&gt;But reducing complexity in the pipeline doesn’t necessarily reduce complexity in the system. Sometimes you’ve simply moved the complexity somewhere else. For example, imagine the old pipeline has:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;./precheck.sh
./deploy.sh
./verify.sh
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;And AI turns that into:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;kubectl apply &lt;span class="nt"&gt;-f&lt;/span&gt; deployment.yaml
kubectl rollout status deployment/app

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That is certainly cleaner. But what happened to everything that precheck.sh and verify.sh were doing? If those scripts contained important operational checks, we haven’t modernized the pipeline. We’ve removed safeguards, and that’s a very different thing.&lt;/p&gt;

&lt;p&gt;This Doesn’t Mean AI Can’t Modernize Legacy Pipelines&lt;br&gt;
I actually think this is one of the areas where AI can be extremely useful. Legacy pipelines are often difficult to understand because the knowledge is distributed across Jenkinsfiles, Bash scripts, documentation, configuration files and tribal knowledge.&lt;/p&gt;

&lt;p&gt;AI is very good at helping us explore that complexity. For example, I can ask it:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“Trace everything that happens when this pipeline deploys to production.”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Or:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“Show me every external dependency used by this Jenkins pipeline.”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Or:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“Explain what this shell script is checking before deployment.”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;That is a much safer starting point than:&lt;br&gt;
“Rewrite this pipeline.”&lt;/p&gt;

&lt;p&gt;The first approach asks AI to understand the existing system. The second asks it to replace the existing system. Those are very different tasks.&lt;/p&gt;

&lt;h2&gt;
  
  
  I Would Start With Read-Only AI
&lt;/h2&gt;

&lt;p&gt;If I were introducing AI into an old production pipeline, I wouldn’t start by giving it permission to modify the pipeline.&lt;/p&gt;

&lt;p&gt;I’d start by letting it observe. Give it the Jenkinsfile, the scripts, the deployment configuration, the logs and all the documentation. Then ask questions.&lt;/p&gt;

&lt;p&gt;The pipeline isn’t just a collection of strange commands anymore. We can start asking why those commands appeared. That historical context can be incredibly valuable when deciding what is safe to remove.&lt;/p&gt;

&lt;h2&gt;
  
  
  Modernization Should Be Incremental
&lt;/h2&gt;

&lt;p&gt;This is where I think AI can work particularly well with legacy DevOps.&lt;/p&gt;

&lt;p&gt;Instead of asking:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“Replace this entire pipeline.”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;I’d rather ask:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“Identify the parts of this pipeline that can be safely modernized, explain what each part currently does, and identify dependencies or risks before proposing changes.”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Then make one change, test it and observe it. Then make another change. Run it in a lower environment and Compare the behavior. Then gradually move toward the new pipeline.&lt;/p&gt;

&lt;p&gt;The goal isn’t to make the Jenkinsfile beautiful. The goal is to change the system without accidentally removing knowledge that the old pipeline encoded.&lt;/p&gt;

&lt;h2&gt;
  
  
  AI Meets Legacy: Context Before Change
&lt;/h2&gt;

&lt;p&gt;This is probably the bigger lesson I take from this. AI is very good at looking at a messy pipeline and saying:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“I can make this simpler.”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Sometimes that’s exactly what we need. But before simplifying a legacy DevOps system, I want to understand why it became complicated in the first place.&lt;/p&gt;

&lt;p&gt;Because technical debt isn’t always random. Sometimes it’s accumulated operational knowledge. A strange script might represent an old incident. A manual step might represent a control that was introduced after a failure. A redundant check might exist because something once went badly without it.&lt;/p&gt;

&lt;p&gt;And if we remove those things without understanding them, we may end up with a pipeline that looks much better while being operationally worse. That’s the paradox of AI and legacy DevOps.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;AI can see the mess very quickly.&lt;br&gt;
The engineer still needs to understand the history behind the mess.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;And that’s where I think AI can be most useful — not as the thing that immediately rewrites the legacy pipeline, but as the engineer’s assistant for understanding it before we decide what should change.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Note: This article was written with the assistance of AI tools for structuring and drafting. The ideas, examples, and perspectives are based on real-world experience in DevOps and cloud engineering.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>devops</category>
      <category>cicd</category>
      <category>jenkins</category>
    </item>
    <item>
      <title>The Read-Only SRE: My Favorite Way to Use AI in Production</title>
      <dc:creator>Yogesh VK</dc:creator>
      <pubDate>Fri, 10 Jul 2026 06:51:29 +0000</pubDate>
      <link>https://dev.to/yogesh_vk/the-read-only-sre-my-favorite-way-to-use-ai-in-production-1pa8</link>
      <guid>https://dev.to/yogesh_vk/the-read-only-sre-my-favorite-way-to-use-ai-in-production-1pa8</guid>
      <description>&lt;p&gt;For years, Site Reliability Engineering, from what I understand, has been built around a simple idea: automate what can be automated, but be cautious about where trust is placed.&lt;/p&gt;

&lt;p&gt;Production systems are valuable not because they’re difficult to operate, but because every decision has consequences. A small configuration mistake can become a customer-facing outage. A poorly timed deployment can impact thousands of users. Experience teaches engineers that production isn’t just another environment — it’s where judgment matters.&lt;/p&gt;

&lt;p&gt;As AI becomes increasingly capable, many of us are beginning to ask the same question. Where does AI belong in production operations?&lt;/p&gt;

&lt;p&gt;Some conversations immediately jump to autonomous incident response, automated remediation, or AI-driven deployments. While those ideas are exciting, I’ve found myself taking a much more conservative approach.&lt;/p&gt;

&lt;p&gt;Instead of asking, “What can AI control?”, I started asking a different question:&lt;/p&gt;

&lt;p&gt;“How much value can AI provide without controlling anything?”&lt;/p&gt;

&lt;p&gt;Answer, I think, is — quite a lot.&lt;/p&gt;

&lt;h2&gt;
  
  
  Production Already Produces Too Much Information
&lt;/h2&gt;

&lt;p&gt;One thing I’ve noticed over the years is that SREs rarely struggle because information is missing. They struggle because there’s too much information.&lt;/p&gt;

&lt;p&gt;An incident begins. Alerts start firing left and right. Dashboards turn red. Logs begin filling up really fast. Slack channels become active all of sudden. People start opening Grafana, Kubernetes dashboards, Cloud Monitoring, GitLab pipelines, and documentation — all at the same time.&lt;/p&gt;

&lt;p&gt;The challenge isn’t collecting data anymore. It’s understanding the situation quickly enough to make good decisions. This is exactly where I think AI has found its first truly valuable role.&lt;/p&gt;

&lt;p&gt;Not replacing the engineer. Helping the engineer think faster.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I Let AI Do
&lt;/h2&gt;

&lt;p&gt;If I imagine AI joining my SRE team tomorrow, the first thing I’d give it is read-only access.&lt;/p&gt;

&lt;p&gt;Read logs, Kubernetes events, monitoring dashboards, deployment history, Terraform plans, Git commits, incident timelines, and anything else that is normally involved in initial Incident troubleshooting.&lt;/p&gt;

&lt;p&gt;Then ask it questions. Something like:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;“What changed in the last hour?”&lt;/li&gt;
&lt;li&gt;“Which deployments happened before latency increased?”&lt;/li&gt;
&lt;li&gt;“Are there any unusual patterns in these logs?”&lt;/li&gt;
&lt;li&gt;“Summarize the last thirty minutes.”&lt;/li&gt;
&lt;li&gt;Those are incredibly valuable tasks. 
Notice something interesting. None of them require AI to modify production.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Where I Draw the Line
&lt;/h2&gt;

&lt;p&gt;The moment AI starts making production changes, the conversation changes completely.&lt;/p&gt;

&lt;p&gt;Restarting a deployment. Scaling workloads. Deleting resources. Changing Terraform code. Updating firewall rules.&lt;/p&gt;

&lt;p&gt;Those aren’t information problems anymore. They’re ownership problems. Every experienced SRE knows that incidents are messy. Information is incomplete. Monitoring isn’t perfect. Sometimes the correct technical decision isn’t the correct business decision.&lt;/p&gt;

&lt;p&gt;No AI model understands customer expectations, maintenance windows, contractual obligations, or organizational priorities unless those things have been explicitly provided.&lt;/p&gt;

&lt;p&gt;Even then, accountability still belongs to people. That’s why I think production writes should remain human decisions.&lt;/p&gt;

&lt;h2&gt;
  
  
  AI as an SRE Intern
&lt;/h2&gt;

&lt;p&gt;I’ve started thinking about AI almost like an SRE intern. An incredibly fast intern. One that never gets tired. One that can read thousands of log lines in seconds. One that remembers documentation better than most humans.&lt;/p&gt;

&lt;p&gt;But still an intern.&lt;/p&gt;

&lt;p&gt;I’d happily ask that intern to prepare an incident timeline, summarize dashboards, highlight anomalies and suggest possible causes.&lt;/p&gt;

&lt;p&gt;I would not ask that intern to restart production workloads without review. Not because the intern isn’t intelligent. Because the responsibility still belongs to the senior engineer who can take ownership.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Future
&lt;/h2&gt;

&lt;p&gt;I suspect AI systems will become increasingly capable over the next few years. Eventually they may earn broader operational ownership.&lt;/p&gt;

&lt;p&gt;Perhaps they’ll restart stateless workloads under carefully defined policies and they’ll execute approved runbooks. Perhaps they’ll remediate well-understood failure scenarios. But I don’t think the journey starts there.&lt;/p&gt;

&lt;p&gt;It starts by becoming exceptionally good at understanding production before attempting to control it.&lt;/p&gt;

&lt;p&gt;Ironically, that’s exactly how we onboard new SREs. We don’t give production write access on day one. We let them observe, learn, dashboards and study previous incidents. Build intuition. Maybe AI deserves the same onboarding process.&lt;/p&gt;

&lt;h2&gt;
  
  
  Final Thoughts
&lt;/h2&gt;

&lt;p&gt;Whenever people ask me whether AI will replace SREs, I think they’re asking the wrong question. The more interesting question is:&lt;/p&gt;

&lt;p&gt;“How can AI help SREs become better at understanding production systems?”&lt;/p&gt;

&lt;p&gt;For me, the answer begins with read-only access. Because before AI earns the right to change production, it should first prove that it truly understands it.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Note: This article was written with the assistance of AI tools for structuring and drafting. The ideas, examples, and perspectives are based on the real-world experience in DevOps and cloud engineering over the years.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>devops</category>
      <category>ai</category>
      <category>sre</category>
      <category>cloudcomputing</category>
    </item>
    <item>
      <title>Why Context Engineering Matters More Than Prompt Engineering in DevOps</title>
      <dc:creator>Yogesh VK</dc:creator>
      <pubDate>Fri, 26 Jun 2026 05:30:00 +0000</pubDate>
      <link>https://dev.to/yogesh_vk/why-context-engineering-matters-more-than-prompt-engineering-in-devops-14n0</link>
      <guid>https://dev.to/yogesh_vk/why-context-engineering-matters-more-than-prompt-engineering-in-devops-14n0</guid>
      <description>&lt;p&gt;Over the last year, I've lost count of how many conversations I've seen about prompt engineering. Every week there seems to be another article explaining how a different prompt structure, a new framework, or a carefully chosen set of words can dramatically improve the quality of AI-generated responses. It's an interesting topic, and there is certainly some truth to it. A well-written prompt usually produces a better answer than a vague one. But after spending more time using AI in real DevOps workflows, I've come to believe that we're focusing on the wrong problem.&lt;/p&gt;

&lt;p&gt;The biggest improvements I've seen, have not come from asking better questions. They've always come from giving AI a better understanding of the environment it is supposed to reason about.&amp;nbsp;&lt;br&gt;
That realization didn't happen overnight. Like many engineers, I initially assumed that if an AI produced an answer that wasn't particularly useful, the fault was probably mine. Maybe the prompt wasn't detailed enough. Maybe I needed to specify the expected format. Maybe I should explain the task differently. So I experimented. I rewrote prompts, added constraints, changed wording, and tried different approaches. The responses became slightly more polished, but they didn't become significantly more useful.&lt;/p&gt;

&lt;p&gt;The turning point came when I stopped changing the prompt and started changing the information I provided.&lt;br&gt;
Instead of simply asking an AI to review a Terraform change, I began explaining how the infrastructure was organized. Instead of asking it to summarize Kubernetes logs, I described the platform architecture, the deployment workflow, and the operational constraints surrounding the application. Instead of expecting it to infer how our CI/CD pipeline worked, I gave it the context that every new engineer on the team would normally receive during onboarding.&lt;/p&gt;

&lt;p&gt;And the difference was remarkable and it permanently changed how I approach things.&amp;nbsp;&lt;br&gt;
The prompts themselves became almost boring. They weren't especially clever or sophisticated. In many cases they were only a sentence or two long. What changed was that the AI finally had enough background information to understand why the question mattered in the first place. Looking back, that shouldn't have been surprising.&lt;/p&gt;

&lt;p&gt;If a new platform engineer joined the team tomorrow, I wouldn't judge their ability based on how well they answered questions during their first hour. Before expecting useful decisions, I would explain how our environments were structured, how deployments flowed through the pipeline, which services were considered critical, where the operational boundaries existed, and perhaps most importantly, why certain engineering decisions had been made in the past. None of that information would fit neatly into a ticket description, but it would heavily influence every decision that engineer made going forward.&lt;/p&gt;

&lt;p&gt;AI is no different. We often expect it to reason about infrastructure that took years to evolve, while giving it only a handful of configuration files and a carefully worded prompt. When the answer falls short, our instinct is to keep refining the prompt instead of asking a more fundamental question: does the model actually understand the environment it's being asked to reason about? In DevOps, the answer is often no.&lt;br&gt;
Infrastructure isn't defined only by Terraform modules, Kubernetes manifests, or CI/CD pipelines. It is defined by the relationships between those pieces. It includes architectural decisions that were made years ago, operational guardrails that exist because of previous incidents, naming conventions that everyone on the team follows without thinking, business priorities that influence deployment schedules, and countless small decisions that experienced engineers carry around almost instinctively. Most of that information never appears in a prompt, yet it shapes nearly every engineering decision we make.&lt;/p&gt;

&lt;p&gt;This is why I've become increasingly interested in what I think of as context engineering. To me, it isn't about inventing another AI buzzword. It's simply the practice of making the surrounding system understandable before expecting useful answers. Good documentation becomes part of that context. Architecture diagrams become part of that context. Repository conventions, deployment workflows, incident learnings, infrastructure boundaries, and even the reasons behind previous technical decisions all become part of the environment the AI is trying to understand.&lt;/p&gt;

&lt;p&gt;Ironically, this is exactly the kind of work that also benefits human engineers. Every team has experienced the challenge of onboarding someone into a mature platform. The difficulty isn't teaching Terraform syntax or explaining how Kubernetes works. Most experienced engineers already know those things. The difficult part is transferring all the knowledge that exists between the lines of the documentation. Why is production deployed differently from staging? Why do certain services follow different release windows? Why is one Terraform module intentionally duplicated instead of shared? Those answers usually live in conversations, design reviews, and operational experience rather than in source code.&lt;br&gt;
Perhaps that's why context engineering feels much more aligned with infrastructure engineering than prompt engineering ever did. Infrastructure has always been about understanding systems rather than individual resources. AI simply exposes the same truth from a different angle. The better the system is documented and understood, the better both humans and machines are able to work within it.&lt;/p&gt;

&lt;p&gt;I'm sure prompt engineering will continue to evolve, and it will undoubtedly remain an important skill for getting the best out of AI tools. But I suspect that, at least in DevOps, its importance is often overstated. Once the model truly understands the environment, the prompts themselves become surprisingly ordinary. They start looking less like carefully engineered instructions and more like the kind of questions one engineer naturally asks another.&lt;br&gt;
And perhaps that's the biggest lesson I've taken away from using AI in infrastructure engineering. The quality of the answer depends less on how elegantly we ask the question and far more on whether we've given the system enough context to understand our world before expecting it to solve our problems.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Note: This article was written with the assistance of AI tools for structuring and drafting. The ideas, examples, and perspectives are based on real-world experience in DevOps and cloud engineering.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Originally published on Medium: &lt;a href="https://medium.com/@yogesh.vk/why-better-prompts-wont-fix-ai-in-devops-235c0abe1814" rel="noopener noreferrer"&gt;https://medium.com/@yogesh.vk/why-better-prompts-wont-fix-ai-in-devops-235c0abe1814&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>devops</category>
      <category>infrastructure</category>
    </item>
    <item>
      <title>Using AWS DevOps Agent with Terraform and CI/CD Pipelines</title>
      <dc:creator>Yogesh VK</dc:creator>
      <pubDate>Fri, 12 Jun 2026 06:00:00 +0000</pubDate>
      <link>https://dev.to/yogesh_vk/using-aws-devops-agent-with-terraform-and-cicd-pipelines-42f1</link>
      <guid>https://dev.to/yogesh_vk/using-aws-devops-agent-with-terraform-and-cicd-pipelines-42f1</guid>
      <description>&lt;p&gt;There’s no shortage of AI tools claiming to improve software delivery. Most of them focus on code generation. Some focus on chat interfaces. A few attempt to automate operational tasks.&lt;/p&gt;

&lt;p&gt;What caught my attention about AWS DevOps Agent is that it focuses on something infrastructure teams spend a surprising amount of time doing every day: understanding changes.&lt;/p&gt;

&lt;p&gt;As infrastructure grows, engineers spend less time writing Terraform and more time reviewing it, explaining it, validating it, and assessing risk before deployment.&lt;/p&gt;

&lt;p&gt;That’s where I think tools like AWS DevOps Agent become interesting. Not because they replace engineers. But because they can reduce some of the cognitive load around infrastructure workflows.&lt;/p&gt;




&lt;p&gt;Imagine a fairly typical Terraform pull request.&lt;/p&gt;

&lt;p&gt;A developer modifies an EKS node group. Updates autoscaling limits.&lt;/p&gt;

&lt;p&gt;Makes a few IAM changes. The Terraform plan is generated as part of a GitLab CI pipeline. The output may easily contain hundreds of lines.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight terraform"&gt;&lt;code&gt;&lt;span class="nx"&gt;Terraform&lt;/span&gt; &lt;span class="nx"&gt;will&lt;/span&gt; &lt;span class="nx"&gt;perform&lt;/span&gt; &lt;span class="nx"&gt;the&lt;/span&gt; &lt;span class="nx"&gt;following&lt;/span&gt; &lt;span class="nx"&gt;actions&lt;/span&gt;&lt;span class="err"&gt;:&lt;/span&gt;
&lt;span class="c1"&gt;# aws_eks_node_group.platform&lt;/span&gt;
  &lt;span class="err"&gt;~&lt;/span&gt; &lt;span class="nx"&gt;scaling_config&lt;/span&gt;
      &lt;span class="nx"&gt;desired_size&lt;/span&gt;&lt;span class="err"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt; &lt;span class="nx"&gt;-&lt;/span&gt;&lt;span class="err"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;6&lt;/span&gt;
  &lt;span class="c1"&gt;# aws_iam_role.platform&lt;/span&gt;
  &lt;span class="err"&gt;~&lt;/span&gt; &lt;span class="nx"&gt;inline_policy&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Nothing unusual.&lt;/p&gt;

&lt;p&gt;But someone still needs to understand:&lt;/p&gt;

&lt;p&gt;What changed?&lt;br&gt;
Is there downtime risk?&lt;br&gt;
Is there cost impact?&lt;br&gt;
Is there a security implication?&lt;br&gt;
This is where an AI agent can be useful. Instead of asking engineers to parse raw plan output, the agent can generate a human-readable summary.&lt;/p&gt;

&lt;p&gt;Something closer to:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;The node group capacity is being doubled from three to six nodes.&lt;/p&gt;

&lt;p&gt;This may increase cluster costs but improves available capacity.&lt;/p&gt;

&lt;p&gt;An IAM policy is also being modified. Review permissions carefully before applying.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;The Terraform hasn’t changed. The deployment process hasn’t changed. But the review process becomes easier.&lt;/p&gt;




&lt;p&gt;The same idea applies to CI/CD pipelines. A typical deployment pipeline already produces a large amount of information.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Build logs.&lt;/li&gt;
&lt;li&gt;Security scans.&lt;/li&gt;
&lt;li&gt;Terraform plans.&lt;/li&gt;
&lt;li&gt;Kubernetes deployment outputs.&lt;/li&gt;
&lt;li&gt;Test results.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Most of this information is technically available. The challenge is understanding it quickly. An AI agent can act as an additional layer between the pipeline and the engineer.&lt;/p&gt;

&lt;p&gt;Instead of scrolling through hundreds of lines of output, the engineer receives a concise explanation of what happened. Like having a senior teammate summarize the deployment.&lt;/p&gt;




&lt;p&gt;Where I find this particularly interesting is that it aligns with a pattern I’ve written about several times before. The most useful AI systems in DevOps are often the ones that improve understanding rather than execution.&lt;/p&gt;

&lt;p&gt;I am generally cautious about giving AI systems the authority to make infrastructure decisions.&lt;/p&gt;

&lt;p&gt;I am much more comfortable letting them explain Terraform plans, summarize deployment risks, or surface unusual changes. That’s a very different trust boundary. One accelerates human decision-making. The other attempts to replace it.&lt;/p&gt;




&lt;p&gt;I suspect this is where tools like AWS DevOps Agent will find their strongest use cases. Not by automatically deploying infrastructure. Not by replacing platform engineers. But by helping teams understand increasingly complex systems faster.&lt;/p&gt;

&lt;p&gt;And as anyone who has spent time reviewing Terraform plans or deployment pipelines knows, understanding the change is often the hardest part.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Note: This article was written with the assistance of AI tools for structuring and drafting. The ideas, examples, and perspectives are based on real-world experience in DevOps and cloud engineering.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>aws</category>
      <category>devops</category>
      <category>agents</category>
    </item>
    <item>
      <title>AI as an SRE Intern: What I Let Agents Touch During Incident Response</title>
      <dc:creator>Yogesh VK</dc:creator>
      <pubDate>Fri, 29 May 2026 05:30:00 +0000</pubDate>
      <link>https://dev.to/yogesh_vk/ai-as-an-sre-intern-what-i-let-agents-touch-during-incident-response-244</link>
      <guid>https://dev.to/yogesh_vk/ai-as-an-sre-intern-what-i-let-agents-touch-during-incident-response-244</guid>
      <description>&lt;p&gt;Anyone who has spent time in operations knows that production incidents create a very different environment from normal engineering work.&lt;/p&gt;

&lt;p&gt;The pressure is higher and information is incomplete. Everyone wants answers immediately. And ironically, that is exactly when poor decisions become most expensive.&lt;/p&gt;

&lt;p&gt;As AI tools become more capable, I’ve been thinking about a simple question:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;If an AI agent joined our incident bridge today, what would I actually trust it to do?&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Relatable Incident Scenario
&lt;/h2&gt;

&lt;p&gt;This is how a typical incident in a operation role looks like:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;HTTP 5xx rates suddenly spike
Latency jumps from 150ms to 2s
Multiple pods begin restarting
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;When you join the bridge, the first 15 minutes are chaos. People are asking all sorts of questions:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What changed?&lt;/li&gt;
&lt;li&gt;Is this infrastructure?&lt;/li&gt;
&lt;li&gt;Is this application?&lt;/li&gt;
&lt;li&gt;Did a deployment happen?&lt;/li&gt;
&lt;li&gt;Should we rollback?&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;
  
  
  Where I feel AI Is Helpful
&lt;/h2&gt;

&lt;p&gt;This is where I happily treat AI as an SRE intern. I don’t ask it to fix anything. I ask it to gather context.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Example 1: Log Summarization&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;kubectl logs payment-service-1234xzy-abcd
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Thousands of lines of output, easily taking 5–10 minutes to even scroll through. How do I get AI to help here? Make it summaries:&lt;/p&gt;

&lt;p&gt;Most common errors:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Database connection timeout&lt;/li&gt;
&lt;li&gt;Retry exhaustion&lt;/li&gt;
&lt;li&gt;Elevated latency after deployment 17 minutes ago&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Example 2: Timeline Reconstruction&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Find incidents involving Redis connection exhaustion
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;AI is great at summarizing the events. It can go through a centralized logs and throw out an even timeline, something like:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight console"&gt;&lt;code&gt;&lt;span class="go"&gt;10:02 deployment
10:04 alerts fire
10:07 pod restarts
10:09 latency spike
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;&lt;strong&gt;Example 3: Runbook Search&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Find incidents involving Redis connection exhaustion
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;AI quickly and efficiently searches for runbooks, previous incident reports and postmortems. Huge time savings and value.&lt;/p&gt;
&lt;h2&gt;
  
  
  What I Don’t Let It Touch
&lt;/h2&gt;

&lt;p&gt;At some point during every incident, somebody proposes an action.&lt;br&gt;
Roll back.&lt;br&gt;
Scale up.&lt;br&gt;
Restart pods.&lt;br&gt;
Increase database connections.&lt;br&gt;
Disable a feature flag.&lt;/p&gt;

&lt;p&gt;These are not information problems anymore. They are judgment problems. We need a human in loop here.&lt;/p&gt;

&lt;p&gt;For example, an AI may suggest restarting a deployment because similar log patterns appeared before.&lt;/p&gt;

&lt;p&gt;What it doesn’t know is that the deployment currently serves a major customer onboarding event. Or that another team is already running a migration. Or that the last restart caused a cascading failure. These are all business use-cases and an AI will not know these.&lt;/p&gt;
&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;If a new SRE joined the team tomorrow, I wouldn’t hand them production access during their first major outage.&lt;/p&gt;

&lt;p&gt;I’d ask them to gather information. Build timelines. Summarize findings. Surface patterns. Learn the system.&lt;/p&gt;

&lt;p&gt;That’s exactly how I think about AI during incidents. Not as the person driving the response. But as the intern helping the team understand the situation faster.&lt;/p&gt;

&lt;p&gt;How would you approach it?&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Note: This article was written with the assistance of AI tools for structuring and drafting. The ideas, examples, and perspectives are based on real-world experience in DevOps and SRE.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Originally published on Medium:&lt;br&gt;
&lt;/p&gt;
&lt;div class="crayons-card c-embed text-styles text-styles--secondary"&gt;
    &lt;div class="c-embed__content"&gt;
      &lt;div class="c-embed__body flex items-center justify-between"&gt;
        &lt;a href="https://medium.com/@yogesh.vk/ai-as-an-sre-intern-what-i-let-agents-touch-during-incident-response-f0c843e1e1ca" rel="noopener noreferrer" class="c-link fw-bold flex items-center"&gt;
          &lt;span class="mr-2"&gt;medium.com&lt;/span&gt;
          

        &lt;/a&gt;
      &lt;/div&gt;
    &lt;/div&gt;
&lt;/div&gt;



</description>
      <category>ai</category>
      <category>sre</category>
      <category>devops</category>
      <category>cloudcomputing</category>
    </item>
    <item>
      <title>AI + GitOps: Why Context Matters More Than Reconciliation</title>
      <dc:creator>Yogesh VK</dc:creator>
      <pubDate>Fri, 08 May 2026 06:15:00 +0000</pubDate>
      <link>https://dev.to/yogesh_vk/ai-gitops-why-context-matters-more-than-reconciliation-45e4</link>
      <guid>https://dev.to/yogesh_vk/ai-gitops-why-context-matters-more-than-reconciliation-45e4</guid>
      <description>&lt;h2&gt;
  
  
  Introduction
&lt;/h2&gt;

&lt;p&gt;There’s something very satisfying about watching a system converge. You push a change to Git. A pipeline runs. A few minutes later, the cluster reflects exactly what you defined.&lt;/p&gt;

&lt;p&gt;The system was Clean, Predictable and Repeatable.&lt;/p&gt;

&lt;p&gt;For a long time, I thought that was the hard part. It turns out, it isn’t.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Setup
&lt;/h2&gt;

&lt;p&gt;This was a fairly typical setup.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Kubernetes cluster on GKE&lt;/li&gt;
&lt;li&gt;Applications deployed using Helm&lt;/li&gt;
&lt;li&gt;GitLab CI driving deployments&lt;/li&gt;
&lt;li&gt;Terraform managing underlying infrastructure&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The deployment flow was simple:&lt;br&gt;
&lt;code&gt;git push origin main&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;Which triggered a GitLab pipeline:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;deploy&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;stage&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;deploy&lt;/span&gt;
  &lt;span class="na"&gt;script&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="s"&gt;helm upgrade --install payments ./chart -f values.yaml&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Nothing fancy. A basic Helm chart defined a service with autoscaling.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="c1"&gt;# values.yaml&lt;/span&gt;
&lt;span class="na"&gt;replicaCount&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;2&lt;/span&gt;

&lt;span class="na"&gt;autoscaling&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;enabled&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
  &lt;span class="na"&gt;minReplicas&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;2&lt;/span&gt;
  &lt;span class="na"&gt;maxReplicas&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;10&lt;/span&gt;

&lt;span class="na"&gt;resources&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;requests&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;cpu&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;200m"&lt;/span&gt;
    &lt;span class="na"&gt;memory&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;256Mi"&lt;/span&gt;
  &lt;span class="na"&gt;limits&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;cpu&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;500m"&lt;/span&gt;
    &lt;span class="na"&gt;memory&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;512Mi"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Everything was stable.&lt;/p&gt;
&lt;h2&gt;
  
  
  The Change
&lt;/h2&gt;

&lt;p&gt;We had started experimenting with using AI to assist in updating configurations. One suggestion came in to “optimize performance under load.” The diff looked reasonable.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight diff"&gt;&lt;code&gt; autoscaling:
   enabled: true
&lt;span class="gd"&gt;-  maxReplicas: 10
&lt;/span&gt;&lt;span class="gi"&gt;+  maxReplicas: 30
&lt;/span&gt;&lt;span class="err"&gt;
&lt;/span&gt; resources:
   requests:
&lt;span class="gd"&gt;-    cpu: "200m"
&lt;/span&gt;&lt;span class="gi"&gt;+    cpu: "500m"
&lt;/span&gt;&lt;span class="err"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Nothing obviously wrong. More replicas. More CPU. Better performance.&lt;/p&gt;
&lt;h2&gt;
  
  
  The System Converges
&lt;/h2&gt;

&lt;p&gt;The change was merged. GitLab CI picked it up.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight console"&gt;&lt;code&gt;&lt;span class="go"&gt;Running with gitlab-runner...
&lt;/span&gt;&lt;span class="gp"&gt;$&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;helm upgrade &lt;span class="nt"&gt;--install&lt;/span&gt; payments ./chart &lt;span class="nt"&gt;-f&lt;/span&gt; values.yaml
&lt;span class="go"&gt;Release "payments" has been upgraded
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;A quick check:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight console"&gt;&lt;code&gt;&lt;span class="go"&gt;kubectl get pods -n payments
payments-7d9f6c8c4d-abc12   1/1 Running
payments-7d9f6c8c4d-def34   1/1 Running

&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Everything looked healthy. No errors. No failed deploys. From a system perspective:&lt;/p&gt;

&lt;p&gt;Everything worked.&lt;/p&gt;
&lt;h2&gt;
  
  
  But Something Was Off…
&lt;/h2&gt;

&lt;p&gt;A few hours later, the signals started showing up.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;cluster CPU usage was higher than usual — node autoscaling kicked in aggressively&lt;/li&gt;
&lt;li&gt;costs started creeping up — some unrelated workloads saw intermittent throttling&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Nothing had technically failed. But the system behavior had changed.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The Problem Wasn’t the Pipeline&lt;/strong&gt;. The pipeline did exactly what it was designed to do.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Git was the source of truth&lt;/li&gt;
&lt;li&gt;the change was applied&lt;/li&gt;
&lt;li&gt;the cluster matched the desired state
There was no drift. No inconsistency. The problem wasn’t reconciliation. It was the definition of the desired state.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Where Context Was Missing — The AI-generated suggestion didn’t know:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;this service wasn’t latency-critical — the cluster had shared resource constraints&lt;/li&gt;
&lt;li&gt;aggressive scaling could impact other services — cost limits were important in this environment
From a configuration standpoint, the change was valid. From a system standpoint, it was incomplete.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;The Subtle Danger&lt;/strong&gt; — This is where AI + GitOps becomes interesting.&lt;/p&gt;

&lt;p&gt;GitOps gives us a powerful guarantee:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;the system will converge to the declared state&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;But it does not guarantee:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;that the declared state is the right one&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;And AI, without sufficient context, can generate configurations that are:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;technically correct&lt;/li&gt;
&lt;li&gt;syntactically valid&lt;/li&gt;
&lt;li&gt;operationally deployable
…but not aligned with the system as a whole.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Everything Looks “Green”. Even the deployment flow looks clean:&lt;br&gt;
&lt;code&gt;helm upgrade --install payments ./chart -f values.yaml&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;And Kubernetes happily reports:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight console"&gt;&lt;code&gt;&lt;span class="go"&gt;kubectl get hpa

NAME       REFERENCE             TARGETS   MINPODS   MAXPODS
payments   Deployment/payments   40%/80%   2         30

&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;No alerts. No failures. Just a system doing exactly what it was told to do.&lt;/p&gt;
&lt;h2&gt;
  
  
  The Realization
&lt;/h2&gt;

&lt;p&gt;Over time, this became clearer. Reconciliation is deterministic. Context is not. GitLab CI will apply whatever is in Git. Kubernetes will enforce whatever is defined. But neither of them understands:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;intent&lt;/li&gt;
&lt;li&gt;trade-offs&lt;/li&gt;
&lt;li&gt;system-wide impact&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That layer still depends on context.&lt;/p&gt;
&lt;h2&gt;
  
  
  Where AI Actually Helps
&lt;/h2&gt;

&lt;p&gt;AI becomes genuinely useful when it helps us understand changes, not blindly generate them.&lt;/p&gt;

&lt;p&gt;For example:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;explaining what a Helm diff actually means&lt;/li&gt;
&lt;li&gt;highlighting scaling implications&lt;/li&gt;
&lt;li&gt;surfacing cost impact&lt;/li&gt;
&lt;li&gt;identifying potential blast radius&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That’s where AI shines and actually adds value.&lt;/p&gt;
&lt;h2&gt;
  
  
  Closing Thought
&lt;/h2&gt;

&lt;p&gt;GitOps is incredibly powerful. It gives us consistency, traceability, and convergence. But it assumes that the desired state is correct. In AI-assisted workflows, that assumption becomes weaker. Because now, the desired state may be influenced by a system that doesn’t fully understand the environment. And that shifts the problem.&lt;/p&gt;

&lt;p&gt;From:&lt;br&gt;
&lt;code&gt;Will the system converge?&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;To:&lt;br&gt;
&lt;code&gt;Are we converging to the right thing?&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;GitOps guarantees convergence. It does not guarantee correctness. That depends on context — and context still needs humans.&lt;/p&gt;

&lt;p&gt;Do you agree?&lt;/p&gt;

&lt;p&gt;Note: This post was developed using AI-assisted writing tools. While AI helped with structuring and phrasing, all concepts and examples reflect real-world engineering experience.&lt;/p&gt;

&lt;p&gt;Originally published on Medium:&lt;br&gt;
&lt;/p&gt;
&lt;div class="crayons-card c-embed text-styles text-styles--secondary"&gt;
    &lt;div class="c-embed__content"&gt;
      &lt;div class="c-embed__body flex items-center justify-between"&gt;
        &lt;a href="https://medium.com/@yogesh.vk/ai-gitops-why-context-matters-more-than-reconciliation-f9e067d20e9a" rel="noopener noreferrer" class="c-link fw-bold flex items-center"&gt;
          &lt;span class="mr-2"&gt;medium.com&lt;/span&gt;
          

        &lt;/a&gt;
      &lt;/div&gt;
    &lt;/div&gt;
&lt;/div&gt;



</description>
      <category>ai</category>
      <category>devops</category>
      <category>cicd</category>
    </item>
    <item>
      <title>AI as a Junior Platform Engineer: How I "Onboard" Coding Agents</title>
      <dc:creator>Yogesh VK</dc:creator>
      <pubDate>Fri, 01 May 2026 07:00:00 +0000</pubDate>
      <link>https://dev.to/yogesh_vk/ai-as-a-junior-platform-engineer-how-i-onboard-coding-agents-1nh2</link>
      <guid>https://dev.to/yogesh_vk/ai-as-a-junior-platform-engineer-how-i-onboard-coding-agents-1nh2</guid>
      <description>&lt;h2&gt;
  
  
  Introduction
&lt;/h2&gt;

&lt;p&gt;The first time I started seriously using AI in my DevOps workflows, I made the same mistake I've seen many others make.&lt;br&gt;
I treated it like a tool.&lt;br&gt;
Something you prompt, get an answer from, and move on. It worked, to a point. But the results were inconsistent. Sometimes surprisingly good, sometimes completely off. It felt less like working with a system and more like rolling a dice.&lt;br&gt;
That changed when I started thinking about AI differently. Not as a tool - but as a junior platform engineer joining the team. That shift alone made everything more predictable.&lt;/p&gt;
&lt;h2&gt;
  
  
  The First Day&amp;nbsp;Problem
&lt;/h2&gt;

&lt;p&gt;When a new engineer joins a team, we don't expect them to be productive immediately. We don't just hand them access to production systems and ask them be productive.&lt;br&gt;
Instead, we onboard them. We give them:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;context about the system&lt;/li&gt;
&lt;li&gt;documentation&lt;/li&gt;
&lt;li&gt;boundaries&lt;/li&gt;
&lt;li&gt;a safe environment to contribute&lt;/li&gt;
&lt;li&gt;time to understand how things work
Without that, even a talented engineer will struggle. AI is no different.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;
  
  
  Context Is the Difference Between Useful and Dangerous
&lt;/h2&gt;

&lt;p&gt;One of the biggest differences between good and bad AI output is context. Without context, an AI agent will give you generic answers. They might be technically correct, but not aligned with your system, your architecture, or your constraints. This is where something like a context.md file becomes incredibly powerful.&lt;br&gt;
Think of it as the onboarding document you would give a new engineer. It might include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;how your infrastructure is structured&lt;/li&gt;
&lt;li&gt;naming conventions&lt;/li&gt;
&lt;li&gt;environments and workflows&lt;/li&gt;
&lt;li&gt;constraints (cost, security, compliance)&lt;/li&gt;
&lt;li&gt;how Terraform modules are organized&lt;/li&gt;
&lt;li&gt;what "good" looks like in your system&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Once the AI has this context, its suggestions start to feel less generic and more like they belong to your system. Just like a junior engineer who finally understands how things are wired.&lt;br&gt;
Sample context.md:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight markdown"&gt;&lt;code&gt;&lt;span class="gh"&gt;# Platform Context&lt;/span&gt;

&lt;span class="gu"&gt;## Overview&lt;/span&gt;
This repository manages AWS infrastructure using Terraform.
Primary workloads run on EKS clusters across dev, staging, and production environments.

&lt;span class="gu"&gt;## Key Principles&lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; Prefer managed services where possible
&lt;span class="p"&gt;-&lt;/span&gt; Minimize blast radius of changes
&lt;span class="p"&gt;-&lt;/span&gt; Avoid cross-environment coupling
&lt;span class="p"&gt;-&lt;/span&gt; All changes must go through PR review

&lt;span class="gu"&gt;## Terraform Structure&lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; modules/ → reusable infrastructure components
&lt;span class="p"&gt;-&lt;/span&gt; envs/dev → development environment
&lt;span class="p"&gt;-&lt;/span&gt; envs/staging → staging environment
&lt;span class="p"&gt;-&lt;/span&gt; envs/prod → production environment

&lt;span class="gu"&gt;## Naming Conventions&lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; Resources follow: &lt;span class="nt"&gt;&amp;lt;env&amp;gt;&lt;/span&gt;-&lt;span class="nt"&gt;&amp;lt;service&amp;gt;&lt;/span&gt;-&lt;span class="nt"&gt;&amp;lt;type&amp;gt;&lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; Example: prod-payments-eks

&lt;span class="gu"&gt;## Guardrails&lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; Never modify production directly
&lt;span class="p"&gt;-&lt;/span&gt; No &lt;span class="sb"&gt;`terraform apply`&lt;/span&gt; without PR approval
&lt;span class="p"&gt;-&lt;/span&gt; Avoid changes that trigger resource replacement unless explicitly required

&lt;span class="gu"&gt;## Cost Constraints&lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; Prefer smaller instance types unless justified
&lt;span class="p"&gt;-&lt;/span&gt; Autoscaling should always have upper limits defined

&lt;span class="gu"&gt;## Security&lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; IAM roles must follow least privilege
&lt;span class="p"&gt;-&lt;/span&gt; No wildcard permissions unless explicitly approved

&lt;span class="gu"&gt;## Review Expectations&lt;/span&gt;
When reviewing a Terraform plan, focus on:
&lt;span class="p"&gt;-&lt;/span&gt; Resource replacements
&lt;span class="p"&gt;-&lt;/span&gt; Changes in networking or IAM
&lt;span class="p"&gt;-&lt;/span&gt; Scaling or cost implications
&lt;span class="p"&gt;-&lt;/span&gt; Cross-module impact

&lt;span class="gu"&gt;## What "Good" Looks Like&lt;/span&gt;
&lt;span class="p"&gt;-&lt;/span&gt; Small, isolated changes
&lt;span class="p"&gt;-&lt;/span&gt; Clear PR descriptions
&lt;span class="p"&gt;-&lt;/span&gt; Minimal blast radius
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Once I started using something like this, the difference was noticeable.&lt;br&gt;
The AI responses became less generic and more aligned with how the system was actually designed. It started picking up on patterns like naming conventions, environment separation, and even risk signals like resource replacements.&lt;br&gt;
It felt much closer to working with someone who had been onboarded into the system, rather than someone guessing from scratch.&lt;/p&gt;
&lt;h2&gt;
  
  
  Guardrails Matter More Than Intelligence
&lt;/h2&gt;

&lt;p&gt;When onboarding a new engineer, we don't just give context. We also define boundaries. What they should and should not do. Where they can make changes. What requires review.&lt;br&gt;
AI needs the same guardrails. For example, I'm comfortable letting AI:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;suggest Terraform changes&lt;/li&gt;
&lt;li&gt;explain plan outputs&lt;/li&gt;
&lt;li&gt;summarize pull requests&lt;/li&gt;
&lt;li&gt;generate draft configurations&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;But there are clear boundaries. AI should not:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;directly apply infrastructure changes&lt;/li&gt;
&lt;li&gt;bypass review processes&lt;/li&gt;
&lt;li&gt;make decisions that require operational judgment&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These are not limitations of capability. They are intentional design choices. Because just like with a new engineer, the goal is not maximum autonomy - it is safe contribution.&lt;/p&gt;
&lt;h2&gt;
  
  
  Start With PRs, Not Production
&lt;/h2&gt;

&lt;p&gt;When a new engineer joins, we usually don't give them direct production access on day one. We ask them to start with:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;small changes&lt;/li&gt;
&lt;li&gt;pull requests&lt;/li&gt;
&lt;li&gt;code reviews&lt;/li&gt;
&lt;li&gt;guided feedback&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This builds confidence and trust over time. The same model works extremely well with AI. Instead of letting AI operate directly on infrastructure, I treat it as a contributor to the PR workflow. It can:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;generate changes&lt;/li&gt;
&lt;li&gt;explain diffs&lt;/li&gt;
&lt;li&gt;highlight potential issues&lt;/li&gt;
&lt;li&gt;improve readability&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;But the final decision still goes through human review. This keeps the system safe while still benefiting from AI acceleration.&lt;/p&gt;
&lt;h2&gt;
  
  
  Feedback Loops Make It&amp;nbsp;Better
&lt;/h2&gt;

&lt;p&gt;A junior engineer improves with feedback. AI systems also improve with iteration. When something is off, the answer almost never is:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;AI doesn't work&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;More often, it means:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;"The context was incomplete"&lt;br&gt;
&amp;nbsp;"The prompt didn't reflect constraints"&lt;br&gt;
&amp;nbsp;"The guardrails weren't clear"&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Over time, refining context and expectations makes AI far more reliable. It starts behaving less like a random generator and more like a team member who understands the system.&lt;/p&gt;
&lt;h2&gt;
  
  
  The Real&amp;nbsp;Shift
&lt;/h2&gt;

&lt;p&gt;Thinking of AI as a junior platform engineer changes how you design workflows. Instead of asking:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;"What can this tool do?"&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;You start asking:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;"How would I onboard someone into this system?"&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;That question naturally leads you to:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;better context&lt;/li&gt;
&lt;li&gt;clearer boundaries&lt;/li&gt;
&lt;li&gt;safer workflows&lt;/li&gt;
&lt;li&gt;more predictable outcomes&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;
  
  
  Closing Thought
&lt;/h2&gt;

&lt;p&gt;AI in DevOps doesn't need to be treated as an autonomous operator. In many cases, it works best as a well-onboarded junior engineer:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;guided by context&lt;/li&gt;
&lt;li&gt;constrained by guardrails&lt;/li&gt;
&lt;li&gt;contributing through safe workflows&lt;/li&gt;
&lt;li&gt;improving over time&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The goal is not to replace engineers. It is to make systems easier to understand, safer to operate, and faster to evolve. And sometimes, the best way to do that is not to give AI more power - but to onboard it more thoughtfully.&lt;/p&gt;

&lt;p&gt;Curious to know what you think of this approach.&lt;/p&gt;

&lt;p&gt;Originally published on Medium:&lt;/p&gt;


&lt;div class="crayons-card c-embed text-styles text-styles--secondary"&gt;
    &lt;div class="c-embed__content"&gt;
      &lt;div class="c-embed__body flex items-center justify-between"&gt;
        &lt;a href="https://medium.com/@yogesh.vk/ai-as-a-junior-platform-engineer-how-i-onboard-coding-agents-963e68e22742" rel="noopener noreferrer" class="c-link fw-bold flex items-center"&gt;
          &lt;span class="mr-2"&gt;medium.com&lt;/span&gt;
          

        &lt;/a&gt;
      &lt;/div&gt;
    &lt;/div&gt;
&lt;/div&gt;



</description>
      <category>ai</category>
      <category>devops</category>
      <category>cloudcomputing</category>
      <category>infrastructure</category>
    </item>
    <item>
      <title>Why AI and Automation Are Not Always the Right Answer in DevOps</title>
      <dc:creator>Yogesh VK</dc:creator>
      <pubDate>Fri, 10 Apr 2026 06:00:00 +0000</pubDate>
      <link>https://dev.to/yogesh_vk/why-ai-and-automation-are-not-always-the-right-answer-in-devops-18ch</link>
      <guid>https://dev.to/yogesh_vk/why-ai-and-automation-are-not-always-the-right-answer-in-devops-18ch</guid>
      <description>&lt;p&gt;In DevOps, AI, and platform engineering, speed without understanding can amplify failure.&lt;/p&gt;

&lt;h2&gt;
  
  
  Introduction
&lt;/h2&gt;

&lt;p&gt;Every engineering team reaches this moment sooner or later.&lt;/p&gt;

&lt;p&gt;A repetitive task appears. A process feels slow and folks just say:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Can we just automate this?&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;On the surface, it sounds like the right instinct. DevOps, after all, was built on the idea of reducing manual effort and increasing reliability through automation.&lt;/p&gt;

&lt;p&gt;But in my experience, automation is not always the right first answer.&lt;/p&gt;

&lt;p&gt;Sometimes the process is slow because it contains necessary human judgment. Sometimes the repetition is actually a signal that the underlying system design needs improvement. And increasingly, with AI entering DevOps workflows, there is a temptation to automate decisions that should still remain human.&lt;/p&gt;

&lt;p&gt;The question is not whether something can be automated. The more important question is whether it should be.&lt;/p&gt;

&lt;h2&gt;
  
  
  Automation Often Scales Existing Problems
&lt;/h2&gt;

&lt;p&gt;One of the most common mistakes teams make is automating a broken or poorly understood workflow.&lt;/p&gt;

&lt;p&gt;A manual deployment process may feel slow and frustrating. But if the underlying release steps are unclear, automating them simply means the same confusion now happens faster and at larger scale.&lt;/p&gt;

&lt;p&gt;In infrastructure systems, this can be dangerous.&lt;/p&gt;

&lt;p&gt;A pipeline that automatically pushes Terraform changes into production may look efficient, but if reviewers do not fully understand the blast radius of those changes, automation simply accelerates risk.&lt;/p&gt;

&lt;p&gt;The result is not better engineering. It is faster failure.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Difference Between Repetition and Judgment
&lt;/h2&gt;

&lt;p&gt;Not every repetitive task is suitable for automation.&lt;/p&gt;

&lt;p&gt;Some tasks are repetitive because they are operationally necessary. Others require human context and judgment, even if the steps appear similar.&lt;/p&gt;

&lt;p&gt;For example, reviewing a Terraform plan may seem repetitive. But what the reviewer is actually doing is not checking syntax. They are making decisions about:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;operational risk&lt;/li&gt;
&lt;li&gt;rollback impact&lt;/li&gt;
&lt;li&gt;customer-facing downtime&lt;/li&gt;
&lt;li&gt;security implications
That is not repetition. I think that is judgment.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Automating the process without preserving that judgment layer often removes the most valuable part of the workflow.&lt;/p&gt;

&lt;h2&gt;
  
  
  AI Makes This Even More Tempting
&lt;/h2&gt;

&lt;p&gt;The rise of AI in DevOps workflows makes this challenge even more relevant. AI tools can now can do all of these and more:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;summarize pull requests&lt;/li&gt;
&lt;li&gt;explain Terraform plans&lt;/li&gt;
&lt;li&gt;analyze logs&lt;/li&gt;
&lt;li&gt;suggest infrastructure changes
These are genuinely useful capabilities. But there is an important boundary.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;AI should help engineers understand systems better. It should not replace ownership of decisions.&lt;/p&gt;

&lt;p&gt;For example, using AI to explain a Terraform plan is helpful. Using AI to automatically approve and apply infrastructure changes is often the wrong answer. The operational responsibility still belongs to humans.&lt;/p&gt;

&lt;h2&gt;
  
  
  Good Automation Removes Toil, Not Thinking
&lt;/h2&gt;

&lt;p&gt;The best automation removes toil, not thought. Good examples include some of these:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;automatic formatting checks&lt;/li&gt;
&lt;li&gt;CI validation pipelines&lt;/li&gt;
&lt;li&gt;policy enforcement&lt;/li&gt;
&lt;li&gt;environment cleanup schedules&lt;/li&gt;
&lt;li&gt;cost anomaly alerts
These tasks are repetitive, rules-driven, and low in ambiguity. They benefit greatly from automation. What should remain human are workflows involving uncertainty, trade-offs, and accountability.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The Better Question to Ask&lt;br&gt;
Instead of asking:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Can we automate this?&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;A better question is:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;What part of this process is pure toil, and what part requires human judgment?&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;That distinction changes everything. Once you separate toil from judgment, automation becomes much safer and much more effective.&lt;/p&gt;
&lt;h2&gt;
  
  
  Closing Thought
&lt;/h2&gt;

&lt;p&gt;In DevOps and platform engineering, automation is incredibly powerful.&lt;/p&gt;

&lt;p&gt;But the goal should never be automation for its own sake. The goal is better systems in my opinion.&lt;/p&gt;

&lt;p&gt;Sometimes that means automation. Sometimes it means improving engineers and systems understanding first.&lt;/p&gt;

&lt;p&gt;And increasingly, with AI in the mix, it means being very deliberate about what we allow machines to decide on our behalf.&lt;/p&gt;

&lt;p&gt;Because not every slow process is a bad one. Some of them are where engineering judgment actually lives..&lt;/p&gt;

&lt;p&gt;Do you feel the same way?&lt;/p&gt;

&lt;p&gt;Originally published on Medium:&lt;/p&gt;


&lt;div class="crayons-card c-embed text-styles text-styles--secondary"&gt;
    &lt;div class="c-embed__content"&gt;
      &lt;div class="c-embed__body flex items-center justify-between"&gt;
        &lt;a href="https://medium.com/@yogesh.vk/why-ai-and-automation-are-not-always-the-right-answer-in-devops-8c0cb5e439bf" rel="noopener noreferrer" class="c-link fw-bold flex items-center"&gt;
          &lt;span class="mr-2"&gt;medium.com&lt;/span&gt;
          

        &lt;/a&gt;
      &lt;/div&gt;
    &lt;/div&gt;
&lt;/div&gt;


</description>
      <category>ai</category>
      <category>devops</category>
      <category>sre</category>
    </item>
    <item>
      <title>Using AI to Explain Terraform Plans to Humans</title>
      <dc:creator>Yogesh VK</dc:creator>
      <pubDate>Fri, 27 Mar 2026 06:16:00 +0000</pubDate>
      <link>https://dev.to/yogesh_vk/using-ai-to-explain-terraform-plans-to-humans-3dp4</link>
      <guid>https://dev.to/yogesh_vk/using-ai-to-explain-terraform-plans-to-humans-3dp4</guid>
      <description>&lt;p&gt;Turning raw infrastructure diffs into decisions engineers can actually understand.&lt;/p&gt;

&lt;h2&gt;
  
  
  INTRODUCTION
&lt;/h2&gt;

&lt;p&gt;Terraform plans are incredibly precise. They show every resource change, attribute modification, and dependency update that will occur during an apply.&lt;br&gt;
But precision is not the same as clarity.&lt;br&gt;
For many engineers reviewing infrastructure changes, Terraform plans feel more like a wall of text than a meaningful explanation of what is about to happen. The information is there, but extracting the real implications often requires experience and careful reading.&lt;/p&gt;

&lt;p&gt;This is exactly where AI can become useful. Not by executing infrastructure changes, but by translating Terraform plans into something humans can reason about.&lt;/p&gt;
&lt;h2&gt;
  
  
  THE PROBLEM WITH RAW TERRAFORM PLANS
&lt;/h2&gt;

&lt;p&gt;Terraform's plan output is designed for correctness, not readability.&lt;br&gt;
It faithfully lists changes such as resource replacements, attribute updates, and dependency adjustments. While this is ideal for machines and precise workflows, it can make reviews difficult for humans, especially in larger environments.&lt;br&gt;
A simple plan might include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;hundreds of attribute updates&lt;/li&gt;
&lt;li&gt;nested resource changes&lt;/li&gt;
&lt;li&gt;implicit dependencies across modules&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;What reviewers actually want to know is much simpler:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What changed?&lt;/li&gt;
&lt;li&gt;Why does it matter?&lt;/li&gt;
&lt;li&gt;Is the risk acceptable?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Terraform itself does not answer those questions.&lt;/p&gt;
&lt;h2&gt;
  
  
  WHERE HUMAN REVIEW BREAKS&amp;nbsp;DOWN
&lt;/h2&gt;

&lt;p&gt;Experienced engineers eventually develop an instinct for reading Terraform plans. They scan for dangerous signals:&lt;br&gt;
resource replacement&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;subnet or network changes&lt;/li&gt;
&lt;li&gt;IAM policy expansions&lt;/li&gt;
&lt;li&gt;scaling changes in compute clusters&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;But this intuition takes time to build, and even experienced reviewers can miss subtle interactions when reviewing large changes late in the day or under delivery pressure.&lt;br&gt;
The real problem isn't lack of information. It's cognitive load.&lt;/p&gt;

&lt;p&gt;Terraform tells us everything. Humans only need to understand the important parts.&lt;/p&gt;
&lt;h2&gt;
  
  
  WHY AI IS GOOD AT THIS&amp;nbsp;PROBLEM
&lt;/h2&gt;

&lt;p&gt;AI models are particularly good at summarizing structured text and identifying patterns.&lt;br&gt;
A Terraform plan contains many signals that AI can interpret effectively:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;which resources will be created, updated, or destroyed&lt;/li&gt;
&lt;li&gt;whether replacements will occur&lt;/li&gt;
&lt;li&gt;potential cost changes&lt;/li&gt;
&lt;li&gt;security-sensitive modifications&lt;/li&gt;
&lt;li&gt;large blast-radius changes&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Instead of forcing humans to parse hundreds of lines of output, AI can produce a concise summary describing the operational impact.&lt;br&gt;
This transforms the Terraform plan from a raw diff into an explanation.&lt;/p&gt;
&lt;h2&gt;
  
  
  AI AS A REVIEW ASSISTANT IN&amp;nbsp;CI/CD
&lt;/h2&gt;

&lt;p&gt;A practical place to integrate this capability is within CI/CD pipelines.&lt;br&gt;
After generating a Terraform plan, a pipeline step can feed the plan output into an AI model. The model then produces a human-readable summary that is attached to the pull request.&lt;br&gt;
Instead of reviewing raw plan text alone, engineers see a structured explanation such as:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Risk Summary: This change replaces the EKS node group, which will trigger a rolling replacement of worker nodes.
Security Impact: No IAM policies were expanded.
Cost Impact: Estimated monthly increase: approximately $120 due to increased instance size.
Operational Notes: Node replacement may temporarily reduce cluster capacity during rollout.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;This type of explanation does not replace the Terraform plan. It simply helps humans understand it faster.&lt;/p&gt;
&lt;h2&gt;
  
  
  USING GITHUB ACTIONS FOR AI-ASSISTED PLAN&amp;nbsp;REVIEWS
&lt;/h2&gt;

&lt;p&gt;GitHub Actions provides a natural place to implement this pattern.&lt;br&gt;
A typical pipeline already includes steps like formatting, validation, and plan generation. Adding an AI analysis step is straightforward and can operate entirely in read-only mode.&lt;br&gt;
The workflow might look like:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Run terraform plan&lt;/li&gt;
&lt;li&gt;Export plan output as JSON&lt;/li&gt;
&lt;li&gt;Send plan summary to an AI model&lt;/li&gt;
&lt;li&gt;Post a structured explanation as a pull request comment&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The key point is that the AI does not change infrastructure or execute Terraform commands. It only interprets the plan and produces a human-readable summary.&lt;br&gt;
This keeps the decision-making process firmly in human hands.&lt;/p&gt;
&lt;h2&gt;
  
  
  WHY THIS IMPROVES INFRASTRUCTURE SAFETY
&lt;/h2&gt;

&lt;p&gt;When infrastructure reviews fail, it is rarely because Terraform produced incorrect output.&lt;br&gt;
Failures occur because reviewers misinterpret the impact or miss important signals hidden within large plans.&lt;br&gt;
AI-assisted explanations reduce that risk by highlighting the kinds of changes humans care about most:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;replacements&lt;/li&gt;
&lt;li&gt;deletions&lt;/li&gt;
&lt;li&gt;network changes&lt;/li&gt;
&lt;li&gt;permission expansions&lt;/li&gt;
&lt;li&gt;scaling adjustments&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The AI becomes a second set of eyes, helping reviewers focus their attention where it matters.&lt;/p&gt;
&lt;h2&gt;
  
  
  THE IMPORTANT BOUNDARY
&lt;/h2&gt;

&lt;p&gt;Even though AI can interpret plans effectively, it should never be allowed to execute them.&lt;br&gt;
Running terraform apply still requires human ownership and operational judgment. AI can explain consequences, but it cannot decide whether those consequences are acceptable.&lt;br&gt;
That boundary is what keeps AI useful rather than dangerous.&lt;/p&gt;
&lt;h2&gt;
  
  
  CLOSING THOUGHT
&lt;/h2&gt;

&lt;p&gt;Terraform already tells us what will change.&lt;br&gt;
AI helps answer the more useful question: What does this change actually mean?&lt;/p&gt;

&lt;p&gt;By turning raw infrastructure diffs into clear explanations, AI allows DevOps teams to review changes faster, understand risk better, and make more confident decisions.&lt;br&gt;
And that is exactly where AI belongs in infrastructure workflows - helping humans think more clearly, not replacing their judgment.&lt;/p&gt;

&lt;p&gt;How does your team review Terraform plans today - raw output, custom tooling, or something smarter?&lt;/p&gt;

&lt;p&gt;Originally published on Medium:&lt;br&gt;
&lt;/p&gt;
&lt;div class="crayons-card c-embed text-styles text-styles--secondary"&gt;
    &lt;div class="c-embed__content"&gt;
      &lt;div class="c-embed__body flex items-center justify-between"&gt;
        &lt;a href="https://medium.com/@yogesh.vk/using-ai-to-explain-terraform-plans-to-humans-e631b264fafd" rel="noopener noreferrer" class="c-link fw-bold flex items-center"&gt;
          &lt;span class="mr-2"&gt;medium.com&lt;/span&gt;
          

        &lt;/a&gt;
      &lt;/div&gt;
    &lt;/div&gt;
&lt;/div&gt;



</description>
      <category>ai</category>
      <category>devops</category>
      <category>terraform</category>
      <category>cicd</category>
    </item>
    <item>
      <title>5 Expensive Terraform Mistakes I Keep Seeing in Real Infrastructure and How AI can Help</title>
      <dc:creator>Yogesh VK</dc:creator>
      <pubDate>Fri, 20 Mar 2026 06:15:00 +0000</pubDate>
      <link>https://dev.to/yogesh_vk/5-expensive-terraform-mistakes-i-keep-seeing-in-real-infrastructure-and-how-ai-can-help-2m38</link>
      <guid>https://dev.to/yogesh_vk/5-expensive-terraform-mistakes-i-keep-seeing-in-real-infrastructure-and-how-ai-can-help-2m38</guid>
      <description>&lt;p&gt;Small infrastructure decisions that quietly turn into large cloud bills&lt;br&gt;
Infrastructure-as-Code has dramatically improved how teams manage cloud environments. Terraform in particular has made it possible to define infrastructure in version-controlled, repeatable configurations.&lt;/p&gt;

&lt;p&gt;In theory, this should make infrastructure both predictable and efficient.&lt;/p&gt;

&lt;p&gt;In practice, however, Terraform does not automatically make systems cost-efficient. It simply makes infrastructure changes easier to reproduce. If inefficient patterns exist in the configuration, Terraform will reproduce them perfectly.&lt;/p&gt;

&lt;p&gt;Over time, small infrastructure decisions accumulate. Many of them appear harmless when introduced, but months later they become visible as unexpectedly large cloud bills.&lt;/p&gt;

&lt;p&gt;Here are some of the most common Terraform patterns I keep seeing that quietly drive up infrastructure costs.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Oversized Compute That Never Gets Revisited
&lt;/h2&gt;

&lt;p&gt;One of the most common patterns starts early in a project.&lt;/p&gt;

&lt;p&gt;During initial development, engineers often choose slightly larger instance types to avoid performance issues. It is safer to start with extra capacity rather than risk under-provisioning a critical service.&lt;/p&gt;

&lt;p&gt;The problem is that these instance sizes often remain unchanged long after workloads stabilize.&lt;/p&gt;

&lt;p&gt;Terraform makes it easy to define infrastructure once and leave it untouched. As long as systems continue running without obvious performance problems, there is little incentive to revisit instance sizing decisions.&lt;/p&gt;

&lt;p&gt;Over time, this leads to clusters and services running on instance types that are significantly larger than necessary.&lt;/p&gt;

&lt;p&gt;This issue is particularly visible in Kubernetes clusters, where node groups are frequently defined with conservative sizing assumptions. If workloads later become more efficient, the underlying infrastructure may remain over-provisioned indefinitely.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Resource Replacements Triggered by Small Configuration Changes
Terraform’s declarative model means that certain configuration changes require resources to be replaced rather than updated.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;For example, modifying attributes such as subnet associations, encryption settings, or instance types may cause Terraform to destroy and recreate a resource.&lt;/p&gt;

&lt;p&gt;While Terraform clearly reports these replacements in the plan output, the operational and financial impact is not always obvious during review.&lt;/p&gt;

&lt;p&gt;Replacing compute clusters, databases, or node groups can temporarily increase infrastructure usage, create additional storage snapshots, or trigger redeployment processes that consume additional resources.&lt;/p&gt;

&lt;p&gt;When these replacements happen frequently across environments, they can contribute to unexpectedly high infrastructure costs.&lt;/p&gt;

&lt;p&gt;This is one reason many teams are beginning to use AI-assisted plan analysis in CI pipelines — to highlight resource replacements and explain their operational impact before they are applied.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Logging and Observability Configurations That Grow Without Limits
Terraform is often used to provision logging pipelines and observability systems. These systems are essential for debugging and monitoring production environments.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;However, logging configurations are frequently defined with very generous defaults.&lt;/p&gt;

&lt;p&gt;For example, teams may configure:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;high verbosity log levels&lt;/li&gt;
&lt;li&gt;long retention periods&lt;/li&gt;
&lt;li&gt;large ingestion pipelines
These settings are useful during development but are rarely revisited as systems mature.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Because Terraform configurations remain stable over time, these logging pipelines can continue collecting massive volumes of data long after the original debugging needs have passed.&lt;/p&gt;

&lt;p&gt;In some environments, observability costs eventually exceed the cost of the infrastructure being monitored.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Idle Infrastructure Environments
Another common Terraform pattern involves environment duplication.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Many organizations create separate environments for development, staging, integration testing, and experimentation. Terraform makes it easy to spin up these environments using identical modules.&lt;/p&gt;

&lt;p&gt;The problem is that these environments often remain running continuously even when they are rarely used.&lt;/p&gt;

&lt;p&gt;A staging environment that runs databases, compute nodes, load balancers, and storage resources can easily cost hundreds of dollars per month. Multiply that across multiple teams and environments, and the cost grows quickly.&lt;/p&gt;

&lt;p&gt;In many cases, these environments are only actively used during working hours.&lt;br&gt;
Automated scheduling policies or environment lifecycle management can dramatically reduce this waste, but these controls are rarely implemented initially.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Storage That Quietly Accumulates
Storage resources are particularly prone to long-term cost growth.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Terraform configurations frequently create:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;snapshots&lt;/li&gt;
&lt;li&gt;backups&lt;/li&gt;
&lt;li&gt;object storage buckets&lt;/li&gt;
&lt;li&gt;artifact repositories
Because storage is relatively inexpensive per gigabyte, these resources often grow without much scrutiny.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Over time, however, storage layers accumulate historical artifacts that are rarely accessed but continue to incur costs.&lt;/p&gt;

&lt;p&gt;Common examples include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;old database snapshots that were never cleaned up&lt;/li&gt;
&lt;li&gt;log archives retained indefinitely&lt;/li&gt;
&lt;li&gt;unused container images in registries&lt;/li&gt;
&lt;li&gt;artifact storage from old CI pipelines
Without lifecycle policies, these storage systems gradually become long-term archives rather than operational infrastructure.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Why These Issues Are Hard to Detect&lt;br&gt;
The most expensive Terraform mistakes rarely appear as obvious misconfigurations.&lt;/p&gt;

&lt;p&gt;Instead, they emerge gradually as systems evolve.&lt;/p&gt;

&lt;p&gt;Each decision may appear reasonable in isolation. The instance size seems safe. The logging level helps debugging. The staging environment might be needed later.&lt;/p&gt;

&lt;p&gt;The problem is that Terraform faithfully preserves these decisions over time.&lt;/p&gt;

&lt;p&gt;Without regular review, infrastructure configurations slowly drift away from the actual needs of the system.&lt;/p&gt;

&lt;p&gt;How AI Can Help Detect These Patterns Earlier&lt;br&gt;
AI cannot fix infrastructure architecture problems automatically. But it can help identify patterns that humans might overlook.&lt;/p&gt;

&lt;p&gt;For example, AI systems analyzing infrastructure configurations or Terraform plans can highlight signals such as:&lt;/p&gt;

&lt;p&gt;compute resources that appear significantly over-provisioned&lt;br&gt;
environments that remain idle for long periods&lt;br&gt;
storage resources that grow continuously without access&lt;br&gt;
resource replacements that may trigger unnecessary redeployments&lt;br&gt;
These insights allow teams to review infrastructure decisions earlier rather than discovering problems only when the monthly bill arrives.&lt;/p&gt;

&lt;p&gt;The Real Lesson&lt;br&gt;
Terraform is an incredibly powerful tool for managing infrastructure. But like any automation system, it faithfully executes the decisions encoded within it.&lt;/p&gt;

&lt;p&gt;If inefficient patterns exist in the configuration, Terraform will reproduce them perfectly every time.&lt;/p&gt;

&lt;p&gt;The goal is not to avoid mistakes entirely. That is unrealistic in complex systems.&lt;/p&gt;

&lt;p&gt;The goal is to detect small inefficiencies early — before they accumulate into large and expensive infrastructure problems.&lt;/p&gt;

&lt;p&gt;Closing Thought&lt;br&gt;
Cloud costs rarely explode because of one catastrophic decision.&lt;/p&gt;

&lt;p&gt;More often, they grow quietly from dozens of small infrastructure choices that were never revisited.&lt;/p&gt;

&lt;p&gt;Terraform gives us the power to manage infrastructure systematically. The challenge is making sure the systems we define remain aligned with how they are actually used.&lt;/p&gt;

&lt;p&gt;That requires continuous review, feedback, and sometimes a second set of eyes — whether human or machine.&lt;/p&gt;

&lt;p&gt;Originally published on Medium:&lt;br&gt;
&lt;a href="https://medium.com/@yogesh.vk/5-expensive-terraform-mistakes-i-keep-seeing-in-real-infrastructure-and-how-ai-can-help-9a4849ddfc91" rel="noopener noreferrer"&gt;https://medium.com/@yogesh.vk/5-expensive-terraform-mistakes-i-keep-seeing-in-real-infrastructure-and-how-ai-can-help-9a4849ddfc91&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>devops</category>
      <category>terraform</category>
      <category>aws</category>
    </item>
    <item>
      <title>AI for DevOps and Platform Engineering: Practical Use Cases That Actually Work</title>
      <dc:creator>Yogesh VK</dc:creator>
      <pubDate>Fri, 13 Mar 2026 04:53:55 +0000</pubDate>
      <link>https://dev.to/yogesh_vk/ai-for-devops-and-platform-engineering-practical-use-cases-that-actually-work-2a63</link>
      <guid>https://dev.to/yogesh_vk/ai-for-devops-and-platform-engineering-practical-use-cases-that-actually-work-2a63</guid>
      <description>&lt;p&gt;Moving beyond hype to real workflows where AI improves infrastructure engineering, and where AI is actually useful for DevOps and Platform Engineering teams today.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;INTRODUCTION&lt;/strong&gt;&lt;br&gt;
AI is rapidly entering every corner of software engineering. DevOps and platform teams are no exception. New tools promise to generate infrastructure code, manage deployments, and even run operations autonomously.&lt;/p&gt;

&lt;p&gt;But most experienced infrastructure engineers react with skepticism.&lt;/p&gt;

&lt;p&gt;Infrastructure systems are complex, stateful, and deeply interconnected. Blind automation often introduces more risk than it removes. The question is not whether AI can be used in DevOps workflows — it is where it should be used, and where it should not.&lt;/p&gt;

&lt;p&gt;The most effective teams are not replacing engineers with AI. They are using AI to reduce cognitive load, surface hidden risks, and make better operational decisions.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;THE SHIFT FROM AUTOMATION TO ASSISTED DECISION-MAKING&lt;/strong&gt;&lt;br&gt;
For years, DevOps focused heavily on automation. CI/CD pipelines automated builds, tests, deployments, and infrastructure provisioning. Infrastructure-as-Code tools like Terraform allowed teams to define environments in reproducible ways.&lt;/p&gt;

&lt;p&gt;AI introduces a new layer to this model.&lt;/p&gt;

&lt;p&gt;Instead of simply automating actions, AI can assist engineers in understanding the consequences of those actions. It becomes a reasoning layer that helps interpret complex systems rather than directly controlling them.&lt;/p&gt;

&lt;p&gt;In practice, this means AI is most valuable when it explains systems, analyzes changes, and highlights risk.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;AI FOR INFRASTRUCTURE CODE REVIEWS&lt;/strong&gt;&lt;br&gt;
Infrastructure changes often carry significant risk. A single change in Terraform can replace compute clusters, modify network boundaries, or expand IAM permissions.&lt;/p&gt;

&lt;p&gt;Traditional CI pipelines verify syntax and policy compliance, but they rarely explain the real impact of a change.&lt;/p&gt;

&lt;p&gt;AI can help fill this gap by reviewing Terraform plans and summarizing their implications. Instead of manually scanning hundreds of lines of plan output, engineers can see a concise explanation of what will change and why it matters.&lt;/p&gt;

&lt;p&gt;This turns infrastructure reviews into clearer conversations about risk and intent.&lt;/p&gt;

&lt;p&gt;Raw Terraform Plan (excerpt):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight terraform"&gt;&lt;code&gt;&lt;span class="c1"&gt;# aws_eks_node_group.platform_nodes must be replaced&lt;/span&gt;
&lt;span class="nx"&gt;-&lt;/span&gt;&lt;span class="err"&gt;/+&lt;/span&gt; &lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"aws_eks_node_group"&lt;/span&gt; &lt;span class="s2"&gt;"platform_nodes"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nx"&gt;instance_types&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"t3.large"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="nx"&gt;-&lt;/span&gt;&lt;span class="err"&gt;&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"m5.large"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="nx"&gt;scaling_config&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="nx"&gt;desired_size&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt; &lt;span class="nx"&gt;-&lt;/span&gt;&lt;span class="err"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;AI-Generated Explanation:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Terraform Plan Summary
High Impact Change
- EKS node group "platform_nodes" will be replaced
- Worker nodes will be recreated
Operational Impact
- Pods will be rescheduled during node replacement
- Temporary capacity reduction possible
Cost Impact
- Instance type upgrade (t3.large → m5.large)
- Estimated monthly increase: ~$120
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;&lt;strong&gt;AI IN CI/CD PIPELINES&lt;/strong&gt;&lt;br&gt;
CI/CD pipelines are another natural integration point for AI.&lt;/p&gt;

&lt;p&gt;Modern pipelines already perform many automated checks:&lt;/p&gt;

&lt;p&gt;formatting validation&lt;br&gt;
policy enforcement&lt;br&gt;
dependency scanning&lt;br&gt;
infrastructure plan generation&lt;br&gt;
AI can extend this pipeline by interpreting the results of those checks.&lt;/p&gt;

&lt;p&gt;For example, an AI step in a GitHub Actions workflow might analyze a Terraform plan and generate a structured summary highlighting resource replacements, cost changes, or security-sensitive updates.&lt;/p&gt;

&lt;p&gt;The pipeline still requires human approval before changes are applied. AI simply improves the context available to reviewers.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Terraform Plan Review&lt;/span&gt;
&lt;span class="na"&gt;on&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
 &lt;span class="na"&gt;pull_request&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
&lt;span class="na"&gt;jobs&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
 &lt;span class="na"&gt;terraform-plan&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
   &lt;span class="na"&gt;runs-on&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;ubuntu-latest&lt;/span&gt;
   &lt;span class="na"&gt;steps&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
     &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;uses&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;actions/checkout@v4&lt;/span&gt;
     &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Run Terraform Plan&lt;/span&gt;
       &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;terraform plan -out=tfplan&lt;/span&gt;
     &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Convert plan to JSON&lt;/span&gt;
       &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;terraform show -json tfplan &amp;gt; plan.json&lt;/span&gt;
     &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;AI Plan Analysis&lt;/span&gt;
       &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;|&lt;/span&gt;
         &lt;span class="s"&gt;ai-review plan.json &amp;gt; plan-summary.md&lt;/span&gt;
     &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Post summary to PR&lt;/span&gt;
       &lt;span class="na"&gt;uses&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;marocchino/sticky-pull-request-comment@v2&lt;/span&gt;
       &lt;span class="na"&gt;with&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
         &lt;span class="na"&gt;path&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;plan-summary.md&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;The AI step reads the Terraform plan and generates a human-readable summary posted directly into the pull request.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;AI FOR SHIFT-LEFT INFRASTRUCTURE SECURITY&lt;/strong&gt;&lt;br&gt;
DevSecOps practices encourage teams to identify security risks earlier in the development lifecycle. However, infrastructure security policies are often difficult to interpret or enforce consistently.&lt;br&gt;
AI can assist by analyzing infrastructure definitions and identifying potential issues before they reach production.&lt;/p&gt;

&lt;p&gt;For example, an AI assistant could flag:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;overly permissive IAM policies&lt;/li&gt;
&lt;li&gt;public exposure of internal services&lt;/li&gt;
&lt;li&gt;misconfigured storage access&lt;/li&gt;
&lt;li&gt;network boundary changes&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These insights can appear during pull request reviews or pipeline checks, allowing teams to address security concerns before deployment.&lt;/p&gt;

&lt;p&gt;Example PR comment:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Infrastructure Security Review
Issue Detected
- S3 bucket allows public read access
Resource
aws_s3_bucket.website_assets
Risk
Public exposure of application assets.

Suggested Fix
Add block_public_acls = true
Add block_public_policy = true
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;&lt;strong&gt;AI FOR OBSERVABILITY AND INCIDENT RESPONSE&lt;/strong&gt;&lt;br&gt;
Operations teams often face the challenge of interpreting large volumes of monitoring data.&lt;/p&gt;

&lt;p&gt;Logs, metrics, and alerts can provide enormous amounts of information, but identifying the root cause of an issue still requires human reasoning.&lt;/p&gt;

&lt;p&gt;AI can assist by analyzing telemetry data and highlighting patterns that indicate emerging problems. Instead of scanning dashboards and logs manually, engineers receive summaries that connect signals across systems.&lt;/p&gt;

&lt;p&gt;Used carefully, this can reduce alert fatigue and accelerate incident investigation.&lt;/p&gt;

&lt;p&gt;Example:&lt;br&gt;
Raw logs:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;ERROR connection timeout db-primary
ERROR connection timeout db-primary
ERROR connection timeout db-primary
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;AI explanation:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Alert Analysis
 Pattern Detected
    Repeated connection failures to database cluster.
 Likely Cause
    Database connection pool exhaustion.
Suggested Investigation
    Check RDS connection limits and application pool size.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;This ties AI to real operations.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;WHERE AI SHOULD NOT BE USED&lt;/strong&gt;&lt;br&gt;
Despite its strengths, AI should not be allowed to control critical infrastructure operations without human oversight.&lt;/p&gt;

&lt;p&gt;Executing infrastructure changes, approving deployments, or modifying security policies are decisions that carry operational responsibility.&lt;/p&gt;

&lt;p&gt;AI can provide insight, but it cannot own the consequences of those decisions.&lt;/p&gt;

&lt;p&gt;The most effective DevOps teams treat AI as an assistant rather than an operator.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;BUILDING AI-AUGMENTED PLATFORM WORKFLOWS&lt;/strong&gt;&lt;br&gt;
The real opportunity is not replacing DevOps workflows, but enhancing them.&lt;/p&gt;

&lt;p&gt;A healthy AI-assisted platform might include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;AI explanations for Terraform plans&lt;/li&gt;
&lt;li&gt;AI-generated summaries for infrastructure pull requests&lt;/li&gt;
&lt;li&gt;AI-assisted security analysis during CI/CD&lt;/li&gt;
&lt;li&gt;AI-powered analysis of observability data
Each capability improves clarity and reduces cognitive load while preserving human ownership of operational decisions.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;CLOSING THOUGHT&lt;/strong&gt;&lt;br&gt;
AI will undoubtedly influence how infrastructure systems are built and operated. But its greatest value will not come from replacing engineers.&lt;/p&gt;

&lt;p&gt;It will come from helping them understand increasingly complex systems.&lt;/p&gt;

&lt;p&gt;DevOps was originally about bringing development and operations closer together. The next phase may be about bringing human judgment and machine insight into better balance.&lt;/p&gt;

&lt;p&gt;

&lt;/p&gt;
&lt;div class="crayons-card c-embed text-styles text-styles--secondary"&gt;
    &lt;div class="c-embed__content"&gt;
      &lt;div class="c-embed__body flex items-center justify-between"&gt;
        &lt;a href="https://medium.com/@yogesh.vk/ai-for-devops-and-platform-engineering-practical-use-cases-that-actually-work-efadc4a90f70?postPublishedType=initial" rel="noopener noreferrer" class="c-link fw-bold flex items-center"&gt;
          &lt;span class="mr-2"&gt;medium.com&lt;/span&gt;
          

        &lt;/a&gt;
      &lt;/div&gt;
    &lt;/div&gt;
&lt;/div&gt;





</description>
      <category>terraform</category>
      <category>ai</category>
      <category>cicd</category>
      <category>monitoring</category>
    </item>
  </channel>
</rss>
