swe-cli-skills

Senior engineer CLI expertise for AI agents — workflows, safety guardrails, gotchas, and anti-patterns across cloud, IaC, containers, databases, dev tools, and platforms

12 stars
Complexity: easy

About this skill

The `swe-cli-skills` skill enhances AI agents with deep, practical knowledge for command-line interface (CLI) tools commonly used in software engineering. Unlike standard reference documentation, this skill encapsulates "senior engineer judgment," offering operational workflows, critical safety guardrails, common pitfalls ("gotchas"), effective error recovery strategies, and robust patterns for composing multiple CLIs. It covers a broad spectrum of domains including major cloud platforms (AWS, GCP, Azure), Infrastructure as Code (Terraform), and containerization (Docker, kubectl), among others. An AI agent should load this skill when facing complex CLI operations that involve multi-step sequences, piped commands, or intricate flag configurations. It's particularly useful when an agent needs to ensure operational safety, understand non-interactive command alternatives, debug CLI errors with actual fixes rather than generic advice, or orchestrate sophisticated interactions between various tools (e.g., piping `aws` output to `jq` for parsing, then processing with `xargs`). By leveraging this skill, AI agents can perform CLI tasks with a significantly higher degree of accuracy, safety, and efficiency, effectively mimicking the practical expertise of an experienced software engineer. It moves beyond rote command execution, enabling the agent to anticipate issues, implement best practices, and recover gracefully from errors, thereby substantially improving the reliability and quality of automated development and operations tasks.

Best use case

swe-cli-skills is best used when you need a repeatable devops & infrastructure workflow instead of a one-off prompt. It is especially useful for teams working in multi. Empower your AI agent with senior engineer CLI expertise, covering complex workflows, safety guardrails, common pitfalls, and anti-patterns across cloud, IaC, containers, databases, and development tools.

Senior engineer CLI expertise for AI agents — workflows, safety guardrails, gotchas, and anti-patterns across cloud, IaC, containers, databases, dev tools, and platforms

Users should expect a more consistent devops & infrastructure output, faster repeated execution, and less time spent rewriting prompts from scratch.

Practical example

Example input

Use the "swe-cli-skills" skill to help with this devops & infrastructure task. Context: Empower your AI agent with senior engineer CLI expertise, covering complex workflows, safety guardrails, common pitfalls, and anti-patterns across cloud, IaC, containers, databases, and development tools.

Example output

A structured devops & infrastructure result with clearer steps, more consistent formatting, and an output that is easier to reuse in the next run.

When to use this skill

  • Use this skill when you want a reusable workflow rather than writing the same prompt again and again.
  • Use it when you are solving a devops & infrastructure task and want a more structured operating flow.
  • Use it when you want something quick to test with a low setup cost.

When not to use this skill

  • Do not use this when you only need a one-off answer and do not need a reusable workflow.
  • Do not use it if you cannot install or maintain the related files, repository context, or supporting tools.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/swe-cli-skills/SKILL.md --create-dirs "https://raw.githubusercontent.com/SylphAI-Inc/skills/main/skills/swe-cli-skills/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/swe-cli-skills/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How swe-cli-skills Compares

Feature / Agentswe-cli-skillsStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityeasyN/A

Frequently Asked Questions

What does this skill do?

Senior engineer CLI expertise for AI agents — workflows, safety guardrails, gotchas, and anti-patterns across cloud, IaC, containers, databases, dev tools, and platforms

How difficult is it to install?

The installation complexity is rated as easy. You can find the installation instructions above.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

Related Guides

SKILL.md Source

# SWE CLI Skills

> man pages for machines — Your agent knows the commands. We teach it the workflows.

This skill provides expert-level CLI knowledge for the tools software engineers use daily. Each guide encodes **senior engineer judgment** — not reference docs, but operational workflows, safety guardrails, flag gotchas, error recovery, and composition patterns.

## When to Use This Skill

Load a specific CLI guide when:
- You need to run complex CLI operations (multi-step workflows, piped commands)
- You're unsure about flag ordering, safety checks, or non-interactive alternatives
- You encounter a CLI error and need the actual fix (not generic advice)
- You need to compose multiple CLIs together (e.g., aws → jq → xargs)

## Available CLI Guides

Guides are organized by category. Read the category index or jump directly to a CLI guide.

