5-Minute DevOps: AI is Taking Our Jobs!! Pt. 3

In , I wrote about my experience developing with AI using no handwritten code and the skills required to get good outcomes. The short version: the same rigor required for continuous integration is required for AI-assisted development. Working with agents will expose weaknesses in that rigor faster than ever. GIGO, only accelerated.

Some claim AI is only useful for greenfield projects or proofs of concept. They're wrong. I use these tools daily for new features, refactoring, improving legacy code, writing tests, debugging, and more. With the right skills and development discipline, AI lets you deliver solutions faster. But does this actually improve organizational outcomes? For most companies, I doubt it.

In my youth, I saw a stand-up routine about cocaine

I said to a guy, "Tell me, what is it about cocaine that makes it so wonderful," and he said, "Because it intensifies your personality." I said, "Yes, but what if you're an a**hole?"

AI development is like that. If you lack discipline, AI will amplify that. You'll see hallucinations, unexpected changes, mounting tech debt, and rising defect rates. Before long, you'll be on social media declaring AI useless, blaming the tool instead of your practices.

However, if you have discipline — clear testable requirements, test-driven development, small batches, and tight feedback loops — AI amplifies those practices. You deliver faster, with less effort, and focus more on solving problems rather than wrestling with implementation.

Speed of Development ≠ Speed to Value

Software delivery is a system. Coding is just one part. A typical flow looks like this:

• A product owner throws features with unclear or incomplete acceptance criteria over the wall to a development team.
• The team breaks down these large chunks of work into "stories" that are still weeks of effort.
• Developers code the stories but frequently need to stop and ask for more clarity on the change, or use their best judgment and play "is this the rock you wanted?" with the product owner. Changesets are large and merges are infrequent because the cost of change is high.
• Because the original requirements were unclear, the developers could not drive development using tests. Testing becomes an activity that occurs, if at all, after development is complete, often conducted by a separate testing team with differing opinions on how the feature should function.
• Before deploying, a Change Advisory Board that meets weekly insists on reviewing all of the documentation that "proves" everything was done correctly and that there is a valid plan for reversing the change if things go too sideways.
• Ops is terrified of deployments because every deployment is large and risky, and always results in excessive support, regardless of what the CAB documentation says.

This isn't hyperbole. I've measured this across multiple teams. It's a common experience that others have reported too. When you map the process, coding is only a fraction of the overall flow. Adding AI to write code faster doesn't fix the real bottlenecks. It just creates waste faster.

Faster Coding Without Faster Feedback Is Dangerous

Industry conversations obsess over "developer productivity," as if faster coding equals progress. But speed without feedback is just digging the hole deeper.

AI can generate code, but it can't validate whether it solves the right problem. It doesn't fix vague requirements, broken testing practices, or heavyweight governance. Without upstream clarity and downstream automation, faster coding leads to more defects, more rework, and more outages per delivery.

We've seen this before. Organizations chased deployment frequency because Accelerate said high performers ship more often. But deployment frequency was a signal of healthy flow, not the goal. Shipping faster without guardrails isn't progress; it's chaos.

The Whole Value Stream Has to Improve

Real speed comes from improving the entire value stream:

• Upstream: Clear problem statements, smaller work items, collaborative product teams.
• Development: Teamwork, single-piece flow, test-first practices, and continuous integration.
• Downstream: Automated, deterministic pipelines, no manual approvals disguised as "governance," and rapid recovery when things break.

That's what Continuous Delivery is about — not developers typing faster, but value moving faster, safer, and with less risk. AI doesn't change that truth.

Fix the Right Problems

Here's the uncomfortable reality: developer productivity doesn't matter in isolation. The bottleneck in most organizations isn't how long it takes to write code — it's everything else.

AI is an amplifier. If your delivery system is healthy, AI makes it better. If it's broken, AI makes it worse.

Map your value stream. Find the real constraints. Fix those. Only then will faster coding translate to faster delivery of value.

The choice is yours.