DevOps in the age of AI: what changed, what didn’t, and what’s next

Intro

The AI revolution changed how we work. And it continues to change it every day.
It’s hard to find a field that hasn’t been impacted since the launch of ChatGPT in November 2022 - and I’m not only talking about the high-tech industry.
It’s getting harder to remember how we used to write code by ourselves - back when documentation and Stack Overflow were our best friends.

And now?
It’s been a while since I’ve written a piece of code completely on my own.
That shift says a lot about how the role itself has changed.
This is what we’re going to discuss in this post: DevOps in the AI era.
What changed, what stayed the same, and where we’re heading.

I’m Orel Bello, an AWS Community Builder and a DevOps Engineer with 5 years’ experience working both before AI tools became part of our daily workflow and since.
So, do I have fewer tasks now that we’ve embraced AI?
Not at all. The opposite. The workload has only grown.
So how does that make sense?
Shouldn’t AI be making our lives easier?
That’s what we’re going to answer here.

So how did DevOps work before?

As you already know, DevOps is not a set of tools. It’s a methodology.
There isn’t a fixed stack every DevOps engineer should use, but there are shared concepts.
CI/CD pipelines, IaC, cloud, monitoring, incident management, and more.
How you implement them is up to you.
The tools change. The idea stays the same.

• You wrote CI/CD pipelines by hand, with the help of documentation.
• You defined infrastructure with IaC, constantly verifying changes with plan, or using external Terraform modules.
• You wrote Bash scripts and Python automations through trial and error.
• You run applications on compute resources, handling scaling with custom metrics.
• You monitored systems using observability tools, deciding what to track based on your understanding of the system.
• And when something broke, what did you do?
• You debugged it yourself - logs, metrics, and yes, sometimes prints in the code to figure out where things were crashing.

So basically, you had to understand the system from end to end.

And today?

It’s different.
You don’t know something? Ask AI.
Even if it’s something specific to your system - with enough context, it can still help.
AI can help with a lot of tasks - and usually faster than we used to do them ourselves.

But the core idea hasn’t changed.
DevOps is still responsible for the same domains:
CI/CD, monitoring, automation, IaC, and cloud.
So where’s the real difference?
Let’s start with the obvious one: writing code.

I’ve always preferred writing simple code.Easy to write. Easy to read. Easy to understand. Easy to debug. But even simple code took time.
You had to search documentation, rely on your Googling skills, and hope the snippet you found would actually work.

And today?
You describe what you want - and AI generates it.
But here’s the catch.
When AI generates large amounts of code, the temptation to skip deep understanding is real.
And that’s a significant shift.
Debugging follows the same pattern - AI helps you move faster, but it also changes how you approach the problem.
One of the most important skills today isn’t just coding - it’s prompting.

You don’t need to remember every syntax detail, but you do need to clearly describe what you want and validate the result.
And it doesn’t stop at application code.
AI can generate Terraform.
AI can generate CI/CD pipelines.
You’ve had an incident?
You might still turn to logs and metrics - but now you also have AI tools (like AWS DevOps Agent) that help analyze and guide the investigation.

So, why did the workload increase?

If AI makes everything faster, why are we doing more work instead of less?
The answer comes in two parts.

1. Productivity has exploded Our productivity has increased dramatically.Tasks that used to take weeks or months can now be done in days. So naturally, we take on more tasks. AI didn’t reduce the amount of work. It reduced the cost of doing work. In short - we still do the same DevOps work, but faster and at a larger scale.

Let’s take a look at a real-world example:
Managing large-scale Cloudflare's configurations manually (like hundreds of DNS records, security rules, and certificates across multiple environments) used to be a long and painful process.
Migrating something like this to Terraform could take months - writing code, importing resources one by one, verifying every step.
It’s the kind of task many teams would avoid.

And today?
The same task becomes much more achievable for a single engineer - and much faster.
We’re talking days to weeks instead of months.

