senior-devops
by alirezarezvanisenior-devops helps scaffold DevOps artifacts with scripts for GitHub Actions or CircleCI pipelines, Terraform modules for AWS/GCP/Azure, and Kubernetes deployment runbooks. Use it as a reviewable starting point for Deployment automation, not production-ready infrastructure.
This skill scores 70/100, which means it is acceptable for directory listing but should be presented as a useful automation-oriented DevOps scaffold rather than a complete senior DevOps knowledge pack. Directory users get real scripts and clear task triggers, but should expect to review generated infrastructure/deployment output and not rely on the bundled references for deep guidance.
- Clear frontmatter description and Quick Start examples make the skill easy for an agent to trigger for CI/CD, Terraform scaffolding, Kubernetes deployment, rollback, and manifest analysis tasks.
- Includes three concrete Python scripts for pipeline generation, Terraform module scaffolding, and Kubernetes deployment/runbook generation, giving agents executable leverage beyond a generic DevOps prompt.
- Scripts show practical behavior such as runtime detection for Node/Python/Go, provider-specific Terraform modules for AWS/GCP/Azure, and blue-green or rolling deployment manifest generation.
- The three reference guides appear largely templated, with placeholder phrases such as "Pattern 1," "Tool 1," and generic TypeScript examples rather than DevOps-specific guidance.
- No install command or README is shown, so users must infer setup and dependencies for running the Python scripts.
Overview of senior-devops skill
What senior-devops is for
The senior-devops skill is a Claude skill for practical DevOps work: generating CI/CD pipelines, scaffolding Terraform modules, and producing Kubernetes deployment manifests and runbooks. It is best suited for engineers who already have an application repository and need a faster starting point for deployment automation rather than a purely conceptual DevOps explanation.
Best-fit users and Deployment jobs
Use senior-devops for Deployment work when you need repeatable artifacts: a GitHub Actions or CircleCI workflow, an AWS/GCP/Azure Terraform module skeleton, or a blue-green / rolling Kubernetes deployment plan. It is especially useful for teams standardizing early-stage infrastructure, migrating manual releases into pipelines, or creating reviewable deployment runbooks before touching production.
What makes this skill more than a prompt
Unlike a generic “write me a CI/CD pipeline” prompt, the senior-devops skill includes executable helper scripts. scripts/pipeline_generator.py detects Node, Python, Go, or generic projects and emits pipeline defaults. scripts/terraform_scaffolder.py creates provider-specific Terraform module files. scripts/deployment_manager.py writes Kubernetes manifests and ordered rollback/deploy runbooks without connecting to a cluster.
Important limitations before installing
The reference markdown files are broad and partly templated, so the highest-value content is in SKILL.md and the Python scripts. Treat generated output as scaffolding, not production-ready infrastructure. You still need to review secrets handling, cloud account boundaries, IAM, networking, environment promotion rules, observability, and compliance controls before merging or applying anything.
How to Use senior-devops skill
senior-devops install and repository path
Install from the source repository with:
npx skills add alirezarezvani/claude-skills --skill senior-devops
The skill lives at engineering-team/skills/senior-devops in alirezarezvani/claude-skills. After install, read SKILL.md first, then inspect scripts/pipeline_generator.py, scripts/terraform_scaffolder.py, and scripts/deployment_manager.py. The references/ folder can provide orientation, but verify details because those files contain generic placeholder-style guidance.
Inputs the skill needs for useful output
For strong senior-devops usage, provide concrete deployment context instead of asking for “a pipeline.” Include:
- repository runtime: Node, Python, Go, containerized, monorepo, or unknown
- CI platform: GitHub Actions or CircleCI
- required stages: build, test, security, deploy
- cloud target: AWS, GCP, or Azure
- deployment target: Kubernetes, ECS, GKE, AKS, or another platform
- environment names: dev, staging, production
- release strategy: rolling, blue-green, canary, manual approval
- constraints: private registry, secrets manager, compliance, downtime tolerance
A weak prompt is: “Set up DevOps for my app.”
A stronger prompt is: “Use senior-devops to create a GitHub Actions pipeline for a Python API with build, ruff, pytest, security scan, Docker image publish, and staging deploy. Target AWS ECS later, but only generate CI now. Explain which commands I must replace.”
Practical script-driven workflow
Start with the smallest artifact you can review safely. For a pipeline:
python scripts/pipeline_generator.py ./app --platform=github --stages=build,test,security,deploy
For Terraform scaffolding:
python scripts/terraform_scaffolder.py ./infra --provider=aws --module=ecs-service --verbose
For Kubernetes deployment planning:
python3 scripts/deployment_manager.py deploy --env=staging --image=app:1.2.3 --strategy=blue-green --verbose --json
The deployment manager is intentionally conservative: it generates manifests and runbooks, but does not talk to your cluster. That makes it useful for code review, change approval, and dry-run planning.
Prompt pattern that improves results
Ask the agent to use the skill, inspect generated files, and then adapt them to your repo:
“Use senior-devops as a starting point. Generate a GitHub Actions workflow for this repository, then explain every placeholder, risky default, and required secret. Do not assume production deployment. Prefer staging-only deployment with manual approval. If the script output is generic, improve it based on package.json, Dockerfile, and our existing .github/workflows conventions.”
This works better because it turns the skill from a one-shot generator into a review-and-adapt workflow.
senior-devops skill FAQ
Is senior-devops suitable for beginners?
Yes, if you want a guided starting point, but no if you expect it to replace DevOps judgment. Beginners can learn from the generated pipeline, Terraform layout, and runbook structure. However, applying cloud infrastructure or Kubernetes manifests without understanding permissions, state, networking, and rollback risk is unsafe.
How does senior-devops compare with ordinary AI prompts?
Ordinary prompts may produce plausible YAML, but they often miss project detection, file placement, and repeatability. The senior-devops skill has scripts that generate concrete files, including CI configuration, Terraform module skeletons, and deployment runbooks. Its advantage is operational structure; its weakness is that you must still customize generated defaults.
What ecosystems does it support?
The pipeline generator targets GitHub Actions and CircleCI, with runtime defaults for Node, Python, Go, and generic projects. The Terraform scaffolder supports AWS ECS service, GCP GKE deployment, and Azure AKS service module patterns. The deployment manager focuses on Kubernetes-style manifests, including rolling and blue-green deployment flows.
When should I not use this skill?
Do not use senior-devops as the final authority for production security, regulated infrastructure, complex multi-account cloud architecture, or mature platform engineering standards. If your organization already has strict internal modules, golden pipelines, or deployment controllers, use the skill for comparison and documentation drafts rather than direct generation.
How to Improve senior-devops skill
Give senior-devops real repo evidence
The fastest way to improve senior-devops output is to provide files that reveal how your system actually works: Dockerfile, docker-compose.yml, package.json, pyproject.toml, requirements.txt, go.mod, existing .github/workflows/, Terraform backend config, Helm charts, and Kubernetes manifests. These inputs reduce generic defaults and help the agent preserve existing conventions.
Check generated artifacts for risky defaults
Review generated pipelines for missing cache rules, broad deploy triggers, unpinned actions, absent secret names, weak test commands, and deployment steps that run on every push. Review Terraform for provider versions, backend assumptions, naming conventions, IAM scope, networking inputs, and environment separation. Review Kubernetes manifests for probes, resource limits, namespace strategy, image tags, and rollback behavior.
Iterate from scaffold to production plan
After the first output, ask for a gap review instead of immediately asking for more files. Example: “Compare this generated workflow against our production requirements: manual approval before prod, image signing, SAST, SBOM, environment-specific secrets, and rollback. List exact edits before rewriting the YAML.” This keeps the workflow decision-led rather than generator-led.
Strengthen the skill itself over time
If you maintain a local copy, improve the senior-devops skill by replacing placeholder reference material with real deployment decision tables, adding examples for Helm and cloud registries, documenting supported script arguments, and adding tests for generated YAML/Terraform. The most valuable additions are not more buzzwords; they are safer defaults, clearer constraints, and examples that match real deployment paths.