Skillget

skills

skill
Security Audit
Fail
Health Warn
  • License — License: MIT
  • Description — Repository has a description
  • Active repo — Last push 0 days ago
  • Low visibility — Only 5 GitHub stars
Code Fail
  • rm -rf — Recursive force deletion command in install.sh
Permissions Pass
  • Permissions — No dangerous permissions requested
Purpose

This project provides a collection of 25 pre-packaged, text-based instruction sets (skills) for AI coding agents. It focuses heavily on DevOps, infrastructure automation, security, and software engineering tasks.

Security Assessment

Overall risk: Medium. The tool is inherently designed to execute shell commands, interact with infrastructure, and perform security audits, meaning an AI agent acting on these instructions could make significant changes to your system. Additionally, the automated installation script (`install.sh`) contains a `rm -rf` recursive force deletion command, which is a common vector for accidental data loss if the script fails or is improperly scoped. No hardcoded secrets or dangerous network requests were identified in the static scan, and no elevated system permissions are explicitly requested beyond standard user execution.

Quality Assessment

The repository is actively maintained (last push was today) and is properly licensed under the permissive MIT license. However, community trust and visibility are currently very low. The project only has 5 GitHub stars, meaning it has not been broadly vetted by the open-source community. Because this is designed to guide automated agents in complex infrastructure tasks, the lack of extensive peer review is a notable concern.

Verdict

Use with caution. The MIT license and active maintenance are positives, but the unvetted low community visibility and the presence of recursive deletion commands in the installer mean you should carefully review the specific skill instructions before allowing any AI agent to execute them on your system.
SUMMARY

Hand-crafted Claude Code skills for DevOps, infrastructure, security, and software engineering. Production-tested, multi-pass refined, context-optimized. Kubernetes, Terraform, Docker, Ansible, CI/CD, databases, networking, security audits, code review, and more.

README.md

skills.

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

npx skills add iuliandita/skills

25 production-tested skills -- Kubernetes, Terraform, Docker, Ansible, CI/CD, databases, AI/ML, testing, virtualization, Arch Linux, networking, MCP servers, security audits, pentesting, code review, and more.

Built on the Agent Skills open standard. Works with any tool that supports it.

License: MIT
Agent Skills

kubernetes terraform docker ansible archlinux cachyos pacman paru aur systemd 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
  • 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. 25 skills. One command.

What's in the box

25 production-tested skills covering:

Infrastructure & Operations

Skill What it does
ansible Playbooks, roles, collections, Molecule testing, Ansible Vault, CIS benchmarks, compliance hardening
arch-btw Arch Linux and CachyOS administration -- pacman, paru, AUR, systemd, bootloader and kernel recovery
docker Dockerfiles, Compose, Podman, Buildah, multi-stage builds, image signing, container hardening
kubernetes Manifests, Helm charts, Gateway API, Kustomize, ArgoCD, sealed secrets, PCI-DSS compliance
terraform Terraform/OpenTofu -- HCL patterns, module design, state management, policy-as-code, compliance
databases PostgreSQL, MongoDB, MySQL/MariaDB, MSSQL -- tuning, schemas, migrations, replication, connection pooling
ci-cd GitHub Actions, GitLab CI/CD, Forgejo workflows, supply chain security, SHA pinning, SBOM generation
virtualization Proxmox VE, libvirt/QEMU/KVM, XCP-ng, VMware -- Terraform provisioning, Packer templates, cloud-init, GPU passthrough, storage backends, clustering, live migration

Networking & Firewalls

Skill What it does
networking DNS, reverse proxies, VPNs, VLANs, load balancers, WireGuard, Tailscale, nftables, BGP/OSPF
firewall-appliance OPNsense/pfSense firewall management via SSH -- pfctl, CrowdSec, pfBlockerNG, CARP failover, hardening

Security & Pentesting

Skill What it does
security-audit Vulnerability scanning, credential detection, auth review, OWASP checks, supply chain security
lockpick Authorized privilege escalation assessments, CTF challenges, post-exploitation, container escape
zero-day Vulnerability research -- deep code analysis, binary reverse engineering, patch diffing, fuzzing, variant analysis, PoC development

Development & Code Quality

Skill What it does
code-review Bug hunting, logic errors, edge cases, race conditions, resource leaks, convention violations
anti-slop Detects and fixes AI-generated code patterns -- over-abstraction, redundant comments, verbose defensive code
testing Unit, integration, E2E, accessibility, and performance tests -- Vitest, Jest, Playwright, pytest, Go testing, cargo test, TDD workflows, mocking strategies, CI test infrastructure
git Commits, branches, hooks, signing, multi-forge workflows (GitHub, GitLab, Forgejo), release management
command-prompt Shell scripting across zsh, bash, POSIX sh, fish, nushell -- dotfiles, completions, one-liners
mcp MCP server development -- protocol patterns, transport, auth, input validation, injection prevention
ai-ml LLM integrations, RAG pipelines, agent systems, embeddings, evaluation harnesses, local inference, fine-tuning, structured output, tool use, cost optimization, safety guardrails
full-review Orchestrates code-review + anti-slop + security-audit + update-docs in one pass

Tooling & Meta

Skill What it does
prompt-generator Turn scattered ideas into structured LLM prompts -- system prompts, templates, prompt engineering
skill-creator Create, review, audit, and optimize AI tool skills -- consistency checks, overlap detection
skill-refiner Self-improving loop -- iterative quality sweeps with cross-model review, inspired by Karpathy's AutoResearch
update-docs Post-session documentation sweep -- captures gotchas, syncs instruction files, trims bloat

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. Every trigger keyword is tested and tuned to minimize false positives and missed activations.
  • 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

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 15 targets:

Tool Flag Default path
Claude Code claude ~/.claude/skills
OpenAI Codex codex ~/.codex/skills
Cursor cursor ~/.cursor/skills
Windsurf windsurf ~/.windsurf/skills
OpenCode opencode ~/.config/opencode/skills
GitHub Copilot copilot ~/.copilot/skills
Gemini CLI gemini ~/.gemini/skills
Roo Code roo ~/.roo/skills
Goose goose ~/.config/goose/skills
Amp amp ~/.amp/skills
Continue continue ~/.continue/skills
Kiro CLI kiro ~/.kiro/skills
Cline cline ~/.cline/skills
Warp warp ~/.warp/skills
Portable portable ~/.skills

All paths are overridable via --dest (single-tool mode) or environment variables (e.g., CLAUDE_SKILLS_DIR).

Requirements

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

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

Reviews (0)

No results found