AI has made writing code feel like cheating. The real trouble shows up right after git push. That is the part almost no one is talking about, and it is where most AI-assisted projects quietly die.

It is not usually the code that fails. It is everything around it, because the cloud is unforgiving.

Developers still run into the same problems they faced before large language models (LLMs) arrived. Environments drift apart. Permissions break in unpredictable ways. Networking works in staging but collapses under real traffic. Rollouts fail and rollbacks do not do what they claim. Monitoring and incident response get set up only after the first outage. These are not exotic issues, but ordinary headaches of shipping software, and they remain stubbornly hard even as code generation becomes trivial.

If we want AI-assisted development to actually scale, we have to confront the real bottlenecks. Everyone feels where the choke point is in the modern agentic software development life cycle, but we do not talk about it nearly enough. We have seen an explosion of coding agents, and many of them are genuinely impressive. But almost no one has tackled the crucial part that kills most AI-generated software: getting it running, safely, in the cloud.

This does not require LLMs to become flawless reasoners, because most platform engineering is not based on some deep logic. It is pattern matching, enforcing boundaries, and checking state. And unlike writing code, configuring infrastructure has fewer degrees of freedom. The space of valid actions is smaller, and the failure modes are well known. With structure, guardrails, and visibility into the real system, today’s models can already be more reliable here than in code generation.

The breakthrough is not better models. It is designing the right system around them.

The new imbalance

The shift happened fast. Developers used to spend weeks writing a new service. Now, a model can generate one in a matter of minutes. The limiting factor is no longer building features but running them.

Deployment is fundamentally different from coding. Writing code is a text problem. Deploying code is a state problem. To deploy safely, a system needs an accurate view of the resources that exist, the relationships between them, and their live configuration. It requires guardrails, reconciliation, and visibility into dependencies that change over time.

LLMs do not have any of that context. They do not know what is already deployed, which permissions are in place, or how different services interact. They operate inside a text box while the cloud is a living system. Asking a model to manipulate that system without giving it structure or guardrails is a recipe for breakage.

Because of this, deploying AI-generated code is actually harder than deploying human-written code. You are no longer dealing with a single developer who understands the system. You are dealing with a generator that outputs large amounts of code but has no understanding of the environment it is meant to run in.

What’s being overlooked

There is a popular narrative that cloud complexity only matters once a company becomes large. In reality, most small applications fail long before scale becomes an issue, and for reasons that have nothing to do with sophisticated infrastructure. The common failure points look almost embarrassingly simple.

Teams often ship:

• Services without proper retries or timeouts
• Functions that are not idempotent and explode on retry
• Migration scripts that fail on the second deploy
• Health checks that do not actually check anything
• Environment variables that differ across machines
• Staging and production resources that accidentally overlap
• Monitoring added only after something goes down
• Continuous integration (CI) pipelines that miss infrastructure regressions
• Rollbacks that do not recreate a working state

These are very common issues. And they’re the exact areas where AI doesn’t really help you yet. AI is great at generating code, but it has no intuition for the messy, boring parts that keep systems alive.

Because writing code is now so fast, teams often spin up more services than they can realistically look after. Not because they lack talent, but because the pace of generation doesn’t match the pace of operational discipline. 

The cloud is still a hostile environment for AI

Many people assume that LLMs should be able to automate infrastructure the same way they automate code. But cloud environments have almost none of the qualities that help code generation produce apps that run reliably. Programming languages have grammar, rules, and predictable outcomes. Cloud platforms are inconsistent, fragmented, and in constant motion.

A real-world system is rarely a single configuration language. It is Terraform combined with CLI commands, hand-edited YAML, a CI workflow written years ago, and a set of manual patches someone applied during an incident at 2 am. There is no single source of truth and no stable abstraction for the model to learn from.

LLMs are trained on historical snapshots. Cloud environments are living systems where the same command can behave differently depending on timing, region, service limits, or partial state. Without visibility and structure, AI agents will keep producing infrastructure that only looks valid on paper, yet fails when pushed to the cloud. 

The true bottleneck is now operational, not creative

The industry keeps waiting for a better model to arrive and solve everything. But the limiting factor is no longer the intelligence of the model. It is the environment we are asking that model to interact with.

Cloud infrastructure was designed for humans with deep knowledge, tribal context, and plenty of manual control. It was not built for agents that need clean structure, safety constraints, and predictable patterns.

If AI-assisted development is going to scale beyond prototypes, the underlying platform needs to adapt. What models need is not more IQ but better surroundings: environments where state is explicit, destructive actions are constrained, and configuration is represented as structured primitives instead of loosely related text files and scripts.

This is not simply a call for a single magical agent that behaves like an AI platform engineer. It is a call for a cloud that is compatible with AI. Without that shift, the gap between generation and deployment will keep widening.

When deployment stops being the bottleneck

Once the operational side catches up, the impact will be even larger than what we saw when LLMs first made coding accessible. People who were never able to build software will be able to not only assemble apps for demos but also ship them reliably. 

That is the real productivity curve AI has not unlocked yet. The coding part is already here. The operational part is where everything slows down. To make AI-assisted development work at scale, we need platforms that give models structure, visibility, and enforce safe boundaries. Once that happens, the cloud stops getting in the way and AI can finally deliver on the promise everyone keeps talking about.

—

New Tech Forum provides a venue for technology leaders—including vendors and other outside contributors—to explore and discuss emerging enterprise technology in unprecedented depth and breadth. The selection is subjective, based on our pick of the technologies we believe to be important and of greatest interest to InfoWorld readers. InfoWorld does not accept marketing collateral for publication and reserves the right to edit all contributed content. Send all inquiries to doug_dineley@foundryco.com.