Skip to content
PodSubs
ShowsPeopleGuestsJobsNewsEvents
More
BlogPodCred
Menu
ShowsPeopleGuestsJobsNewsEventsBlogPodCredNetworksSign in
Join nowSign in
  • Shows
  • People
  • Jobs
  • News
  • More
    • Guests
    • Events
    • Blog
    • PodCred
    • Networks
    Join nowSign in

DevOps Academy Podcast

DevOps Academy Podcast artwork

DevOps Academy Deep Dive S1E18: AI Is Making Developers Faster — Is Infrastructure Becoming the New Bottleneck?

Oct 19, 202623 minAudioSeason 1, Episode 18
ShareXLinkedInFacebookWhatsAppEmail

AI coding assistants are helping developers write code, generate tests, and build applications faster than ever. But is the rest of the software delivery process keeping up? In this episode of DevOps Academy Deep Dive, we explore how AI-assisted development is shifting engineering bottlenecks from writing code to infrastructure provisioning, CI/CD pipelines, security reviews, testing, and production operations. We discuss why faster code generation doesn't automatically mean faster software delivery, how AI-generated infrastructure can introduce new complexity, and why platform engineering, self-service capabilities, and automation are becoming increasingly important. 🔑 Key Takeaways Why faster coding doesn't always mean faster software delivery How AI shifts bottlenecks into infrastructure, CI/CD, and security The growing gap between AI-generated code and human review capacity Why AI-generated infrastructure requires architectural oversight How platform engineering and golden paths can reduce friction Why self-service infrastructure matters more in AI-assisted development How increased development speed affects testing and deployment pipelines The hidden maintenance costs of rapidly generated software Why engineering teams should measure end-to-end delivery performance How DevOps teams can identify and eliminate the next bottleneck 🎧 Tune in to discover why the biggest challenge in AI-assisted development may no longer be writing code, but building engineering systems that can keep up. 💬 Is AI making your engineering team faster, or simply moving the bottleneck somewhere else?

Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.

Transcript

From the show. Tap a time to play from there.

You know how a city suddenly decides to upgrade a local highway? Like they take this congested, really frustrating two -lane road and spend years paving this glorious ten -lane superhighway? Oh yeah, and it costs a fortune. Right, exactly. And the day it finally opens, you're flying along at top speed, the wind is in your hair, and you're thinking, wow, this is the future. We finally solved the commute. Until you reach your exit. Yes. You hit the off -ramp. and it is still just a single winding dirt road with like a blinking

stop sign at the very end. Just a massive parking lot. Exactly. Suddenly all those shiny new lanes just mean you've built a bigger parking lot. You didn't actually solve the traffic problem, you just changed where the traffic jam happens. Yeah, you just moved the bottleneck. Right. And whether you are a developer, an engineering leader, or just someone insanely curious about how the technology you use every day is actually built behind the scenes, you are probably feeling this exact traffic jam right now. We are doing a deep dive today into the great AI bottleneck. It's a huge issue right now. It really is. We are

looking at this massive, completely unexpected paradox happening in the tech world. Basically, AI is making developers write code faster than ever before in human history. But it is actually slowing down overall engineering delivery. OK, let's unpack this. Yeah. That highway analogy perfectly captures what we call a bottleneck shift. Because I mean, for the last two decades, organizations have been absolutely desperate for faster coding. It was the holy grail. Right. Everybody just wanted to type faster. Exactly. They invested heavily in better development environments.

They built massive reusable code libraries. You know, they bought into every automation tool imaginable. And now, thanks to large language models and AI coding assistance, they finally achieved the dream. The 10 lane highway. Right. Developers can generate complex logic, unit tests, and documentation at unprecedented speeds. But what these engineering teams are discovering is a very painful truth. Software delivery is not just code generation. Yeah. Coding has accelerated to breakneck speeds, but everything downstream,

I mean the infrastructure provisioning, the security audits, the compliance checks, the manual testing, all of that has remained at the exact same speed. So the off -ramp is still a dirt road. Precisely. The arrival rate of work at the off -ramp has absolutely skyrocketed, but the capacity of the delivery system to process that work hasn't changed one bit. That dynamic, it really reminds me of a manufacturing plant. Like, let's say you have an assembly line. If station one produces 100 widgets an hour and you bring in an AI tool that

