AI Won’t Be Productive By Default (And That’s OK)

Remember when we thought deploying from our laptops was efficient? When FTPing files directly to production at 2 AM felt like peak productivity? We’ve been here before. As AI transforms how we write code, we’re about to learn the same lesson all over again — but this time with much bigger bills.

It’s funny and relatively benign when AI orders 260 McNuggets; however, you may not be laughing when — pressured by overzealous leaders — a team burns through $10,000 in AI costs in a single afternoon. They were experimenting with agent fleets to automate their deployment pipeline. The agents worked beautifully — they just worked a little too enthusiastically, spawning sub-agents that spawned more sub-agents in an expensive game of digital telephone. 

I do expect to read more stories of AI costs gone wrong in 2025. It’s the same chaos we saw in the early days of cloud adoption, just with a different price tag.

The good news is that we have an approach — dare I say, a Lindy one — that has stood the test of time and will help guide us through this chaos.

The Myth Of Magical Productivity

Here’s the uncomfortable truth I’ve been sharing in my talks: AI will not be productive by default. We must deliberately extend DevOps principles to govern AI usage, infrastructure, and costs.

This isn’t pessimism — it’s pattern recognition. After spending years at companies like MassMutual, Nuance/Microsoft, and now as a founding engineer at CloudZero, I’ve seen this movie before. New technology arrives, promises to solve all our problems, and then creates an entirely new class of constraints we need to manage.

The difference this time? The velocity of change is staggering. We’re not just talking about code completion and chat interfaces anymore. We’re dealing with:

Each of these represents a fundamental shift in how we build, deploy, and maintain software systems. And each brings its own special flavor of chaos.

Enter The Theory Of Constraints (Again)

If you’ve read “The Goal” by Eliyahu Goldratt, you know that every system is limited by a small number of constraints. Remove one constraint, and another emerges. It’s like playing organizational whack-a-mole, except the moles are increasingly expensive.

I like to think of traditional software development as managing three primary constraints:

AI doesn’t eliminate these constraints. It transforms them into something more complex:

The Phoenix Rising (Again)

Gene Kim’s “The Phoenix Project” taught us the Three Ways of DevOps:

These principles didn’t become obsolete when containers arrived. They didn’t disappear when we moved to serverless. And they’re not going away just because AI can write code now.

What we’re witnessing is the birth of what I call “DevAIOps” — the deliberate application of DevOps principles to AI-augmented software development. It’s not about using AI to do DevOps (though that’s happening too). It’s about applying everything we’ve learned about managing complex systems to this new reality.

The Pattern Repeats

During my time at Nuance/Microsoft, I watched teams struggle with the transition from monolithic applications to microservices. The technology was revolutionary, but without proper systems in place, it created more problems than it solved. Teams ended up with:

Sound familiar? Replace “microservices” with “AI agents” and you’ve got 2025’s version of the same story.

What Good Looks Like

Here’s what efficient AI adoption actually looks like when it’s working:

In other words, it feels exactly like good DevOps. Because it is good DevOps, just evolved to handle new types of complexity.

The Path Forward

The good news? We don’t have to figure this out from scratch. The patterns, principles, and practices we’ve developed over the past decade of DevOps transformation provide a solid foundation. We just need to adapt them thoughtfully.

Over the next few posts in this series, I’ll dive deep into:

Because here’s the thing: AI is transformative. It will fundamentally change how we build software. But transformation without discipline is just expensive chaos. We’ve learned this lesson before. Let’s not learn it again the hard way.

The future isn’t about AI replacing DevOps. It’s about DevOps evolving to encompass AI. And that evolution starts with accepting a simple truth: AI won’t be productive by default.

And that’s OK. We’ve solved harder problems than this. We just need to approach it with the same systematic thinking that turned the chaos of early cloud adoption into the refined practices we have today.

After all, according to Ray Kurzweil, we still have a few more years until the singularity. Might as well build some good systems while we wait.

Author: Adam Tankanow

A founding engineer at CloudZero, Adam builds from first principles after years at Bose, Dolby, Nuance, and MassMutual. He has degrees from Tulane and Miami tucked away like old maps. His thoughts follow hard-won truths: memory fails but writing endures, old wisdom outlasts cleverness, understanding precedes implementation. When tangled, he walks among trees, knowing himself as learner and cultivator, connector and arranger – roles that chose him as he chose them.