dotfiles

Complete Bash development skill — defensive patterns, testing with BATS, linting with ShellCheck, POSIX compatibility, idioms, project structure, and CI/CD integration. Load automatically when working with .sh files.

Python debugging via mcp-dap-server with debugpy. Use when stepping through Python code, finding bugs, inspecting runtime state, or debugging pytest tests.

Complete Python development skill — style, type safety, error handling, testing, async, packaging, and performance. Load automatically when working on Python projects.

uv package manager for Python — project setup, dependency management, lockfiles, and migration from pip/poetry/pipenv. Use when setting up Python projects, managing dependencies with uv, or migrating from pip/poetry/pipenv.

Packer HCL2 template authoring. Load when working with .pkr.hcl files. Covers template syntax (variable/locals/source/build blocks), HCL2 type system, provisioners, post-processors, and template organization patterns.

Infrastructure and CI/CD around Packer VM builds. Covers HCP Packer Registry integration, artifact management, automated build pipelines, multi-platform orchestration, image versioning and rollout strategies.

QEMU/KVM VM image baking patterns with Packer. Covers golden image strategy, QEMU-specific boot command/keyboard automation via VNC, preseed/kickstart/cloud-init, QEMU disk management, and image testing.

Terraform and OpenTofu core contribution patterns. Auto-load when working in internal/terraform/, internal/tofu/, or cmd/tofu/ directories. Covers graph engine, state, plans, backends, and provider resolution.

terraform-inventory tool development — state parsing and Ansible inventory generation. Auto-load when go.mod references terraform-inventory.

Terraform CloudInit provider development. Auto-load when working on cloudinit-related provider code. Covers MIME multipart generation, resource/data source design, and testing patterns.

Libvirt Terraform provider development. Auto-load in internal/libvirt/ or internal/codegen/ directories. Covers XML mapping, codegen pipeline, network transports, and RNG schema compliance.

Terraform Plugin Framework and SDK v2 provider development. Auto-load when provider.go or internal/provider/ detected. Covers schema design, resource lifecycle, acceptance testing, and migration patterns.

Terraform/OpenTofu HCL review, development patterns, and core internals. Auto-load when working with .tf files. Complements antonbabenko/terraform-skill for user-facing HCL patterns; this skill covers structured code review and development-side knowledge.

Create and manage CMakePresets.json for reproducible build configurations. Supports configurePresets, buildPresets, testPresets, and IDE integration. Use when setting up a new project's build workflow or standardizing developer build commands.

Use when writing, editing, debugging, or reviewing `.slint` UI code, or wiring it to Rust/C++/JS/Python — the Slint language, layout, compile-time gotchas, interop, and the MCP server for runtime checks.

Use when building CLI tools in Rust. Keywords: CLI, command line, clap, terminal, stdin, stdout, stderr, argument parsing, shell completion, color output, progress bar, TUI, subcommand.

Use when building fintech applications in Rust. Keywords: fintech, trading, decimal, currency, financial, money, transaction, ledger, payment, exchange rate, precision, rounding, accounting, audit.

Use when building web services in Rust. Keywords: web server, HTTP, REST API, axum, actix, warp, tower, middleware, extractors, state management, authentication, JWT, CORS, rate limiting, WebSocket.

Comprehensive Rust development skill — ownership, error handling, async patterns, unsafe code, API design, memory optimization, performance, testing, and idiomatic Rust. Load automatically when working on Rust projects.

Git safety rules for multi-agent environments. Prevents cross-agent contamination by enforcing explicit path staging, banning destructive operations, and requiring pre-commit verification.

C++ development skill — Core Guidelines, clang-tidy, modernization, debugging, and crash diagnosis. Load automatically when working on C++ projects.

Complete Go development skill — style, idioms, error handling, testing, modern features, linter configuration, and optimization. Load automatically when working on Go projects.

Configure CMake install, export, and packaging (CPack) for C++ libraries. Use when setting up library distribution, fixing broken install targets, or adding packaging.

Split monolithic CMakeLists.txt into modular, maintainable CMake scripts. Covers extracting components into cmake/ modules, managing include order, and keeping the root CMakeLists.txt as a thin orchestrator. Use when a root CMakeLists.txt exceeds 200 lines or contains clearly separable concerns.

Configure CMake custom targets for formatting, linting, documentation, and pre-commit hooks. Covers clang-format, clang-tidy, Doxygen, include-what-you-use, sanitizers, and CTest configuration. Use when adding code quality tooling to a CMake project.

Build overlay launcher-style applications using the Hyprtoolkit library and wlr-layer-shell protocol

Write and maintain Arch Linux PKGBUILD build scripts for pacman/makepkg. Covers required fields, build functions, common patterns, VCS sources, split packages, and Arch packaging standards.

Apply operations across multiple files simultaneously. Pattern-based bulk modifications, search-and-replace across codebases, consistent changes to many files at once.

Analyze a software codebase for algorithmic complexity and performance hotspots, then propose or implement safe optimizations without breaking behavior. Use when asked to scan many files, find inefficient loops, nested iteration, repeated scans, costly rendering/recomputation, N+1 queries, avoidable O(n^2) or O(n) operations, or reduce complexity such as O(n^2) to O(n log n) / O(n), while preserving tests, APIs, outputs, and maintainability.

Manage and compress conversation context in long sessions. Detect when context is growing large, summarize completed work phases, archive old findings while preserving key decisions. Prevents context degradation.

Advanced multi-agent orchestration with parallel workers, synthesis protocols, and coordinator lifecycle. Use when complex tasks require multiple agents working in parallel with intelligent result synthesis.

Create evidence artifacts for task completion. Produces evidence.md (human-readable) and evidence.json (machine-readable) per task with per-acceptance-criterion status. Use after implementing a task to prove it works.

Persistent cross-session memory management. Enables agents to remember user preferences, project conventions, and past decisions across different sessions using a structured MEMORY.md index and topic files.

Resolve configuration files through a three-layer override chain (project -> user -> default). Enables customizable skill behavior without editing skill files directly.

Strict output format for reviewer and QA agents. Ensures reviews are consistent, parseable, and actionable. Follows a structured contract with required sections.

Auto-create new skills from repetitive workflows. When you notice yourself doing the same multi-step process repeatedly, extract it into a reusable SKILL.md that any agent can use.

Prove code works by running it, not just checking it exists. Verification through execution rather than inspection. Use after writing or modifying code to ensure it actually functions correctly.