suddenly speeds it up to 200 widgets an hour, the executives are gonna pop champagne, right? Like, productivity is up. On paper, yeah. Right. They're thrilled. Right. But if Station 2, the very next step on the line that has to actually package those widgets, can still only process 40 units an hour, you haven't actually doubled your factory's production. No, none at all. You have just created a massive, chaotic, incredibly expensive queue of unfinished widgets piled up on the factory floor. It makes me wonder, are organizations just hallucinating their own productivity

gains by only looking at the volume of code being written? Honestly, yes. Measuring productivity purely by lines of code produced or the number of pull requests submitted is incredibly misleading right now. Because the AI is doing all the typing. Exactly. AI makes those specific metrics look spectacular. But your end users, your customers, they don't receive lines of code. They don't care how many pull requests you merged. They receive working software. Right. And what we are seeing is a fundamental disruption in cost

dynamics. You see, historically, writing the very first version of a feature was the hardest part. It required intense cognitive effort, days of typing, and that natural human friction inherently limited how much software an organization could actually produce. It was a natural speed limit. Right. But we are now in an era where AI makes the initial creation cost incredibly cheap. You can ask an assistant to build a social sharing widget, and you'll have the code in 20 minutes.

Which is mind -blowing. It is, but while the creation cost has plummeted, the lifecycle cost of that code has vastly increased. Because every single piece of new code needs a physical or, well, at least a virtual place to live and breathe. Let's trace the actual lifespan of a feature to see where the time actually goes. Because this is where it gets crazy. Okay, let's do it. Say an AI helps the developer write a new user login module in one day instead of three. On paper, they save two days. Awesome. But that

login module still needs an isolated test environment. Provisioning that environment takes a day. The module requires specific cloud resources, maybe a new database. That requires filing an IT ticket, which just sits in a queue for 48 hours. Ugh, the classic IT ticket black hole. You know it. Then the security team needs to manually review and approve the new database permissions. That's another ticket. The automated testing pipeline takes 40 minutes to run. The final deployment requires a manual sign -off from a release manager

who is, of course, currently in back -to -back meetings. Naturally. So those two days the developer saved on coding, they are completely swallowed up by the downstream realities of the delivery system. Wow. And the friction doesn't stop once the feature is finally pushed to production, right? There are these incredibly daunting long -term questions that emerge when creation is this cheap. Oh, absolutely. Like, who owns that login module in six months when the original developer moves to a different team? Or who is responsible for updating its underlying dependencies

when a zero -day vulnerability is discovered next year? That's a huge one. Right. And who is keeping an eye on the cloud bill for the servers running it? And perhaps the most critical question of all, who takes the time to safely remove it when nobody needs it anymore? Generating the initial code doesn't answer a single one of those questions. No, it doesn't. And what's fascinating here is how this dynamic places an unbearable amount of pressure, specifically on infrastructure. OK, how so? Well, infrastructure operates under very different physical and financial constraints

than simple application code. Today, a developer can just ask their AI. It created a terraform configuration for this new microservice. And for anyone not deep in the weeds. Terraform is a tool for infrastructure as code, right? Like a blueprint written in plain text that tells your cloud provider what servers to build. That's exactly it. And the AI spits out that blueprint in seconds. But applying that configuration creates real, physical resources. It spins up actual databases. It alters network routing. It establishes

public -facing web endpoints. It writes IAM permissions. Actually, I should probably jump in and clarify. IAM for a second, that's identity and access management, which is essentially the digital bouncer for your software. It decides which users and which services are actually allowed to talk to each other, right? That's a perfect description. The digital bouncer. And getting past the bouncer safely requires precision. Individually, a generated network configuration, an auto -scaling policy

to handle web traffic, and those IAM permissions might look entirely fine in isolation. Sure, on their own they make sense. Wait, the AI writes them flawlessly according to generic best practices. But when you combine all of those isolated generated files into a single production environment, who actually understands the complete system? Oh wow, that is a terrifying thought. It's like having a skyscraper built by a hundred different specialized contractors who never once looked at a master blueprint. Yes. Like one crew built

a staircase, another crew built a hallway, and suddenly you have a door that opens up into a completely empty elevator shaft. Exactly. We refer to this phenomenon as the understanding gap. You see, the limiting factor in engineering used to be how fast humans could manually type out the configuration files, usually YAML files, which are just plain text lists of instructions dictating how the infrastructure behaves. Right. Lots of indentations to mess up. Right. But now the AI generates thousands of lines of YAML at machine speed. So the new limiting factor isn't

