▸ Agent Skills

Engineering

The core build, debug, and delivery loop.

Sections

  • acp — Expert guidance for Agent Client Protocol (ACP) - building, integrating, or debugging ACP agents and clients, implementing JSON-RPC 2.0 schemas, managing session lifecycles, elicitation, tool calls, v1/v2 migration, and using official SDKs (TypeScript, Rust, Python, Java, Kotlin). Use when working with ACP protocols, building ACP-compatible AI agent servers or client applications, or inspecting ACP specifications and RFDs.
  • casita — Expert guidance for Casita, the verified content-addressed repository for immutable object graphs, source code, and build artifacts. Use when working with the casita CLI, Rust API (casita::Repository), content-addressed storage, BLAKE3 blob deduplication, canonical directory graphs, roots and retention policies, garbage collection, repository sync, Casitar archives, or importing filesystem, tar, Git, and OCI artifacts.
  • characterization-tests — Pin down the existing behaviour of untested or legacy code with characterization (golden-master / approval) tests before you change it, so refactors and upgrades stay safe. Use when you must modify, refactor, or upgrade code that has no tests, want to capture current behaviour as an oracle even where it looks wrong, or need a safety net before a risky change. Distinct from test-driven development, which specifies new behaviour test-first; this tests around existing behaviour. Pairs with code refactoring and dependency upgrades.
  • code-comments — Write concise, high-signal code comments and prune comment bloat. Use when writing new code, editing existing files, or auditing code comments via /code-comments to keep comments minimal, explain non-obvious intent ("why, not what"), and avoid restating self-explanatory code.
  • codebase-design — Shared vocabulary and principles for designing deep modules. Use when designing or improving a module's interface, hunting for deepening opportunities, deciding where a seam goes, making code more testable or easier for an agent to navigate, or when another skill needs the deep-module vocabulary.
  • diagnosing-bugs — A disciplined loop for hard bugs and performance regressions. Use when the user says debug or diagnose this, or reports something broken, throwing, failing, flaky, or slow. Insists on building a tight, red-capable feedback loop before hypothesising, then reproduces, minimises, ranks hypotheses, instruments, fixes with a regression test, and runs a post-mortem.
  • domain-modeling — Build and sharpen a project's domain model as you design - pin down the ubiquitous language in a CONTEXT.md glossary and record hard-to-reverse architectural decisions as ADRs. Use when you want to nail down domain terminology, challenge fuzzy or conflicting terms, invent edge-case scenarios to stress-test the model, or record an architectural decision - or when another skill needs to maintain the domain model.
  • egui — Expert guidance for immediate-mode GUI development in Rust using egui - widgets, layout, containers, styling, custom painting, state retention, eframe apps, and testing. Use when building desktop or web interfaces in Rust, creating custom immediate-mode widgets or canvas painters, styling egui visuals, or querying docs.rs rustdoc without hallucination.
  • implement — Implement a piece of work based on a spec or set of tickets.
  • mcp — Expert guidance for Model Context Protocol (MCP) server development - designing, building, and debugging MCP servers, implementing tools, resources, and prompts, managing JSON-RPC 2.0 protocol lifecycles, configuring stdio and Streamable HTTP transports, and using official SDKs (TypeScript, Python, Kotlin, Go). Use when implementing or testing MCP servers, defining tool schemas, managing resource subscriptions, or debugging with the MCP Inspector.
  • nutanix-api-v4 — Expert guidance, API endpoints, SDK usage, OData filtering and sorting, namespace specifications, release updates, and troubleshooting for Nutanix v4 APIs (AOS 7.0+, Prism Central pc.2024.3+). Use when developing, integrating, or troubleshooting with Nutanix v4 REST APIs, Python/Go/Java/JavaScript v4 SDKs, OData parameters, or migrating off deprecated legacy Nutanix APIs (v1, v2, v3).
  • nutanix-enterprise-ai — Expert guidance, architecture reference, sizing guidelines, Helm deployment, fine-grained RBAC authorization, Hugging Face and NVIDIA NIM model management, local and unified inference endpoints, batch inference, security scanning, and MCP server configuration for Nutanix Enterprise AI (NAI v2.8). Use when configuring or troubleshooting Nutanix Enterprise AI, GPT-in-a-Box 2.0, LLM model serving, AI Gateway, or Model Context Protocol on Kubernetes.
  • nutanix-files — Expert guidance, CLI commands, architecture reference, file server & share management, SMB/NFS protocols, directory services, smart tiering, disaster recovery, analytics, performance tuning, and troubleshooting for Nutanix Files (v5.0). Use when working with Nutanix Files, SMB/NFS file shares, file analytics, Smart Tiering, Metro Availability, Files REST APIs, or file server performance optimization.
  • nutanix-kubernetes-platform — Expert guidance, CLI commands, architecture reference, cluster lifecycle operations, air-gapped installation, image building, upgrades, and troubleshooting for Nutanix Kubernetes Platform (NKP v2.18), including Konvoy, Kommander, and NKP Insights. Use when working with NKP, Nutanix Kubernetes Platform, Konvoy, Kommander, nkp CLI commands, or Nutanix Kubernetes cluster management.
  • nutanix-objects — Expert guidance, CLI commands, architecture reference, bucket lifecycle management, S3 API operations, streaming replication, IAM configuration, monitoring, and troubleshooting for Nutanix Objects (v5.3). Use when working with Nutanix Objects, S3 object storage, Nutanix Objects Browser, bucket policies, WORM storage, cloud tiering, or Nutanix Objects REST APIs.
  • optimize-performance — Improve the performance of a hot path with measurement-first discipline - profile to find the real bottleneck, set a target, change one thing, re-measure, and stop when the target is met. Use when code is too slow, memory-hungry, or throughput-bound and you want to make it deliberately faster without ever guessing at the cause. For a performance regression - code that was fast and got slow - run bug diagnosis instead, which treats the slowdown as a bug to bisect.
  • productionize-app — Transform an application into a production-ready deployment through systematic analysis, hardening, and framework-specific optimization. Use when preparing an app to ship - auditing readiness, tightening config, and getting it deployable to a target platform.
  • research — Investigate a question against high-trust primary sources - official docs, source code, specs, first-party APIs - and capture the findings as a cited Markdown file in the repo. Use when you want a topic researched, docs or API facts gathered and verified, or the reading legwork delegated to a background agent while you keep working.
  • sculpt-code — Reshape code for readability, naming, structure, TODOs, and reduced surface area - and take on larger cleanups like removing engineering debt, untangling oversized modules, and collapsing duplicated logic - all without changing behaviour. Use when you want to clean up or refactor code, from a quick readability pass to a staged debt-reduction effort.
  • spacetimedb — Expert guidance for developing, publishing, and debugging SpacetimeDB database modules (in Rust, C#, TypeScript, C++) and connecting real-time clients. Use when asked to write SpacetimeDB table schemas, reducers, views, schedule/event tables, or when using the spacetime CLI, generating client SDK bindings, or implementing WebSocket subscriptions.
  • tdd — Test-driven development done red-green-refactor. Use when building a feature or fixing a bug test-first, writing integration tests, deciding what to test and where the test seams go, or avoiding brittle implementation-coupled tests. Covers what a good test is, the anti-patterns to avoid, and the rules of the red-green loop.
  • upgrade-dependencies — Safely upgrade dependencies, frameworks, or a language/runtime version across a codebase, including risky major-version bumps and framework migrations. Use when bumping a package, stepping a major version, migrating a framework, or updating a runtime - read the changelog first, move in small reversible steps behind a green safety net, handle transitive and lockfile changes, and stage the rollout. Lean on characterization tests for the net and bug diagnosis when an upgrade breaks something.
  • xai — Build applications with xAI and Grok APIs, SDKs, model selection, function calling, vision, live web search, and OpenAI-compatible client configurations. Use when integrating Grok models or xAI API endpoints, querying xAI capabilities, or configuring xAI API SDKs.