Ops Engineering Skills

The open-source Agent Skills library for the entire enterprise engineering stack. DevOps, DevSecOps, Cloud, Kubernetes, CI/CD, GitOps, security scanning, SRE, compliance, databases, messaging, service mesh, serverless, internal developer platforms, MLOps, and AgentOps — written once to the open Agent Skills standard and usable natively in Claude Code, Claude.ai, GitHub Copilot, OpenAI Codex, Cursor, Gemini CLI, and any other agent that implements the spec.

If you've ever wished your AI coding agent gave you production-grade, opinionated guidance on a Kubernetes rollout, an IAM policy, a Terraform migration, an MCP server, or a model-serving setup — instead of a paragraph of generic textbook advice — that's exactly what this repository is for.

Why this exists

Most AI-agent guidance today falls into one of two traps:

1. Too generic — a paragraph of platitudes about "following best practices" that could apply to any tool, which is another way of saying it applies usefully to none of them.
2. Locked to one vendor — real depth, but packaged in a proprietary plugin format that only works in one product, so the same knowledge gets re-written from scratch for every agent a team happens to use.

This repository is built to avoid both traps:

1. Real operational depth. Every skill includes prerequisites, exact steps, best practices, concrete pitfalls (each with a symptom and a fix), and a fully worked example — not a restatement of the topic's Wikipedia page.
2. Genuinely portable. Skills are packaged to the open SKILL.md standard, natively supported today by Claude Code, GitHub Copilot, OpenAI Codex, Cursor, and Gemini CLI. Build the skill once; every one of those agents can use it as-is, with no translation layer.
3. Deliberately not everything. This library stays inside an "ops engineering" scope on purpose — it does not try to also be a general software-development, data-analytics, technical-writing, or business-automation skill pack, so the name on the repo matches what's actually inside it.

See it in action

Every skill follows the same shape: a machine-checkable frontmatter block an agent uses to decide relevance, followed by eight required sections that force real depth instead of restated documentation. Here's an excerpt from pod-crashloop-and-oom-troubleshooting:

---
name: pod-crashloop-and-oom-troubleshooting
description: >
  Guides diagnosing `CrashLoopBackOff` pods (using `kubectl logs --previous`,
  `kubectl describe pod`, and exit-code interpretation to find the real root
  cause) and `OOMKilled` terminations specifically (distinguishing an
  undersized memory limit from a genuine application memory leak using
  events, `kubectl top`, and limits vs. observed usage). Use when a user
  asks "why is my pod CrashLoopBackOff," "what does OOMKilled mean," "my pod
  keeps restarting," "exit code 137," or "should I just raise the memory
  limit to stop the crashes."
license: Apache-2.0
compatibility: "Claude Code, GitHub Copilot, OpenAI Codex, Cursor, Gemini CLI"
metadata:
  domain: kubernetes-platform
  maturity: stable
---

That description field is doing real work — it's written so an agent with zero other context can correctly decide "yes, this is the skill for this question" purely from the trigger phrases inside it. The body that follows walks through the actual diagnostic sequence (why CrashLoopBackOff is a symptom, not a cause; how to tell a memory leak from an undersized limit; the single most common mistake — reflexively raising the memory limit without checking whether the real problem is a leak) with real kubectl commands at every step. No filler.

What's covered

296 skills across 22 domains:

See the full list of all 296 individual skills, each with its own one-line description and direct link, in docs/SKILLS_INDEX.md.

How skills are authored

Two design decisions run through the entire library and are worth understanding before you use or contribute to it:

1. Generic concept skills stay separate from tool-specific skills, and cross-reference instead of duplicating. For example, sast-integration (in DevSecOps) covers the concept of static analysis — what it catches, where it fits in a pipeline, why it's not sufficient alone. Separate skills like sonarqube-code-quality-and-security and fortify-static-analysis cover the specific tool's mechanics in depth and link back to the concept skill rather than re-explaining "what is SAST" from scratch. This means an agent gets exactly the right altitude for the question — conceptual when someone's deciding whether to adopt a practice, tool-specific when they've already decided and need to actually configure something.

2. Every skill follows the same 8-section shape, enforced by an automated validator (scripts/validate_skills.py) on every change:

Full detail lives in spec/authoring-guide.md — read it before contributing a skill.

Installation

Four ways to install, in order of convenience. All four give you the exact same skill content — pick whichever fits your agent and workflow. Options 1 and 2 are verified end-to-end against this live repository: marketplace add

• plugin install, and npx skills add + a real skill install, both confirmed working with no separate publishing step required.

Option 1: Claude Code Marketplace (Recommended)

Native to Claude Code — gives you version tracking and one-command updates.