typing, it's whether human engineers can actually comprehend the infrastructure being proposed before they hit the deploy button. Which makes me want to push back a bit on how we even define a successful deployment right now. Okay. If a developer uses an AI assistant to spin up a complex new testing environment and says, hey, I clicked around, it works. Is it works actually a dangerously weak quality standard in this new era? Oh, completely. Functional correctness is only one single dimension of software quality, and relying on it alone

is highly dangerous. Right. Infrastructure can work perfectly well for the developer testing it, while simultaneously being wildly over -provisioned, meaning the AI just requested the most powerful, expensive servers available, costing the company thousands of dollars a month unnecessarily. Just to run a test environment. Exactly. Or it can work and still be fundamentally insecure. Perhaps because the AI took the path of least resistance and granted wild card permissions, effectively telling that digital bouncer to just let everybody into the database. Yikes. It can work and be

entirely non -compliant with European privacy regulations. Or it can be so fragile and complex that it is completely impossible for the operations team to debug when it inevitably crashes at 2 in the morning. So we are looking at a massive difference between generated architecture and designed architecture. Yes. Architecture traditionally involves intentional reasoned decisions. Why did we choose a relational database over a NoSQL database for this specific problem? Why do we build this specific network topology? Why do we choose this exact level of redundancy in case

of a failure? You're actually thinking about the future. Right. But when a team relies solely on AI -generated infrastructure, it bypasses all that critical reasoning. If the team simply accepts whatever functions in the moment, they end up with a technically valid infrastructure that possesses zero architectural rationale. It's a house of cards. Here's where it gets really interesting though. If developers themselves can't fully understand the infrastructure they are generating, this has to create an absolute nightmare for the security and review teams downstream.

I mean, look at the sheer math asymmetry here. It's brutal. Right. An AI can generate 500 lines of highly complex network configuration code in like three seconds. A human security reviewer cannot responsibly comprehend 500 lines of complex network configuration in three seconds. Not a chance. So we are rapidly entering a world where writing code is abundant, but understanding code is incredibly scarce. That asymmetry creates a devastating cascade through the entire delivery pipeline, especially in what we call CI -CD.

continuous integration, and continuous deployment. And for anyone unfamiliar, CICD is basically the automated conveyor belt of the software world, right? Exactly. When a developer finishes code, they put it on this conveyor belt, which automatically runs tests, checks for bugs, and packages it up for delivery. And DevSecOps is the practice of building security checks directly into that conveyor belt. Got it. Now, imagine your developers are using AI to triple the amount of code they submit to the belt. It's going to back up. Completely. Your security team suddenly receives three times

as many third party dependencies to evaluate. They have three times as many external APIs to secure. You cannot respond to a 300 % increase in machine generated code by simply asking your human security team to work 300 % faster. It just doesn't scale. And the automated conveyor belt itself must start buckling under the weight too. Oh, it absolutely chokes. The automated test suites have to execute much more frequently. The build queues pile up. Artifact storage where the packaged code is actually kept grows exponentially. And that takes up server space. Which is not

free. Running this conveyor belt requires cloud -based virtual machines called runners. Runners cost money by the minute. Ouch. So the deep irony of AI -assisted development is that an engineer might use AI to save 10 minutes of typing out a function only to sit around checking their watch for 45 minutes waiting for a CI runner to become available because the entire testing system is backed up. Wow. And in that 45 minutes, they lose their flow state, they switch context to look at something else, and the initial 10 minutes they saved is completely wiped out. Let

me challenge that bottleneck, though. Sure. If the core problem is that AI is generating code much too fast for human reviewers and traditional pipelines to handle, why not just fight fire with fire? What do you mean? Why not have an AI review the AI -generated code? Like, you just set up a secondary agent to read the first agent's work, and boom, you get your speed back. I hear that all the time. It is a very tempting proposition. And to be fair, AI can be incredibly helpful in the review process for spotting basic syntax

errors, identifying missing unit tests, or flagging known vulnerabilities. Right. The simple stuff. But relying entirely on one AI system to validate another AI system introduces a massive risk of false confidence. Really? How so? Well, let's say the generating AI writes a database query that technically works, but misses a crucial pagination step. OK. If that query hits production, it might try to load 10 million user records into memory all at once and crash the server.

A human reviewer with institutional knowledge might catch that immediately because they know how big the user base is. Right, they know the context. Exactly. But the reviewing AI, lacking the broader architectural context of how the company's users scale, might just rubber stamp it because it aligns with its own algorithmic logic. It looks at the code and says, yep, that's a valid query. Oh, man. So you have just automated the rapid deployment of a critical vulnerability. Precisely. The goal of a review pipeline is not maximum speed or maximum test volume. The goal

