AI Needs Structure: Why Promises Unlock AI-Powered Platform Engineering

The adoption of AI is accelerating across every corner of software development. From writing emails to generating code, AI has quietly become embedded in daily workflows, including those of platform engineers. The question isn’t if AI will shape platform engineering, but how.  

Can GenAI solve the platform engineer’s biggest pains? Can it accelerate platform delivery, improve developer experience, and make infrastructure more secure and efficient? The short answer is yes, but only if your platform is designed to provide AI with a solid foundation to work with. The missing ingredient is structure.

AI pains in platform building

AI adoption is broad, but an associated transformation is rare. MIT’s Project NANDA reports that “over 80 percent of organisations have explored or piloted [GenAI] and nearly 40 percent report deployment,” yet for enterprise-grade systems, “only 5 percent reached production.”  

Why does the relatively high level of AI usage when coding feel like the exception? Because the AI has a strict contract and structure to work with. The compiler or interpreter is the arbiter. SDKs define clear, reusable patterns that enable safe and repeatable work.

Platform building rarely has that structure. Teams prompt AI to scaffold Terraform, Helm, and pipelines. Initially, it feels fast. But then the cracks appear. For example, teams often encounter:

• Drift by default. Each prompt produces slightly different naming and shapes. Environments diverge. Every service becomes a snowflake.

• Low trust. Outputs look plausible until they meet real workloads and edge cases. Without a strong validation layer, review becomes the bottleneck.

• Hidden coupling. Generated scripts and manifests interact in surprising ways. One change breaks three pipelines.

• Maintenance trap. AI can create a hundred pipelines in a night. It does not explain intent or how they should evolve together.

• Governance gaps. Security and policy sit outside the generation path. Exceptions multiply.

AI performs best with a clear contract with predictable lifecycles. Give it ambiguity and it flounders. To use AI effectively in platform engineering, the platform must define the contract and the lifecycle rules that AI can target.

Turning platform principles into practice (for our Robot friends)

Kratix is a platform framework that gives your platform the same clarity and structure a compiler gives code. It defines how services should be described and managed, providing an API and lifecycle rules that make platform behaviour predictable and consistent.

With Kratix, you separate the contract from the implementation. Kratix offers:

• Clear contracts for platform services. A Promise defines an API as a Kubernetes CRD with types, defaults, and validation. Inputs are explicit. Error states are explicit. Drift is detectable.

• Structured lifecycles. Workflows are containerised steps for create, update, reconcile, and delete. Each has a clear input and output. You can test them like any other code.

• Codified governance. Implement policy checks, security scans, and approvals within the workflows so they execute on every change, not just during reviews.

• Good developer experience with the Kratix SDK and CLI. Scaffold new workflows in minutes. Use helpers to read request data, current status, and emit results.

This structure makes AI useful instead of risky. An agent can propose a change to a Promise, and rely on Kubernetes to validate the API while your pipelines validate the behavior. If your proposed change passes the validation steps, it is safe to merge. If it fails, the errors are concrete and actionable.

Here is what the contract looks like in practice, captured in a single YAML Promise:

For anyone familiar with Kubernetes, this will feel natural. The `Promise` is just another Custom Resource Definition (CRD). It follows the same conventions, `metadata`, `spec`, `status`, and defines the contract for “anything as a service.”  

That contract is simple for humans to reason about, and crucially, easy for AI to generate and modify. For example, you might ask an AI agent to “add a new API key, update the default value, and append a new container to the workflow.” The agent can generate the change, then validate it instantly using Kubernetes itself as the compiler:

Because Kubernetes enforces structural contracts, AI can safely and confidently modify your platform configuration.

Beyond the contract: Structured workflows for platform services

Of course, when building platforms, the YAML is only half the story. The real work happens in the workflow containers. Each container encapsulates a step in the lifecycle, such as generating Terraform, running a security scan, or updating a database.  

Each container has its own input/output contract, and because it’s just code, you can use any language. This design enables teams to develop business logic in small, testable, and reusable units.

Kratix makes this easier with the CLI and SDK. The CLI scaffolds new workflows, while the SDK provides built-in helpers to do actions such as discovering user inputs from a request and accessing the current status of a resource.

This structure not only enhances human productivity but also amplifies the effectiveness of AI. When logic is modular and well-defined, AI can operate confidently within each boundary. Instead of writing a massive provisioning script, it can focus on generating a single, simple container.

For example, take the security scan step that runs a Snyk scan on an image. With Kratix’s clear structure and SDK, the entire workflow can be generated from a single prompt that describes its purpose and expected inputs. The AI doesn’t guess, it fills in a structured contract.

Summary

AI has already changed how we write code, but without the structure we see in programming languages and associated ecosystems, it will struggle to change how we build platforms. The result will be all too familiar: fractured YAML, one-off pipelines, and systems that are impossible to evolve safely.

Promises offer a different path. By defining platform capabilities through typed contracts and lifecycle workflows, Kratix provides AI with the same guardrails and clarity that compilers and SDKs offer in application development. With those boundaries in place, AI can help teams build, extend, and operate platform services confidently, without spraying ungoverned configuration into production.

The takeaway: AI isn’t a force multiplier for your platform. Structure is. Kratix gives you both, with clean contracts and flexible workflows, so your platform can grow safely, collaboratively, and fast. 

Try the Kratix quick start and see how Promises let you bring AI into platform engineering on your terms.