DEV Community

Cover image for Cloud & Platform Engineering Skills: Production-Grade Skills for AI Coding Agents
Manideep Chittineni
Manideep Chittineni

Posted on

Cloud & Platform Engineering Skills: Production-Grade Skills for AI Coding Agents

AI coding agents are becoming increasingly capable.

They can write Terraform, generate Kubernetes manifests, create CI/CD pipelines, troubleshoot infrastructure, review IAM policies and even help investigate production incidents.

But there is a fundamental challenge:

Writing infrastructure code is not the same as engineering production infrastructure.

A production-grade cloud platform requires architectural reasoning, security controls, operational experience, reliability engineering, cost awareness and an understanding of the trade-offs behind every decision.

That is the problem I wanted to explore with my latest open-source project:

☁️ Cloud & Platform Engineering Skills

GitHub: https://github.com/mchittineni/cloud-platform-skills

The project is an open-source library of production-oriented engineering skills for AI coding agents, covering Cloud, Platform Engineering, DevOps, SRE, Security and FinOps.

The current repository contains 43 production-grade skills, with an evaluation framework, compliance gates and generated integrations for multiple AI agent runtimes. (⁠https://github.com/mchittineni/cloud-platform-skills)

Why another skills library?

AI agents can already access enormous amounts of documentation.

The problem isn’t necessarily a lack of information.

The problem is knowing which information to use, when to use it, and how to apply it safely.

Consider a request such as:

“Design a highly available EKS platform for multiple teams.”

A useful engineering response shouldn’t simply generate some Terraform.

It needs to consider things such as:

  • Cluster architecture
  • Multi-AZ design
  • Pod networking
  • Node scaling
  • Workload isolation
  • IAM
  • Secrets
  • Network boundaries
  • Observability
  • Upgrade strategy
  • Disaster recovery
  • Cost
  • Security
  • Operational ownership

The same applies to:

“Why is our Kubernetes deployment failing?”

or:

“Our AWS bill suddenly increased.”

or:

“How should we implement an SLO for this API?”

These are engineering problems, not merely coding problems.

That’s why the project treats a skill as more than a prompt.

What is a skill?

Each skill contains several layers of engineering knowledge.

A typical skill includes:

**1. Routing triggers

  1. When-to-use guidance
  2. Route-elsewhere guidance
  3. Production-shaped implementation examples
  4. Engineering reasoning
  5. Architecture trade-offs
  6. Best practices
  7. Anti-patterns
  8. References
  9. Evaluation cases**

The goal is to help an AI agent answer not only:

“How do I do this?”

but also:

“Should I use this approach?”

and:

“What could go wrong in production?”

🧠 Progressive disclosure

One of the core design principles is progressive disclosure.

The agent shouldn’t load every skill into its context.

Instead, the intended workflow is:

User request
     │
     ▼
Skill index
     │
     ▼
Identify matching skill
     │
     ▼
Read "When to Use"
     │
     ▼
Load the selected skill
     │
     ▼
Load deeper references only when needed
Enter fullscreen mode Exit fullscreen mode

The repository explicitly recommends reading the index, selecting a matching skill and avoiding bulk-loading the entire library. (⁠https://github.com/mchittineni/cloud-platform-skills)

This matters because loading dozens of unrelated engineering skills into an agent’s context can reduce rather than improve the quality of reasoning.

☁️ Cloud Engineering

The project covers AWS, Azure and Google Cloud.

Examples include:

AWS

  • EKS enterprise patterns
  • IAM and Zero Trust policies
  • Cloud migration strategies
  • High availability and scalability

Azure

  • AKS enterprise landing zones
  • Azure cloud engineering patterns
  • Enterprise network and governance patterns

GCP

  • GCP cloud engineering patterns
  • GKE multi-tenancy
  • Resource hierarchy
  • Workload identity and external CI authentication

These skills are designed around real engineering scenarios rather than simply listing cloud service commands.

For example, the AWS IAM skill is intended for situations such as reviewing overly permissive policies, designing multi-account guardrails or replacing AdministratorAccess with appropriately scoped access. (⁠https://github.com/mchittineni/cloud-platform-skills)

🏗️ Platform Engineering

Platform engineering is another major part of the project.

The library includes skills around:

  • Internal Developer Portals
  • Backstage
  • Golden paths
  • Cloud-native microservices
  • API Gateway
  • Service Mesh
  • Serverless architectures
  • Event-driven systems

For example, the Internal Developer Portal skill is designed around scenarios such as enabling developers to create production-ready services through self-service workflows and measuring platform adoption. (⁠https://github.com/mchittineni/cloud-platform-skills)

This is particularly useful for organisations building internal platforms where the goal isn’t just to provision infrastructure, but to create a consistent developer experience.

⚙️ DevOps

The DevOps section covers the operational foundations needed to build and run modern platforms.

Some examples include:

  • CI/CD pipeline design
  • Terraform modules
  • Terragrunt governance
  • Kubernetes
  • Helm
  • GitOps
  • Docker
  • Configuration management
  • Performance and load testing
  • Zero-downtime releases
  • Backup and disaster recovery
  • DORA metrics

For example, the CI/CD skill isn’t simply about creating a pipeline.

It covers scenarios such as removing long-lived cloud credentials from CI, improving slow pipelines and designing build-test-deploy workflows. (⁠https://github.com/mchittineni/cloud-platform-skills)

🔐 DevSecOps and Security

AI agents operating against cloud infrastructure create an important security consideration.

These aren’t just documents being read by humans.

They are instructions that an agent may execute with credentials.

That changes the threat model.

A poorly designed instruction could potentially encourage:

  • Credential exposure
  • Destructive commands
  • Confirmation bypass
  • Security-control bypass
  • Concealment from operators

The project therefore includes dedicated security skills covering areas such as:

  • AI agent security
  • CSPM
  • IAM
  • Secrets management
  • Policy-as-Code
  • SAST/SCA
  • Supply-chain security
  • Container runtime security
  • Detection engineering
  • Security incident triage

The repository explicitly treats malicious or careless agent instructions as a major part of its threat model. (⁠https://github.com/mchittineni/cloud-platform-skills)

📊 SRE and Observability

Production systems also need reliability engineering.

The library includes skills for:

  • SLI/SLO design
  • Error budgets
  • Prometheus
  • Grafana
  • OpenTelemetry
  • Infrastructure monitoring
  • Incident management
  • Postmortems
  • Chaos engineering
  • Resilience testing

This means an agent can be guided toward engineering concepts such as:

Service
   ↓
SLIs
   ↓
SLO
   ↓
Error Budget
   ↓
Release / Reliability Decision
Enter fullscreen mode Exit fullscreen mode

rather than simply producing another monitoring dashboard.

💰 FinOps

Cloud engineering isn’t complete without cost engineering.

The project includes a FinOps skill covering the Inform → Optimise → Operate lifecycle.

It can be used for scenarios such as:

  • Unexpected cloud-bill increases
  • Commitment decisions
  • Shared-cost allocation
  • Cloud cost optimisation

This is important because architecture decisions have financial consequences.

A technically elegant architecture that is economically unsustainable isn’t necessarily a good production architecture.

🧪 The important part: evaluation

One of the biggest goals of the project was to avoid simply creating Markdown files and calling them “production ready.”

So the skills are evaluated.

The repository currently contains 190 routing evaluation cases, covering both:

Should this skill trigger?

and:

Should this skill not trigger?

The current repository reports at least 95% routing pass rate, with two documented near-ties between sibling security skills rather than hiding those edge cases through overly broad keyword matching. (⁠https://github.com/mchittineni/cloud-platform-skills)

This distinction is important.

Imagine an agent receives:

“A Kubernetes workload needs to access AWS resources.”

There are multiple potentially relevant concepts:

  • Kubernetes
  • IAM
  • Secrets
  • Workload identity
  • Cloud security

The goal isn’t to trigger every related skill.

The goal is to route the request to the most appropriate engineering knowledge.

🔒 Compliance gates

The project also uses deterministic compliance checks.

The repository currently reports:

  • 43 POWERFUL-tier skills
  • 95 average compliance score
  • 0 compliance blockers
  • 0 workflow security blockers

The compliance inspection covers areas such as:

  • Destructive commands
  • Credential leaks
  • Description accuracy
  • Script safety
  • Frontmatter validity
  • Reference resolution
  • Line budgets
  • Evaluation completeness

These checks run offline and don’t require an LLM or API key. (⁠https://github.com/mchittineni/cloud-platform-skills)

The repository also includes workflow security auditing and supply-chain controls for its own GitHub Actions. (⁠https://github.com/mchittineni/cloud-platform-skills)

🔄 One source of truth

Another architectural decision was to avoid manually maintaining different versions of the same skill for every AI tool.

The authoritative source is:

skills/
Enter fullscreen mode Exit fullscreen mode

Runtime-specific integrations are generated from that source.

The repository currently supports integrations for environments including:

  • Claude Code
  • Google Antigravity / Gemini CLI
  • OpenAI Codex CLI
  • Cursor
  • GitHub Copilot

The repository contains generated runtime entry points and instructions for installing the skills into these environments. (⁠https://github.com/mchittineni/cloud-platform-skills)

The sync process can regenerate the runtime targets with:

python3 scripts/sync-all.py
Enter fullscreen mode Exit fullscreen mode

This makes the architecture:

              skills/
                │
        ┌───────┼────────┐
        │       │        │
        ▼       ▼        ▼
     Claude   Cursor   Copilot
        │       │        │
        └───────┼────────┘
                ▼
          Agent Runtime
Enter fullscreen mode Exit fullscreen mode

One source of truth.

Multiple agent runtimes.

🛠️ Using the repository

The simplest approach is to clone the repository:

git clone https://github.com/mchittineni/cloud-platform-skills.git
cd cloud-platform-skills
Enter fullscreen mode Exit fullscreen mode

Then inspect the skill index:

ls skills
Enter fullscreen mode Exit fullscreen mode

For Claude Code, the repository supports automatic discovery through .claude/skills/.

For Codex, AGENTS.md provides the routing table.

For Cursor, the repository provides generated Cursor rules.

For GitHub Copilot, it provides generated Copilot instructions.

For Gemini/Antigravity, there is a dedicated installation script.

The project documentation contains the runtime-specific installation and verification instructions. (⁠https://github.com/mchittineni/cloud-platform-skills)

🧩 What a skill looks like

The repository follows a consistent skill anatomy.

skills/
└── domain/
    └── skill-name/
        ├── SKILL.md
        ├── evals/
        │   └── evals.json
        ├── references/
        ├── scripts/
        └── assets/
Enter fullscreen mode Exit fullscreen mode

The SKILL.md contains the routing information and core engineering guidance.

Deeper material lives under references/ and is loaded only when necessary.

Evaluation cases live alongside the skill.

This makes each skill relatively self-contained and independently testable. (⁠https://github.com/mchittineni/cloud-platform-skills)

👨‍💻 Humans can use these skills too

Although the project is designed for AI coding agents, the content is also useful for engineers.

The skills can act as:

  • Engineering runbooks
  • Architecture Decision Records
  • Standard Operating Procedures
  • Troubleshooting guides
  • Platform engineering references
  • Cloud architecture references
  • Interview preparation material

For example, an engineer troubleshooting an EKS cluster can read the EKS skill directly without using an AI agent.

The agent is simply another consumer of the same engineering knowledge.

Why I think this matters

We’re moving from AI assistants that answer questions to AI agents that can perform engineering work.

That changes the requirements.

An agent working on production infrastructure needs more than syntax.

It needs:

Technical knowledge
       +
Engineering reasoning
       +
Production patterns
       +
Security guardrails
       +
Operational awareness
       +
Correct routing
Enter fullscreen mode Exit fullscreen mode

That’s the direction I wanted to explore with this project.

The goal isn’t to replace experienced engineers.

It’s to give AI agents a better engineering foundation so that experienced engineers can spend more time on architecture, decisions, review and higher-value work.

📚 This project builds on my earlier work

If you are interested in the broader AI + DevOps + Cloud Engineering ecosystem, this project is also part of a series of open-source resources I’ve been building.

🤖 Ultimate AI Engineering Guide

If you missed my earlier post about the Ultimate AI Engineering Guide, I’d recommend checking it out.

It focuses on AI Engineering concepts and provides a structured resource for learning and interview preparation.

👉 Read the earlier LinkedIn post:
https://www.linkedin.com/posts/manideepchittineni_github-mchittineniultimate-ai-engineering-guide-activity-7492872832176091136-1I0g

☁️ Ultimate DevOps Guide

I also previously shared the Ultimate DevOps Guide, covering DevOps fundamentals, Cloud Computing and related engineering topics.

If you missed that post, you can read it here:

👉 Read the earlier LinkedIn post:
https://www.linkedin.com/posts/manideepchittineni_github-mchittineniultimate-devops-guide-activity-7491439038969581568-LEAu

These projects complement each other:

        AI Engineering
                │
                ▼
      Ultimate AI Engineering
                │
                ▼
          DevOps / Cloud
                │
                ▼
        Ultimate DevOps Guide
                │
                ▼
      Cloud & Platform Skills
                │
                ▼
         AI Coding Agents

The latest project focuses on bringing those engineering practices directly into AI-agent workflows.

🚀 What’s next?

There is plenty of room to expand the project.

Some areas I’m interested in exploring include:

  • More AWS, Azure and GCP skills
  • More Kubernetes patterns
  • Advanced platform engineering
  • Additional security skills
  • More FinOps scenarios
  • More routing evaluations
  • Deeper agent-security controls
  • Additional agent runtimes
  • Automated skill quality benchmarking
  • More production troubleshooting scenarios

The architecture is intentionally designed so that new skills can be added without changing the underlying runtime integrations.

⭐ Try it yourself

If you’re working with:

  • Cloud platforms
  • Kubernetes
  • Terraform
  • DevOps
  • Platform Engineering
  • DevSecOps
  • SRE
  • FinOps
  • AI coding agents

I’d encourage you to take a look.

👉 GitHub Repository

https://github.com/mchittineni/cloud-platform-skills

If you find it useful:

⭐ Star the repository
🐛 Open an issue
💡 Suggest a skill
🔧 Contribute an improvement
📢 Share it with your engineering team

The project is open source and MIT licensed. (⁠GitHub)

Final thoughts

AI agents are becoming increasingly capable of writing infrastructure.

The next challenge isn’t simply:

“Can AI generate Terraform?”

It’s:

“Can AI make good production engineering decisions while generating Terraform?”

That’s a much harder problem.

And I believe the answer requires combining AI agents with structured engineering knowledge, explicit routing, production patterns, evaluation and security guardrails.

Cloud & Platform Engineering Skills is my attempt to build that foundation as an open-source project.

If you’re experimenting with AI agents in Cloud, DevOps, Platform Engineering or SRE, I’d love to hear what you’re building and which skills you think should be added next.

⭐ GitHub: https://github.com/mchittineni/cloud-platform-skills

Tags: #ai #devops #cloud #platformengineering #kubernetes #terraform #devsecops #sre #aiengineering #opensource #github #cicd #aws #azure #gcp

Top comments (0)