is fast confidence. You need genuine assurance that a change is safe enough to progress to the user. And fast confidence requires reliable, underlying systems and human judgment. Not just two chatbots agreeing with each other. OK. So if manual human reviews can't scale to meet this new volume, and having AI review AI introduces dangerous false confidence, how can organizations possibly survive this? Because doing nothing just means drowning in the traffic jam. This is where the concept of platform engineering becomes the absolute most critical piece of the

puzzle for the AI era. But it requires organizations to fundamentally shift from a request -driven platform model to a capability -driven platform model. OK, let me try to translate that. So a request -driven platform team is basically just an IT help desk. Basically, yeah. Like, I'm a developer, I submit a ticket that says, hey, I need a database, and I wait a week for someone to build it. And if AI doubles my output, I double the tickets I submit, and the help desk just drowns. Exactly. It's totally unsustainable. So is a capability -driven team basically building

an internal app store, like a vending machine where developers can just self -serve exactly what they need? A vending machine is a brilliant way to visualize it, yes. A capability -driven platform team builds scalable, self -service systems for the rest of the engineers. They define the boundaries, the guardrails, within which developers can move as fast as they want, safely. We refer to these pre -approved routes as golden paths. Golden paths, I like that. Walk me through exactly how a golden path operates in the real

world. Let's go back to that database example. Sure. So imagine a developer needs a new Postgres database for a future. In a chaotic non -platform environment, they turn to their AI assistant and ask it to generate the infrastructure code from scratch. Right. The AI uses its general internet knowledge to guess at the networking rules, the backup frequency, the server size, the security policies. Now, a human has to manually review all of those random generated decisions. And we already established that humans do not

have the time to read a wall of AI -generated YAML files anymore. Exactly. But in a mature organization, the platform team has already built a golden path, a fully automated approved self -service capability, your vending machine. Nice. The developer just pushes a button and inputs three simple variables, the name of the database, the expected amount of traffic, and whether it's for testing your production. That's it. That's all they have to do. Yep. The platform handles literally everything else according to strict pre -written organizational standards. The data

encryption is automatically configured to comply with company policy. Daily backups are silently enabled. Observability tools, the monitors that alert the team if the database goes down, are instantly attached. Cost tracking tags are applied so the finance department knows exactly which team is spending what. Oh, I see. Yeah. So the developer's AI assistant isn't just out there in the Wild West inventing random unvetted architecture based on whatever it's scraped from the internet. Precisely the opposite. A smart organization actually trains their internal AI assistants

on these golden paths. So instead of generating generic configuration files, the AI acts as an intelligent guide, helping the developer navigate the company's specific internal ecosystem. That is so smart. Right. If a developer asks for something weird, the AI can say, actually, our proof pattern for this is X. Let me trigger that for you. It knows which deployment strategies are supported, which cloud regions are legally allowed for user data, and what the security baselines are. It accelerates the work, but it does it entirely

inside the constraints. So what does this all mean for the actual culture of engineering moving forward? Because it sounds to me like we are transitioning from a historical mindset of scarcity, where building things was hard and rare, to a mindset of absolute overwhelming abundance. Absolutely. And when creation becomes this easy, I honestly think the most critical engineering skill of the next decade might simply be the ability to say, no. Like actively pausing to ask whether we actually need to build another microservice or if we're just doing it because the AI makes

it feel free. If we connect this to the bigger picture, you've pinpointed the exact cultural shift that has to happen. When creation becomes practically free, restraint becomes your most valuable asset. Restraint. Yeah. Yeah. Reusing an existing well -tested service is almost always vastly superior to generating a brand new one just because your AI can whip it up in 20 minutes. Because that 20 -minute generation event creates five years of maintenance responsibility. You know, it's exactly like adopting a puppy. Oh,

how so? Getting the puppy is incredibly easy and fun. It takes an hour. You just pick it up. But feeding it? Walking it at 5 a .m. in the rain, paying for the vet bills and taking care of it for the next 15 years, that is the real cost of the decision. That is a perfect analogy. The true cost is the life cycle, not the adoption. And this is fundamentally why AI doesn't invalidate old school DevOps principles. It stress tests them to their absolute limits. DevOps has always

been about automation, fast feedback loops. making small incremental changes, and breaking down the silos between teams. If an organization relies heavily on tribal knowledge, like, oh, don't touch the routing configuration. Only Dave knows how the load balancer works. We all know a Dave. We do. But AI will brutally expose that setup. If Dave has to manually approve every change and developers are suddenly submitting 10 times as many changes thanks to AI, Dave isn't just a bottleneck anymore. Dave is a complete systemic