/plugin marketplace add selvarajmurugesan90/ops-engineering-skills

Then install only the plugins you need (each is independent):

/plugin install devops-skills@ops-engineering-skills
/plugin install devsecops-skills@ops-engineering-skills
/plugin install cloud-skills@ops-engineering-skills
/plugin install kubernetes-platform-skills@ops-engineering-skills
/plugin install cicd-tooling-skills@ops-engineering-skills
/plugin install gitops-argo-skills@ops-engineering-skills
/plugin install policy-governance-skills@ops-engineering-skills
/plugin install iac-automation-skills@ops-engineering-skills
/plugin install security-tooling-skills@ops-engineering-skills
/plugin install enterprise-collaboration-skills@ops-engineering-skills
/plugin install platform-extras-skills@ops-engineering-skills
/plugin install standards-compliance-skills@ops-engineering-skills
/plugin install sre-skills@ops-engineering-skills
/plugin install ai-agent-skills@ops-engineering-skills
/plugin install mlops-skills@ops-engineering-skills
/plugin install database-operations-skills@ops-engineering-skills
/plugin install data-messaging-skills@ops-engineering-skills
/plugin install service-mesh-gateway-skills@ops-engineering-skills
/plugin install serverless-compute-skills@ops-engineering-skills
/plugin install idp-skills@ops-engineering-skills
/plugin install itsm-tooling-skills@ops-engineering-skills
/plugin install role-based-practices-skills@ops-engineering-skills

Or install everything at once by adding all 22 plugin names above in sequence. Update later with /plugin marketplace update + /plugin update <plugin>@ops-engineering-skills. Uninstall with /plugin uninstall <plugin>@ops-engineering-skills.

Option 2: npx skills

Works with the community skills CLI, a generic installer for any Agent-Skills-standard repository — no Claude Code required, works for any compliant agent.

# Preview every skill in the repository before installing anything
npx skills add selvarajmurugesan90/ops-engineering-skills --list

# Install a single skill for a specific agent, no prompts
npx skills add selvarajmurugesan90/ops-engineering-skills \
  --skill pod-crashloop-and-oom-troubleshooting --agent claude-code -y

# Install every skill across all 296, for all supported agents
npx skills add selvarajmurugesan90/ops-engineering-skills --all

This resolves the same plugins/<domain>/skills/ folders as the other methods and installs them straight into your agent's local skills directory (e.g. .claude/skills/, .agents/skills/) — no --target needed, and no publishing step beyond this repository being public on GitHub.