### ☁️ Cloud (`skills/cloud/`)

| CLI | File | Use For |
|-----|------|---------|
| **AWS CLI** | `skills/cloud/aws.md` | S3 filter ordering, IAM auth, EC2 queries, JMESPath, Lambda |
| **gcloud** | `skills/cloud/gcloud.md` | GCP project/config management, GKE, Cloud Run, IAM, logging |
| **Azure CLI** | `skills/cloud/azure.md` | Resource groups, AKS, App Service, RBAC, ARM deployments |

### 🏗️ Infrastructure as Code (`skills/iac/`)

| CLI | File | Use For |
|-----|------|---------|
| **Terraform** | `skills/iac/terraform.md` | State management, import workflows, safe apply, workspace migration |

### 🐳 Containers & Orchestration (`skills/containers/`)

| CLI | File | Use For |
|-----|------|---------|
| **Docker** | `skills/containers/docker.md` | Build cache, multi-stage builds, compose v2, cleanup, debugging |
| **kubectl** | `skills/containers/kubectl.md` | Context safety, namespace gotchas, rollout/rollback, pod debugging |
| **Helm** | `skills/containers/helm.md` | Values precedence, upgrade resets, rollback, chart debugging |

### 🔀 Git & Version Control (`skills/git-vcs/`)

| CLI | File | Use For |
|-----|------|---------|
| **Git** | `skills/git-vcs/git.md` | Non-interactive alternatives, rebase, merge, conflict resolution |
| **GitHub CLI** | `skills/git-vcs/gh.md` | PR workflows, issue management, releases, Actions |

### 🛠️ Dev Tools (`skills/dev-tools/`)

| CLI | File | Use For |
|-----|------|---------|
| **jq** | `skills/dev-tools/jq.md` | JSON filtering, select vs map, array ops, shell variable injection |
| **sed** | `skills/dev-tools/sed.md` | Stream editing, in-place substitution, macOS vs Linux portability |
| **make** | `skills/dev-tools/make.md` | Build automation, Makefile patterns, phony targets, variables |
| **curl** | `skills/dev-tools/curl.md` | Auth headers, multipart uploads, API debugging, response handling |
| **SSH/SCP** | `skills/dev-tools/ssh.md` | Tunneling, ProxyJump, key management, agent-safe patterns |

### 📦 Package Managers (`skills/package-managers/`)

| CLI | File | Use For |
|-----|------|---------|
| **npm** | `skills/package-managers/npm.md` | Dependency management, scripts, workspaces, publishing, lockfiles |
| **pip & uv** | `skills/package-managers/pip-uv.md` | Virtual envs, dependency resolution, uv acceleration, constraints |

### 🗄️ Databases (`skills/databases/`)

| CLI | File | Use For |
|-----|------|---------|
| **psql** | `skills/databases/psql.md` | Connection strings, non-interactive queries, backup/restore, meta-commands |
| **redis-cli** | `skills/databases/redis.md` | Connection, key operations, debugging, persistence, cluster management |

### 🚀 Platforms & Services (`skills/platforms/`)

| CLI | File | Use For |
|-----|------|---------|
| **Stripe CLI** | `skills/platforms/stripe.md` | Webhook testing, API debugging, fixtures, payment flow testing |
| **Sentry CLI** | `skills/platforms/sentry.md` | Release management, sourcemap uploads, deploy tracking |
| **Vercel CLI** | `skills/platforms/vercel.md` | Deployments, env vars, serverless functions, domains |
| **Firebase CLI** | `skills/platforms/firebase.md` | Hosting deploy, Firestore rules, auth emulators, Cloud Functions |
| **flyctl** | `skills/platforms/fly.md` | App deployment, scaling, secrets, regions, Machines API |

## Quick Reference: Critical Gotchas

These are the highest-impact mistakes — check the full guide for details:

