skills.

Hand-crafted Agent Skills for DevOps, security, infrastructure, and software engineering.

npx skills add iuliandita/skills

kubernetes terraform docker ansible archlinux cachyos pacman paru aur systemd nixos nix flakes home-manager nix-darwin helm argocd ci-cd github-actions gitlab-ci postgresql mongodb mysql networking dns wireguard tailscale vpn nftables opnsense pfsense mcp model-context-protocol security-audit owasp pentesting privilege-escalation ctf code-review git shell zsh bash prompt-engineering pci-dss compliance devops infrastructure-as-code iac containers podman buildah sealed-secrets haproxy caddy traefik nginx autoresearch self-improving llm rag embedding vector-store langchain langgraph openai-sdk anthropic-sdk agents fine-tuning ollama vllm promptfoo vitest jest playwright pytest tdd e2e accessibility axe-core load-testing k6 proxmox qemu kvm libvirt packer cloud-init gpu-passthrough virtualization hypervisor

Compatibility

These skills follow the Agent Skills open standard - the cross-vendor format for portable AI agent capabilities. Any tool that reads SKILL.md files can use them directly:

• Claude Code - native support
• OpenAI Codex CLI - native support
• Gemini CLI - native support
• Cursor - native support
• VS Code GitHub Copilot - native support
• Windsurf - native support
• OpenCode - native support
• Cline - native support
• Roo Code - native support
• Goose - native support
• Amp - native support
• Continue - native support
• Kiro CLI - native support
• Warp - native support
• OpenClaw - native support
• Hermes Agent - native support
• Qwen Code - native support
• Crush - native support
• Google Antigravity - native support
• Augment - native support
• OpenHands - native support
• Trae - native support
• Qoder - native support
• Kimi Code CLI - native support
• Any other tool that implements the Agent Skills spec

No conversion, no adapters. Drop the skill folder in your tool's skills directory and it works.

Why these skills

These aren't generic prompts copy-pasted from a blog post. Every skill in this collection has been built iteratively, analyzed against real-world usage, cross-checked with official documentation, and refined through multiple passes until it actually works the way you'd expect. Each one is structured with a compact core that triggers fast and loads clean, plus dedicated reference files that get pulled in only when the agent needs the deep stuff - compliance checklists, manifest templates, pattern libraries. No bloat in the main body, no missing context when it matters.

Every skill is researched well beyond any model's training cutoff. We're talking current CVEs, recent breaking changes, deprecation notices, and gotchas from this week - not whatever the model last saw during pre-training. When Kubernetes drops a beta API, when Terraform changes provider behavior, when Docker deprecates a build flag - these skills already know about it. Models are smart, but their knowledge has a shelf life. These skills keep it current.

This is a growing collection. New skills get added as they're built, tested, and proven useful. If you're using an AI coding tool without custom skills, you're leaving a lot of capability on the table.

NEW: Self-Improving Skills

skill-refiner brings Karpathy's AutoResearch pattern to AI skill collections. Instead of manually reviewing and improving skills one by one, skill-refiner runs an automated loop that scores, improves, and validates every skill in the collection - then does it again.

The loop: Score -> Improve -> Verify -> Keep or Revert -> Repeat.

• Adaptive focus - first pass scores everything, then subsequent iterations zero in on the weakest skills until they're brought up to standard
• Three-layer evaluation - lint validation (structural), AI self-check (quality), and behavioral testing against synthetic tasks (does the skill actually work?)
• Cross-model peer review - if you have multiple AI harnesses installed (Claude + Codex, for example), the secondary model reviews every improvement the primary makes. Adversarial evaluation catches single-model blind spots.
• Karpathy gate - only changes that measurably improve a skill's score survive. Everything else gets reverted. No drift, no degeneration, monotonic improvement.
• Self-improvement - skill-refiner improves its own evaluation infrastructure (including itself) in a separate meta-phase with human review checkpoints

10 iterations. 29 skills. One command.

What's in the box

37 production-tested skills covering:

Infrastructure & Operations

Networking & Firewalls

Security & Pentesting

Development & Code Quality

Tooling & Meta

How they're built

Each skill follows the Agent Skills specification:

• SKILL.md with YAML frontmatter - name, description, license, optional compatibility for environment requirements, and metadata for custom fields. The frontmatter is what agents read at startup to decide which skills to activate.
• Compact body (target under 500 lines, 600 hard max) - the core instructions that load into every conversation. Kept lean so it doesn't eat your context window.
• Reference files (references/ directory) - detailed pattern libraries, compliance checklists, manifest templates. The agent reads these on-demand when the task requires depth. You get expert-level detail without paying the token cost upfront.
• Argument hints (metadata.argument_hint) - tells agents what arguments a skill expects when invoked (e.g., <file-or-pattern>, [iterations]). Angle brackets for required, square brackets for optional.
• Precise trigger descriptions - optimized so the right tool activates the right skill at the right time. Descriptions target about 200 characters, with warnings above 240, so startup skill lists stay compact in tools with tight context budgets.
• Cross-skill awareness - skills know about each other. The security-audit skill knows not to step on lockpick's territory. Docker knows to defer to Kubernetes for cluster networking. No overlapping, no conflicts.