Option 3: install.sh (the repo's own cross-agent installer)

Use this for OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, or any agent that reads SKILL.md files directly from a folder — no package manager involved, just a shell script.

git clone https://github.com/selvarajmurugesan90/ops-engineering-skills.git
cd ops-engineering-skills

# Install every domain
./installers/install.sh --plugin all --target .codex/skills          # OpenAI Codex
./installers/install.sh --plugin all --target .github/skills         # GitHub Copilot
./installers/install.sh --plugin all --target .claude/skills         # Claude Code (manual, no marketplace)

# Or install just one domain
./installers/install.sh --plugin devsecops --target .github/skills
./installers/install.sh --plugin database-operations --target .codex/skills

# Symlink instead of copy (useful while developing/customizing skills locally)
./installers/install.sh --plugin cloud --target .github/skills --symlink

Run ./installers/install.sh --help for the full flag reference. Valid --plugin values are the 22 domain folder names under plugins/ (see Repository structure below) or all.

Option 4: Clone and copy manually

No installer at all — works with literally any agent or tooling, including ones that don't yet have first-class Agent Skills support.

git clone https://github.com/selvarajmurugesan90/ops-engineering-skills.git

# Copy an entire domain
cp -r ops-engineering-skills/plugins/cloud/skills/* <your-agent-skills-dir>/

# Or copy a single skill
cp -r ops-engineering-skills/plugins/kubernetes-platform/skills/helm-chart-authoring <your-agent-skills-dir>/

Any directory containing a SKILL.md is a complete, self-contained skill — copy exactly the ones you want, nothing else is required.

Using a skill once installed

Skills activate automatically based on what you ask your agent — there's no special syntax to invoke them. Just describe what you need, in plain language, and the agent matches your request against every installed skill's description field:

"Why is my pod stuck in CrashLoopBackOff?"
→ activates kubernetes-platform's pod-crashloop-and-oom-troubleshooting

"Set up a Jenkins pipeline that other repos can reuse"
→ activates cicd-tooling's jenkins-centralized-shared-library

"I need to triage a security finding backlog before our audit"
→ activates devsecops's security-finding-backlog-triage

"Design a rollback strategy for a bad model deployment"
→ activates mlops's production-model-rollback-procedure

"Compare GitNexus, Graphify, and CodeGraph for my coding agent"
→ activates ai-agent's code-knowledge-graph-tools-for-ai-agents

"Deploy a complete IDP on AWS from scratch"
→ activates internal-developer-platform's complete-idp-deployment-on-aws-from-scratch

If a skill doesn't activate when you expect it to, check its description field in docs/SKILLS_INDEX.md — descriptions are written for exactly this kind of trigger-phrase matching, and a mismatch usually means the phrasing needs to be more concrete (see spec/authoring-guide.md if you want to improve one via a contribution).

Repository structure

ops-engineering-skills/
├── .claude-plugin/marketplace.json      # Claude Code marketplace catalog (22 plugins)
├── AGENTS.md                            # repo-level guidance for any agent
├── plugins/
│   ├── devops/skills/<skill>/SKILL.md
│   ├── devsecops/skills/<skill>/SKILL.md
│   ├── cloud/skills/<skill>/SKILL.md                       # incl. OCI, on-prem
│   ├── kubernetes-platform/skills/<skill>/SKILL.md
│   ├── cicd-tooling/skills/<skill>/SKILL.md                # Jenkins, Bamboo, GHA, GitLab, Azure Pipelines, CodePipeline, Gitea
│   ├── gitops-argo-ecosystem/skills/<skill>/SKILL.md
│   ├── policy-and-governance-tooling/skills/<skill>/SKILL.md
│   ├── iac-and-automation-tooling/skills/<skill>/SKILL.md
│   ├── security-scanning-tooling/skills/<skill>/SKILL.md
│   ├── enterprise-collaboration/skills/<skill>/SKILL.md    # Jira, Confluence
│   ├── observability-and-platform-extras/skills/<skill>/SKILL.md
│   ├── standards-and-compliance-frameworks/skills/<skill>/SKILL.md
│   ├── site-reliability-engineering/skills/<skill>/SKILL.md
│   ├── ai-agent/skills/<skill>/SKILL.md
│   ├── mlops/skills/<skill>/SKILL.md
│   ├── database-operations/skills/<skill>/SKILL.md         # PostgreSQL, MySQL, MongoDB, Redis, ClickHouse...
│   ├── messaging-and-data-orchestration/skills/<skill>/SKILL.md   # Kafka, RabbitMQ, Temporal, Airflow
│   ├── service-mesh-and-api-gateway/skills/<skill>/SKILL.md       # Linkerd, Consul, Cilium, Kong
│   ├── serverless-and-alternative-compute/skills/<skill>/SKILL.md # Lambda, Functions, Knative, Dapr, Nomad
│   ├── internal-developer-platform/skills/<skill>/SKILL.md        # Backstage, Humanitec, golden paths
│   ├── incident-tooling-and-itsm/skills/<skill>/SKILL.md          # PagerDuty, ServiceNow, ChatOps, Linear
│   └── role-based-engineering-practices/skills/<skill>/SKILL.md   # runbook exec, design review, roadmap, ADRs
├── template/skill-template/SKILL.md     # starting point for new skills
├── spec/authoring-guide.md              # required frontmatter + sections
├── scripts/validate_skills.py           # schema/lint validator
├── installers/install.sh                # cross-agent installer (all 22 domains)
└── docs/
    ├── SKILLS_INDEX.md                  # full list of all 296 skills
    ├── VALIDATION_REPORT.md             # latest full validation run
    └── SEO_CHECKLIST.md                 # repo metadata/discoverability checklist

Validation & quality bar

Every skill in this repository passes the same automated checks before it's considered complete:

• Schema validation (scripts/validate_skills.py) — frontmatter correctness, kebab-case naming (≤64 chars), description length (1–1024 chars), metadata.domain matching the actual folder, all 8 required sections present and in order, duplicate-name detection across all 296 skills, and a hardcoded-secret pattern scan.
• Cross-reference integrity — every relative link inside every skill's "Cross-references" section is checked to resolve to a real file. Zero broken links across the entire repository, including the deep cross-domain chains inside the "complete deployment from scratch" integration skills.
• claude plugin validate — the marketplace manifest and all 22 individual plugin manifests validate cleanly against the Claude Code plugin schema.
• Installer verification — installers/install.sh is tested against --plugin all and every individual domain, confirmed to place the correct file count into a target directory.
• Destructive-action review — every destructive or irreversible command that appears anywhere in the repository (terraform destroy, kubectl delete namespace, force-push, a chaos experiment in production, an etcd restore, TRUNCATE/DROP KEYSPACE, a ChatOps-triggered runbook action, and dozens more) is explicitly flagged with a warning and a safer alternative — never presented as a safe default.

Full results, including the complete per-domain skill count table, are in docs/VALIDATION_REPORT.md — re-generate it with the same two commands before every release:

python3 scripts/validate_skills.py
claude plugin validate .

Roadmap

• Live install-and-invoke smoke testing across GitHub Copilot, OpenAI Codex, Cursor, and Gemini CLI (currently verified via claude plugin validate and the installer's file-placement correctness, not a live agent session in each product).
• Community contributions for domains not yet covered — see open new-skill-proposal issues for what's already been requested.
• Ongoing subject-matter-expert review passes on the highest-traffic skills, prioritized by which domains see the most installs/usage.

Have a domain or tool you think is missing? Open a new-skill-proposal issue — see Contributing.

FAQ

Is this affiliated with Anthropic? No. This is an independent, community-built repository that implements the open Agent Skills standard Anthropic published and donated to the Agentic AI Foundation. It is not an official Anthropic product.

Does it actually work with Copilot / Codex / Cursor / Gemini CLI, or just Claude Code? The skill content (every SKILL.md) is 100% agent-agnostic — it's plain Markdown with YAML frontmatter, no Claude-specific syntax anywhere. Claude Code additionally gets a native marketplace/plugin experience (/plugin install ...) because that's a first-party feature of that product; other agents use install.sh, npx skills, or a manual copy to get the identical files.

Can I use this commercially? Yes — the entire repository is Apache-2.0 licensed. Use, modify, and redistribute freely, including commercially, with attribution. (Note: one skill, code-knowledge-graph-tools-for-ai-agents, describes a third-party tool — GitNexus — that itself has a non-commercial license for its own free tier; that restriction applies to GitNexus, not to this repository or the skill describing it.)

Do I have to install all 296 skills? No — every plugin (domain) installs independently. Install only the domains relevant to your stack; there's no dependency between them.

How do I know a skill's guidance is current? Check its maturity field (stable or draft) and the version caveats inside its "Prerequisites & environment" section — skills are written to cite defensible version ranges rather than a single pinned version, since most of this tooling moves fast.

Something's wrong or outdated in a skill — what do I do? Open a bug-report issue (template provided) or send a PR directly; see Contributing.

Contributing

Contributions that add real operational depth are the most valuable kind. See CONTRIBUTING.md for the skill-authoring guide and review checklist, and spec/authoring-guide.md for the exact format every skill must follow.

Security

See SECURITY.md to report a skill that recommends an unsafe practice or a vulnerability in bundled tooling.

License

Apache License 2.0 — see LICENSE. Free to use, modify, and redistribute, including commercially, with attribution.

Keywords: Claude Code skills, GitHub Copilot skills, OpenAI Codex skills, Cursor skills, Agent Skills standard, DevOps skills, DevSecOps skills, Cloud engineering skills, AWS/Azure/GCP/OCI skills, Kubernetes skills, Helm, Kustomize, Istio, KEDA, EKS/AKS/GKE/OKE, OpenShift/ROSA, Flux CD, Crossplane, Rook/Ceph, Jenkins pipeline, Bamboo Specs, GitHub Actions reusable workflows, GitLab CI/CD, Azure Pipelines, ArgoCD, Argo Rollouts, Argo Workflows, GitOps, OPA Gatekeeper, Kyverno, Fairwinds Polaris, Terraform, Terragrunt, CloudFormation, Ansible, Trivy, Snyk, Checkov, tfsec, OWASP ZAP, SonarQube, Prisma Cloud, Fortify, Sysdig Secure, Sealed Secrets, External Secrets Operator, Vault PKI, SPIFFE SPIRE, Falco, SRE skills, SLO error budget, incident response, postmortem, chaos engineering, CIS Benchmarks, Well-Architected Framework, SOC2 ISO 27001 PCI-DSS NIST CSF, OWASP Top 10, Jira best practices, Confluence documentation, ServiceNow ITSM, PagerDuty Opsgenie, Linear, PostgreSQL, MySQL MariaDB, MongoDB, Redis, ClickHouse, Cassandra, Neo4j, ArangoDB, TimescaleDB, Liquibase, Kafka, RabbitMQ, Temporal, Airflow, Linkerd, Consul, Cilium, Kong API gateway, AWS Lambda, Azure Functions, Knative, Dapr, Backstage, Humanitec, internal developer platform, AI agent engineering, AgentOps, MCP server development, LangChain LangGraph, CrewAI AutoGen, code knowledge graph, RAG vector database, MLOps skills, MLflow, Weights and Biases, Kubeflow, Ray, LLMOps, open source skill marketplace, enterprise DevOps standards.