Claude Skills

This skill configures secure, high-performance networking between on-premises infrastructure and cloud platforms like AWS, Azure, and GCP. Use it when building hybrid architectures, connecting data centers to the cloud, or during gradual migrations. It provides capabilities for both cost-effective VPNs and high-throughput dedicated connections.

This skill provides comprehensive guidance for creating and managing Helm charts to template and package Kubernetes applications. It helps developers build production-ready charts from scratch, manage multi-environment deployments, and implement reusable configuration templates. Use it when packaging Kubernetes applications or setting up Helm chart repositories following best practices.

This skill enables developers to create and manage production-ready Grafana dashboards for real-time monitoring and observability. It helps visualize system metrics, application performance, and business KPIs from sources like Prometheus. Use it when building operational dashboards, implementing SLO monitoring, or tracking infrastructure health.

This skill enables developers to implement GitOps workflows using ArgoCD and Flux for automated, declarative Kubernetes deployments. It provides guidance for setting up continuous reconciliation, managing multi-cluster deployments, and automating application deployments directly from Git. Use it when adopting GitOps practices or establishing declarative infrastructure management for Kubernetes.

This Claude Skill generates production-ready FastAPI project templates with async patterns and dependency injection. Use it when starting new FastAPI applications to quickly set up structured backend APIs with comprehensive error handling. It's ideal for building high-performance web services and microservices with proper testing and project organization.

This skill automates a comprehensive AI development workflow with structured planning, implementation, and a multi-layer review system using Sub-agents, Claude Code's `/review`, and CodeRabbit CLI. It handles automated fixes and PR creation, prioritizing issues from Critical to Low. Use it for implementing new features, large refactorings, security-critical development, or when a systematic approach is requested.

This Claude Skill enforces exclusive pnpm usage by automatically detecting and blocking npm/yarn commands during package installation, script execution, or dependency management. It intercepts prohibited commands like `npm install` or `npx` and provides corrected pnpm equivalents. The skill activates when users mention package managers or work with dependencies, ensuring consistent package management across the project.

This skill enforces semantic Git commit practices by ensuring proper file staging and prefix usage. It prevents bulk `git add -A` operations and requires focused, purpose-driven commits with appropriate semantic prefixes. Use it when committing code, managing Git history, or when users mention Git-related operations.

This skill implements distributed tracing using Jaeger and Tempo to track requests across microservices. It helps developers debug latency issues, identify performance bottlenecks, and understand service dependencies in distributed systems. Use it when analyzing request flows or implementing observability for microservices architectures.

This Claude Skill helps developers manage major dependency version upgrades with compatibility analysis and staged rollout strategies. It provides comprehensive testing approaches for handling breaking changes in frameworks and libraries. Use it when upgrading major versions, resolving dependency conflicts, or planning incremental upgrade paths.

This skill provides production-ready templates for implementing core DeFi protocols including staking, AMMs, governance, and lending systems. Use it when building decentralized finance applications to accelerate development with battle-tested smart contract patterns. It includes essential functionality like reward distribution, automated market making, and flash loan integration.

This Claude Skill helps developers optimize cloud costs through resource rightsizing, tagging strategies, and spending analysis. It provides a framework for reducing cloud expenses, implementing cost governance, and analyzing infrastructure spending. Use it when you need to downsize resources, manage multi-cloud costs, or meet budget constraints.

This skill helps developers build automated billing systems for recurring payments and subscription management. It handles invoicing, dunning management, proration, and tax calculations for SaaS and subscription-based businesses. Use it when implementing subscription billing, automating invoice generation, or managing payment recovery workflows.

This skill helps developers implement Clean Architecture, Hexagonal Architecture, and Domain-Driven Design for building maintainable and testable backend systems. It's ideal for designing new complex applications or refactoring existing monoliths to achieve loose coupling. The patterns guide you in creating scalable, well-structured codebases with clear domain separation.

This skill provides principles for designing intuitive and maintainable REST and GraphQL APIs. Use it when creating new APIs, reviewing specifications, or establishing team design standards. It covers resource-oriented architecture and helps optimize APIs for various use cases like mobile or third-party integrations.

This skill helps developers migrate AngularJS applications to Angular using hybrid mode and incremental component rewriting. It provides strategies for running both frameworks together, converting directives to components, and updating dependency injection. Use it when planning AngularJS upgrades or modernizing legacy Angular codebases.

This skill generates implementation plans from existing specifications by extracting requirements and converting them into step-by-step tasks. It validates that all spec requirements are covered and explicitly references spec sections. Use it when you have a validated spec and need to create actionable implementation tasks for development work.

This skill performs extended verification before marking work as complete by running tests and validating specification compliance. It blocks completion if either tests fail or the implementation doesn't meet spec requirements, serving as a final quality gate. Developers should use it after implementation but before committing or deploying to ensure both functionality and specification alignment.

This skill establishes the Specification-Driven Development (SDD) methodology and serves as the entry point for SDD conversations. It enforces mandatory use of applicable workflow skills and emphasizes spec-first development where specifications are the single source of truth. Developers should use this skill at the start of any SDD project to determine the appropriate workflow skill to invoke.

The spec skill creates formal, executable specifications directly from clear, well-defined requirements using spec-kit tools. It focuses on defining the WHAT and WHY, not the HOW, and is ideal when detailed requirements are provided upfront. Use this skill to skip exploratory dialogue when the feature scope is already well-defined.

This skill refactors specifications that have evolved organically to identify inconsistencies, remove redundancy, and improve structure while maintaining full feature coverage. It is designed for use on legacy or significantly updated specs to enhance clarity and maintainability, but should not be used during active implementation.

The spec-kit skill provides the technical integration layer for spec-kit CLI, automatically handling initialization, installation validation, and project setup. It ensures proper file/directory layout and serves as the single source of truth for all SDD workflow skills. Developers should use this low-level technical skill when building workflow skills that require spec-kit integration.

The review-spec skill analyzes technical specifications to validate their structure and quality before implementation. It checks for completeness, clarity, and implementability by identifying ambiguities, gaps, and missing requirements. Developers should use it after creating a specification to prevent confusion and rework during the development phase.

This skill reviews code against specification requirements to ensure implementation compliance. It checks for deviations, generates a compliance score with detailed reports, and can trigger spec evolution when mismatches are found. Use it after implementation completion or before deployment to validate that code matches the intended specification.