Install

Quick install (via skills.sh)

# All skills
npx skills add iuliandita/skills

# Pick specific ones
npx skills add iuliandita/skills --skill kubernetes --skill docker --skill terraform

# See what's available
npx skills add iuliandita/skills --list

Using the bundled installer

# All skills for Claude (default)
git clone https://github.com/iuliandita/skills.git /tmp/skills-install
/tmp/skills-install/install.sh
rm -rf /tmp/skills-install

# Install for a specific tool
git clone https://github.com/iuliandita/skills.git /tmp/skills-install
/tmp/skills-install/install.sh --tool codex
rm -rf /tmp/skills-install

# Pick and choose
git clone https://github.com/iuliandita/skills.git /tmp/skills-install
/tmp/skills-install/install.sh --tool claude kubernetes docker terraform ansible
/tmp/skills-install/install.sh --list  # see what's available
rm -rf /tmp/skills-install

Multi-tool install with symlinks

Install once, symlink everywhere. Skills go to a single canonical directory (~/.agents/skills/), and each tool gets symlinks. Update the canonical copy and all tools see the change.

git clone https://github.com/iuliandita/skills.git /tmp/skills-install

# Install for Claude, Cursor, and Gemini in one shot
/tmp/skills-install/install.sh --tool claude,cursor,gemini --link

# Check for updates later
/tmp/skills-install/install.sh --check --link

rm -rf /tmp/skills-install

Override the canonical directory with SKILLS_CANONICAL_DIR:

SKILLS_CANONICAL_DIR=~/my-skills ./install.sh --tool claude,roo --link

Local private skills can be installed with --include-internal when they exist in your checkout and declare metadata.internal: true. This is mainly for personal gitignored skills; public installs only include the tracked skill set.

./install.sh --tool claude,codex,opencode --link --include-internal --force

Checking for updates

Each install writes a .skills-lock.json with content hashes. Compare against the source to see what changed:

./install.sh --check                # check default (Claude)
./install.sh --check --tool cursor  # check a specific tool
./install.sh --check --link         # check canonical dir

Manual

cp -r skills/kubernetes ~/.claude/skills/kubernetes
cp -r skills/kubernetes ~/.codex/skills/kubernetes
cp -r skills/kubernetes ~/.cursor/skills/kubernetes

Supported tools

The installer supports 25 targets:

Common aliases also work: claude-code, openai-codex, github-copilot, gemini-cli, kiro-cli, qwen-code, and kimi-cli.

All paths are overridable via --dest (single-tool mode) or environment variables (e.g., CLAUDE_SKILLS_DIR). Some agent ecosystems prefer shared or project-local skill directories; for example, OpenClaw also scans ~/.agents/skills, and Hermes can be configured to scan external directories such as ~/.agents/skills. NanoClaw is intentionally not listed as a normal global target because its docs use project-local .claude/skills and container/skills; install to a NanoClaw checkout with --tool portable --dest /path/to/NanoClaw/.claude/skills or --dest /path/to/NanoClaw/container/skills as appropriate.

Requirements

Any AI coding tool that supports the Agent Skills standard. See the supported tools table above for the full list of tested targets.

Releases

Releases use release-please in PR mode. Releasable commits merged to main open or
update a release PR, and merging that release PR creates the tag and GitHub Release.

• feat: creates a minor release
• fix: creates a patch release
• deps: creates a patch release
• Any releasable commit type marked with ! or containing BREAKING CHANGE: creates a major release
• docs:, chore:, ci:, test:, and style: do not trigger a release on their own

This repo uses release-please, which only treats feat, fix, and deps as releasable
units. If a refactor or performance change should cut a release, use a squash-merge title
that reflects the user-facing impact, usually fix:.

Updating

Pull the latest and re-run the installer:

cd /path/to/skills
git pull
./install.sh --force

Or check what changed first:

cd /path/to/skills
git pull
./install.sh --check   # see what's outdated
./install.sh --force   # update everything

The installer backs up existing skills before overwriting (unless --no-backup), so you won't lose local customizations.

Structure

skills/
  ansible/
    SKILL.md              # Core skill instructions (Agent Skills spec)
    references/           # Deep-dive reference files
      compliance.md
      playbook-patterns.md
      ...
  docker/
    SKILL.md
    references/
      dockerfile-patterns.md
      ...
  ...
install.sh                # Installer (15 agents, symlink mode, lock file)
scripts/
  lint-skills.sh          # Collection linter
  validate-spec.sh        # Agent Skills spec validator

Contributing

Found a bug in a skill? Have a suggestion? Open an issue or PR. If you've built skills of your own and want to share, let's talk.

Skills must pass ./scripts/lint-skills.sh and follow the Agent Skills specification.

License

MIT