- **AWS S3**: `--exclude` must come BEFORE `--include` (left-to-right evaluation)
- **Terraform**: Always `terraform plan` after `terraform import` (detects drift)
- **Docker**: Copy dependency files before source code (cache optimization)
- **kubectl**: ALWAYS verify `kubectl config current-context` before apply
- **Helm**: `helm upgrade` RESETS values not specified — use `--reuse-values`
- **Git**: Use `git --no-pager` and `--no-edit` flags (agents have no TTY)
- **SSH**: Use `BatchMode=yes` to prevent password prompt hangs
- **psql**: Always use `-v ON_ERROR_STOP=1` in scripts (psql continues after errors by default)
- **Redis**: NEVER use `KEYS *` in production — use `SCAN` instead (blocks server)
- **gcloud**: Always set `--project` explicitly in automation (don't rely on default project)
- **npm**: Use `npm ci` in CI/CD, not `npm install` (ensures reproducible builds)
- **sed**: `sed -i` behaves differently on macOS vs Linux — use `-i.bak` for portability
- **make**: Indentation MUST be real tabs, not spaces (invisible error)
- **Stripe**: `stripe listen` webhook secret changes on every restart — update your env var
- **Sentry**: Sourcemap `--url-prefix` must exactly match browser request paths
- **Vercel**: `vercel` without `--prod` deploys to preview, not production
- **Firebase**: `firebase deploy` without `--only` deploys EVERYTHING

## Token Efficiency

This skill uses a **category sub-index architecture**. Instead of loading all CLI guides at once:
1. Read this root `SKILL.md` to find the right category
2. Read only the specific CLI guide you need (e.g., `skills/cloud/aws.md`)

This keeps token usage minimal — load one guide (~200-400 lines) instead of the entire library.

## Each Guide Contains

1. **Setup & Auth** — Installation and credential configuration
2. **Core Workflows** — The 20% of commands covering 80% of usage
3. **Flag Gotchas** — Ordering traps, version quirks, surprising defaults
4. **Error Patterns** — Real error messages → real fixes
5. **Anti-Patterns** — "Never do X because Y" with safe alternatives
6. **Composability** — How to pipe this CLI with others
7. **Agent Constraints** — Non-interactive alternatives, TTY workarounds

Related Skills

PicoClaw Fleet

11
from EricGrill/agents-skills-plugins

Orchestrate a fleet of remote PicoClaw workers over SSH for fast, ephemeral one-shot tasks.

DevOps & Infrastructure

posthog-analytics

12
from SylphAI-Inc/skills

Automate PostHog dashboard creation, sync, update, and export via API

create-skill

12
from SylphAI-Inc/skills

Guide users through creating AdaL skills by clarifying the skill type (personal, project, or public plugin) and scaffolding the appropriate structure.

clone-anywebsite

12
from SylphAI-Inc/skills

Guide and recipe for high-fidelity, visual-first web cloning mainly using the Chrome DevTools MCP and Deep DOM Interrogation. and screenshot and read image tool

pijul-sparse-skills

16
from plurigrid/asi

Sparsity-preserving skill versioning via Pijul patches with GF(3) projection gates

load-skills

16
from plurigrid/asi

Bootstrap skill loader for instance startup. Pulls fresh skills from plurigrid/asi and loads GF(3)-balanced startup triads. MUST run at beginning of every new instance.

designing-workflow-skills

16
from plurigrid/asi

Guides the design and structuring of workflow-based Claude Code skills with multi-step phases, decision trees, subagent delegation, and progressive disclosure. Use when creating skills that involve sequential pipelines, routing patterns, safety gates, task tracking, phased execution, or any multi-step workflow. Also applies when reviewing or refactoring existing workflow skills for quality.

vercel-react-native-skills

16
from woojubb/robota

React Native and Expo best practices for building performant mobile apps. Use when building React Native components, optimizing list performance, implementing animations, or working with native modules. Triggers on tasks involving React Native, Expo, mobile performance, or native platform APIs.

eval-skills

16
from JetBrains/databao-cli

Run structured evaluations on skills to measure quality and track improvements.

writing-skills

14
from jay6697117/cx-switch

Use when creating new skills, editing existing skills, or verifying skills work before deployment

find-skills

14
from jay6697117/cx-switch

Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.

infrastructure-skills

13
from docxology/template

Programmatic discovery of first-party agent SKILL.md files under configured public repo roots (infrastructure, projects, docs/prompts, and .cursor/skills). Use when enumerating skills, validating .cursor/skill_manifest.json, writing docs/_generated/skills_index.md, checking docs/prompts workflow contracts, or wiring editor automation. Exposes discover_skills, write_skill_manifest, manifest_matches_discovery, and check_skill_contracts.