Claude Skills

This skill provides a standardized cost-estimation framework for technical plans, requiring explicit breakdowns of LLM, infrastructure, and human supervision costs. It enforces a specific parsable output format for integration with the board's API and is used when writing plans, forecasting LLM usage, or making savings claims. The framework ensures all cost estimates are auditable and defensible.

This is a foundational review framework that all domain-specific reviewers must implement to ensure consistent structure, severity ratings, and verdict formatting. It defines the boundary between domain-specific heuristics and generic checks, eliminating duplication across 18 different reviewer prompts. Use this skill whenever invoking any listed domain reviewer, but not for general cross-domain security reviews.

This skill provides a searchable catalogue of known SDLC anti-patterns for agents to actively reject during architecture reviews, planning, implementation, and post-mortems. It enables agents to identify and cite specific bad patterns like "God service" when reviewing code, plans, or incidents. The skill scans project documentation and source code using Read, Grep, and Glob tools to detect these patterns.

This skill enables developers to design stateful digital logic circuits like registers, counters, and finite state machines. It provides methodologies for implementing memory elements (latches, flip-flops) and covers sequential design including state diagrams, transition tables, and timing analysis. Use it when your circuit needs to remember past inputs, count events, or execute state-dependent control sequences.

This skill helps developers build and deploy a pkgdown documentation site for an R package to GitHub Pages. It covers configuration, theming, article organization, and deployment methods like branch-based or GitHub Actions. Use it when creating or customizing a package's documentation site or fixing deployment issues.

This skill enables developers to create parameterized Quarto or R Markdown reports that can be programmatically rendered with different inputs for batch generation. It's designed for automating customized reports for different clients, departments, or data subsets from a single template. Key capabilities include defining parameters, programmatic rendering, and automating recurring reports with varying inputs.

This skill helps developers create production-ready Grafana dashboards with reusable panels, template variables, and provisioning for version-controlled deployment. Use it when building operational dashboards for SRE teams, visualizing Prometheus/Loki metrics, or establishing SLO compliance reporting. It enables migration from manual dashboard creation to automated, maintainable dashboard-as-code workflows.

This skill builds a Feast-based feature store for centralized ML feature management, handling both batch and real-time serving. It enables defining feature views with transformations and point-in-time correct joins for consistent training-serving pipelines. Use it when managing features across multiple models, needing low-latency serving, or reusing feature definitions.

This skill guides developers in building custom MCP servers to expose domain-specific tools to AI assistants. It covers implementation in Node.js or R, including tool definition, transport configuration, and testing with Claude Code. Use it when you need specialized integrations beyond standard tools or to wrap existing APIs as MCP services.

This skill enables distributed agreement without central authority using mechanisms like threshold voting and quorum sensing. It covers proposal generation, advocacy dynamics, and deadlock resolution for leaderless group decisions. Use it when centralized decision-making is a bottleneck or when designing automated consensus systems like distributed databases or multi-agent AI.

This skill helps developers make decisions when multiple valid approaches exist, using a structured "bee democracy" method to independently evaluate options and reach a confident consensus. It's ideal for selecting architectures, justifying tool choices, or before committing to high-cost actions. Key features include reasoning-out-loud for transparency and quorum sensing for confidence-based decision thresholds.

This skill guides developers in building CLI plugins or adapters using the abstract base class pattern. It covers defining the plugin contract, implementing idempotent install/uninstall operations, and choosing installation strategies like symlink or copy. Use it to add support for new frameworks to a CLI tool or to extend an existing plugin architecture.

This skill helps developers create multi-stage CI/CD pipelines using GitHub Actions, featuring matrix builds, dependency caching, and artifact management. It's designed for setting up automated testing and deployment, migrating from other CI tools, or implementing complex workflows with parallel execution and conditional logic. Use it to establish pipelines covering linting, testing, building, and deployment with integrated security and quality gates.

The `breathe` skill is a lightweight AI micro-reset that inserts a single, deliberate pause between actions to check alignment and clear accumulating drift. Use it between tool calls, reasoning steps, or before decisions to refocus attention with minimal interruption. It's designed as a habitual meta-cognitive check for developers to maintain clarity during complex tasks.

This skill enables generative ideation and structured creation from ambiguity, transforming cleared space into coherent new patterns. It is designed for use after clearing stale concepts or when facing novel problems without existing templates. Its core capability is to seed and nurture nascent ideas through their early stages, providing a fresh design approach.

This skill enables an agent to reconstruct its identity and working context from persistent artifacts after a restart or crash, solving the cold-start problem. It performs progressive identity loading, fresh-vs-continuation detection, and calibration to ensure consistent behavior across sessions. Developers should use it at the start of every new session or when agent behavior appears inconsistent with prior interactions.

This skill provides force-free behavioral modification techniques for dogs, using desensitization and counter-conditioning to address issues like reactivity, separation anxiety, and resource guarding. It is designed for use after basic obedience is established, when specific unwanted behaviors interfere with daily life. The methods rely on systematic threshold management to modify the dog's emotional response.

This skill provides structured training for foundational dog commands like sit, stay, and come using positive reinforcement. It covers core training techniques, session structure, and distraction proofing for puppies, adult dogs, or rescues. Developers can use it to integrate reliable, step-by-step obedience guidance into their applications.

This skill enables Claude to monitor its own reasoning process for risks like hallucinations or scope creep. It uses frameworks like Cooper color codes and the OODA loop to assess internal state and make real-time decisions. Developers should use it during complex tasks, in unfamiliar domains, or before producing high-stakes outputs.

This skill audits icon pipelines by comparing registries against glyph maps, icon directories, and manifests to detect missing assets. It identifies gaps in glyphs, icons, and HD variants for skills, agents, and teams across all palettes. Use it to validate asset completeness before renders, after registry updates, or for periodic pipeline health checks.

This skill audits and repairs Claude Code discovery symlinks for skills, agents, and teams by comparing registries against .claude/ directories. It detects missing, broken, or extraneous symlinks and can optionally repair them. Use it after adding new components, repository changes, or when slash commands fail.

This skill audits a project's dependencies to check for outdated versions, security vulnerabilities, and compatibility issues. It analyzes lock files, plans upgrade paths, and assesses breaking changes. Use it before releases, during maintenance, after security advisories, or when inheriting a project to ensure dependency health.

The `attune` skill enables Claude to dynamically calibrate its communication style, expertise level, and emotional tone to match a specific user. It analyzes conversational evidence to adapt to a user's implicit preferences, moving beyond basic intent alignment to genuine relational attunement. Use this skill at session start, during communication mismatches, or when switching between different user contexts.

The Athanor skill systematically transforms tangled or legacy code into optimized, modern output using a four-stage alchemical process. It is designed for deep refactoring tasks where incremental fixes have failed, such as converting codebases between paradigms or overhauling deeply problematic modules. The process includes structured checkpoints to analyze and purify the code at each stage.