blockage. You cannot operate at machine speed if human manual approval is required at every single junction. So if you are an engineering leader listening to this, you shouldn't just be signing checks for more AI coding tools to make your developers type faster. You really have to look at the entire delivery system holistically. You need to follow the work. Take a real feature your team built recently and track its entire journey from the initial idea all the way to running and production. And critically, you need to separate the active work time from the waiting

time. Right, active versus waiting. Because you might investigate a ticket and find that it took four days to resolve, but it only required five minutes of actual active keyboard time. The other 95 hours were just the ticket sitting in a queue waiting for a manual sign -off. You have to identify and automate the actual constraints in your system, not just optimize the coding part that is already blazing fast. So to synthesize all this for you listening today. AI isn't necessarily creating this infrastructure bottleneck out of thin air.

It is merely exposing the massive inefficiencies, the fragile manual processes, and the tribal knowledge that our historically slower coding speeds used to cover up. The real goal of adopting all of this incredible technology isn't just faster coding. The goal is the faster, safer delivery of value to the user. And that would be my most urgent takeaway for anyone navigating this transition right now. Stop asking your engineering managers, how much faster are our developers

with AI? It is the wrong metric. Start asking, where did the bottleneck move? Where did the bottleneck move? Exactly. Because the moment the coding constraint disappears, another constraint immediately becomes visible downstream. Finding, understanding, and aggressively removing that next constraint is the true operational challenge of this new era. It's a brilliant way to frame the problem, and it leaves me with one final thought to mull over, specifically around this idea of the DevOps learning loop and the incredibly high cost of maintaining all this generated code.

If the ultimate goal of an engineering team is faster iteration and faster learning, and the biggest danger of AI is cheap creation leading to massive operational bloat, perhaps the true competitive advantage of the future won't belong to the teams with the absolute best AI coding agents. Interesting. It will belong to the teams who deploy AI as a highly specialized decommissioning agent. Like imagine a tool designed specifically to play garbage collector. An AI that just hunts down forgotten cloud infrastructure, untangles

obsolete code and safely deletes it. Oh, that would be incredible. Right. In a world where every single company is obsessed with generating more, the ultimate superpower might just be automated subtraction. because otherwise you're just speeding down that glorious 10 -lane AI superhighway only to find yourself trapped on the dirt road off -ramp, drowning in a traffic jam you paid to create yourself. Thank you so much for joining us on this deep dive. Catch you next time.

Open the transcript file

Hosts and Guests

Nobody is credited on this episode yet.

Credit the people on this episode

Be the first to rate this episode

More episodes

All episodes
  1. DevOps Academy S1E22: Platform Engineering 2.0 — Are Internal Developer Platforms Becoming AI Platforms?

    Nov 16, 202628 minAudio

    Internal Developer Platforms were built to simplify software development. But as engineering teams begin building AI-powered applications, are traditional developer platforms ready for what comes next? From integrating...

    Credit the people on this episode

  2. DevOps Academy S1E21: Shadow AI Is Becoming the New Shadow IT — Do You Know What Agents Are Running in Your Organization?

    Nov 9, 202623 minAudio

    Your engineering team may be using more AI tools than you realize. But do you know which ones have access to your code, credentials, and production systems? From AI coding assistants and locally running models to...

    Credit the people on this episode

  3. DevOps Academy S1E20: MCP in Production — Are AI Agents Creating a New Infrastructure Security Boundary?

    Nov 2, 202622 minAudio

    AI agents are moving beyond generating answers. They're connecting to real infrastructure, accessing internal systems, and interacting with production environments. But who controls what they're allowed to do? The Model...

    Credit the people on this episode

  4. DevOps Academy Deep Dive S1E19: AI Workloads Fail Differently — Is Traditional SRE Enough for Production AI?

    Oct 26, 202623 minAudio

    What happens when your AI application is running perfectly, but its answers are wrong? Traditional Site Reliability Engineering focuses on availability, latency, error rates, and infrastructure performance. But...

    Credit the people on this episode

  5. DevOps Academy Deep Dive S1E16: eBPF and the Future of Observability — Can We Monitor Systems Without Instrumenting Everything?

    Sep 29, 202620 minAudio

    Modern engineering teams collect more telemetry than ever, yet getting meaningful visibility into production can still require extensive application instrumentation. In this episode of DevOps Academy Deep Dive, we...

    Credit the people on this episode