1. The scope has expanded We didn’t just speed up DevOps. We expanded it. AI introduced new capabilities - and with them, new responsibilities. Like Uncle Ben said: “With great power comes great responsibility.” AI can accelerate a lot of things - but it can also create new risks if not used carefully. You don’t even need extreme examples. Here are things I’ve personally experienced:

• AI pushing directly to the main branch
• Deleting code it shouldn’t
• Creating excessive commits for small changes

• Losing context in the middle of critical tasks, leaving you hanging
  So, alongside the new capabilities, we now have new risks that need to be managed.
  We now have to think about things that didn’t exist before:

• Security

• Prompt injection, data leakage, model access

• FinOps

• Every request has a cost - tokens, inference, compute

• Guardrails

• What the system is allowed to do and what it isn’t

• Agents

• Systems that act on our behalf and need boundaries
  The system didn’t get simpler.
  It got bigger.

New capabilities

It’s not just about doing the same work faster.
We can now do things that weren’t really feasible before.
AI agents are a good example.
Before, we built self-service tools - predefined automations for specific use cases.
Creating an RDS user, provisioning a secret, spinning up a cluster.

And now?
Instead of building a flow for every use case, we can let the user describe what they want - and let the system handle a large part of the process.
Is it perfect? No.
Does it require guardrails and validation? Absolutely.
But it changes how we think about automation.
Let’s take a look at a real-world example:
We work with multiple platforms, including AWS, CircleCI, MongoDB, and Datadog.
Tracking cost and usage trends across all of them used to be heavy manual work.
Every month, we had to:

• collect data
• analyze trends
• find anomalies
• explain cost spikes So we built an AI-based flow to handle this. Using CircleCI, we run AI-driven logic (Claude code) that integrates with each platform. It fetches data, analyzes trends, and produces a report with insights. What used to take hours of manual work every month is now automated.

What stayed the same

Even though the way we work on a daily basis has changed dramatically, the core concepts remain the same.
The scope of DevOps hasn’t been reduced by AI - if anything, it expanded.
We are still doing the same kind of work we did before.
DevOps is still DevOps.
Just running faster than ever.

AI brings new challenges, but it’s also a massive power multiplier.
You don’t really have the privilege of ignoring it.
Anyone who keeps working the same way we did 5 years ago will fall behind.
That doesn’t mean you need to try every new AI tool that comes out - that’s a fast way to burn out.
Instead, pick 1–2 tools that you use daily (for example, Cursor or Claude Code), and actually integrate them into your workflow.
You’ll be surprised how tasks you kept postponing suddenly become doable in minutes.

The problem for juniors

There is one group that this shift impacts the most: juniors.
Juniors are in a tricky spot.

On one hand, they now have the ability to work on complex tasks and build full workflows with just a few prompts.
But on the other hand, if they rely on AI without building a strong foundation, it becomes risky.
If you don’t understand the basics, you can’t really validate what AI gives you.
You won’t know when it’s correct - and more importantly, when it’s wrong.
AI is powerful, but it still needs a gatekeeper.
If you just let it generate everything without questioning it, what value are you actually bringing?
Don’t leave your judgment at the door.
Question everything.
That’s how you stay relevant in the AI era.

Where we’re heading

Let’s talk about the elephant in the room.
Will DevOps still exist 10 years from now?
There are opinions in both directions.
Honestly? No one really knows.
But for now, DevOps is here to stay, and to evolve.
Right now, I don’t see companies replacing their DevOps teams with AI.
What I do see is teams using AI to become faster and more effective.
So instead of worrying about being replaced, focus on using AI to become better at what you do.

What can we expect going forward?
More AI tools.
More agents.
More workflows that simplify complex tasks.
We’ll keep moving faster.
We’ll spend more time building things that actually drive innovation.
And yes - in some ways, it will make our lives easier.
But at the same time, it will require more responsibility, more awareness, and better decision-making on our part.

Conclusion

So did AI make our lives easier?
Yes - and no.
It made each task easier.
But it also raised the bar.
We move faster.
We build more.
We are responsible for more.
DevOps didn’t get simpler.
It got bigger.
And that’s exactly why it matters more than ever.