wshobson/agents
156 skills2M installs6M starsGitHub
Install
npx skills add https://github.com/wshobson/agentsSkills in this repo
1Tailwind Design Systemtailwind-design-system is an agent skill for building production-ready design systems on Tailwind CSS v4 using CSS-first configuration, design tokens, component variants, responsive patterns, and accessibility defaults.56.4kinstalls2Typescript Advanced Typestypescript-advanced-types is comprehensive guidance for TypeScript's advanced type system: generics, conditional types, mapped types, template literal types, and built-in utility types.56.1kinstalls3Nodejs Backend Patternsnodejs-backend-patterns is an agent skill that guides Claude Code when generating Node.js backend services with Express or Fastify. It covers middleware patterns, custom error-handling classes, authentication and authorization, database integration, and REST or GraphQL API design. A developer uses it when scaffolding a Node.js server, REST API, GraphQL backend, or microservice so the output follows production conventions like input validation, connection pooling, rate limiting, and structured logging.40.9kinstalls4Brand Landingpagebrand-landingpage conducts a structured, low-friction brand discovery interview before generating high-converting landing pages. The framework caps the interview at 10 questions across phases and assumes technical literacy with design terminology. Developers use it to extract brand, messaging, and conversion goals efficiently before design asset creation.31.4kinstalls5Python Performance OptimizationComprehensive profiling and optimization guide for Python code covering CPU profiling with cProfile, memory profiling, line-by-line analysis, and performance optimization strategies. Addresses bottleneck identification, latency reduction, memory optimization, and algorithmic improvements.29.9kinstalls6Python Testing Patternswshobson/agents is a production-ready agentic plugin marketplace delivering 92 plugins, 199 agents, and 162 skills across Python development, testing, architecture, security, ML, and more. Use as a marketplace to discover and install domain-specific agent tools, commands, and knowledge packages across multiple coding harnesses.28.4kinstalls7Nextjs App Router PatternsA production-ready agentic plugin marketplace with 92 plugins spanning architecture, languages, security, data, and infrastructure. It generates idiomatic artifacts for six different agent harnesses (Claude Code, Codex, Cursor, OpenCode, Gemini, Copilot) from a single Markdown source. Each plugin is isolated and composable; installing a plugin loads only its components (agents, commands, skills) into context.25.6kinstalls8Code Review ExcellenceCode review excellence skill from the Agentic Plugin Marketplace. Provides structured guidance for conducting thorough code reviews. Part of a marketplace with 92 plugins, 199 agents, and 162 skills for Claude Code and other coding agents.25.6kinstalls9Api Design PrinciplesAPI design principles from the Agentic Plugin Marketplace. Provides guidance on designing robust, maintainable APIs. Part of a comprehensive marketplace with 92 plugins and 162 skills for multiple coding harnesses.25.3kinstalls10Postgresql Table DesignThe wshobson/agents agentic plugin marketplace is a production-ready collection of 92 plugins, 199 agents, 162 skills, and 106 commands for agent-assisted development. It includes agents and skills for database design, backend development, and data architecture. Developers use it to access specialized expertise in PostgreSQL design, schema optimization, and database-related backend patterns across multiple coding agents.22.4kinstalls11Fastapi TemplatesA production agentic plugin marketplace with 92 plugins, 199 agents, 162 skills, and 106 commands. Emits harness-native artifacts from a single Markdown source for Claude Code, Codex, Cursor, OpenCode, Gemini, and GitHub Copilot. Includes a three-layer plugin quality evaluation framework.22kinstalls12E2e Testing PatternsMaster end-to-end testing with Playwright and Cypress to build reliable test suites that catch bugs improve confidence and enable fast deployment Use when implementing E2E tests debugging flaky tests or establishing testing standards name e2e-testing-patterns description Master end-to-end testing with Playwright and Cypress to build reliable test suites that catch bugs improve confidence and enable fast deployment Use when implementing E2E tests debugging flaky tests or establishing testing standards E2E Testing Patterns Build reliable fast and maintainable end-to-end test suites that provide confidence to ship code quickly and catch regressions before users do When to Use This Skill Implementing end-to-end test automation Debugging flaky or unreliable tests Testing critical user workflows Setting up CI CD test pipelines Testing across multiple browsers Validating accessibility requirements Testing responsive designs Establishing E2E testing standards Core Concepts 1 E2E Testing Fundamentals What to Test with E2E Critical user journeys login checkout signup Complex interactions drag-and-drop multi-step forms Cross-browser compatibility Real API integration Authentication flows Wha.20kinstalls13Architecture PatternsAdvanced architecture patterns reference covering Domain-Driven Design (DDD), Onion Architecture, and Anti-Corruption Layers with implementation examples. The skill provides a complete multi-service project structure organized by bounded contexts, showing how to structure dependencies and handle cross-context communication. Software engineers use this to design and implement complex, maintainable system architectures.19.6kinstalls14Mobile Android DesignA comprehensive guide to Material Design 3 and Jetpack Compose for building modern Android apps. Use this when designing Android interfaces, implementing Compose layouts, creating adaptive designs for multiple screen sizes, and following Google's Material Design 3 guidelines.19.5kinstalls15Mobile Ios DesignMaster iOS design with SwiftUI components and Apple Human Interface Guidelines. Covers navigation patterns, responsive layouts, typography, colors, SF Symbols, accessibility, and design for iPhone, iPad, and visionOS.19.3kinstalls16Prompt Engineering PatternsMaster advanced prompt engineering techniques to maximize LLM performance, reliability, and controllability in production. Covers few-shot learning, chain-of-thought prompting with self-consistency, structured outputs with JSON mode and Pydantic, prompt optimization through A/B testing, and template systems with variable interpolation. Teaches how to design system prompts, reduce token usage, and handle edge cases through strategic example selection.18.7kinstalls17Error Handling PatternsMaster error handling patterns across languages including exceptions, Result types, error propagation, and graceful degradation. Covers error categories (recoverable vs unrecoverable), best practices for failing fast, preserving context, meaningful messages, and type-safe errors. Teaches when to use exceptions vs Result types, clean resource handling, and common pitfalls like catching too broadly or poor error messages.18.5kinstalls18Python Design PatternsWrite maintainable Python code using design principles like KISS, Single Responsibility, and composition over inheritance. Use when designing new services, refactoring complex code, or evaluating code structure for coupling and testability.17.4kinstalls19Javascript Testing PatternsImplement robust testing strategies for JavaScript/TypeScript using Jest, Vitest, and Testing Library. Use when setting up test infrastructure, writing unit and integration tests, or adopting TDD. Covers mocking, fixtures, and component testing.16.7kinstalls20Modern Javascript PatternsMaster ES6+ features and modern JavaScript patterns including async/await, destructuring, and functional programming. Use when refactoring legacy code, implementing modern patterns, or optimizing JavaScript applications.16.7kinstalls21Sql Optimization PatternsSQL Optimization Patterns teaches systematic query optimization and database performance tuning using EXPLAIN analysis, proper indexing strategies (B-Tree, Hash, GIN, GiST, BRIN), and query plan reading. It covers index design decisions, avoiding N+1 queries, join optimization, partial indexes, and functional indexes. Use this skill when debugging slow-running queries, designing performant schemas, or reducing database load. Includes monitoring techniques like pg_stat_statements for finding missing indexes and optimization best practices for different query patterns.16.3kinstalls22Rust Async PatternsRust Async Patterns teaches production async/await programming with the Tokio runtime for building high-performance concurrent systems. It covers Tokio tasks, channels, streams, error propagation, JoinSet for managing multiple tasks, select! for racing futures, and proper cancellation token handling. Use this skill when building async Rust services, implementing concurrent I/O operations, or debugging async code issues. It emphasizes non-blocking operations, proper error handling with `?`, and best practices like avoiding locks across await points and handling graceful shutdown.16.3kinstalls23Security Requirement ExtractionA skill for deriving actionable security requirements from threat models and business context. Use when translating threats into testable requirements, writing security user stories, building acceptance criteria, or mapping compliance requirements. Bridges security analysis and implementation through structured requirement categories, traceability attributes, and priority-driven testing.16kinstalls24Dotnet Backend PatternsMaster C#/.NET backend development patterns for building production-grade APIs, MCP servers, and enterprise applications. Covers clean architecture, dependency injection, async/await, Entity Framework Core, Dapper, configuration via IOptions pattern, Redis caching, and unit/integration testing with xUnit. Use when developing .NET backends, reviewing C# code, designing service architectures, or implementing caching and resilience patterns.15.8kinstalls25Git Advanced WorkflowsMaster advanced Git workflows including rebasing, cherry-picking, bisect, worktrees, and reflog to maintain clean history and recover from any situation. Use when managing complex Git histories, cleaning up commits before merging, applying specific commits across branches, finding commits that introduced bugs, working on multiple features simultaneously, troubleshooting repository issues, or preparing clean pull requests for review.15.7kinstalls26Responsive DesignResponsive Design is part of the wshobson/agents agentic plugin marketplace providing 92 plugins and 162 skills across development domains. The marketplace offers domain-expert agents, modular skills with progressive disclosure, and commands for common workflows. Developers use it to load specialized capabilities on-demand for architecture, testing, security, infrastructure, and domain-specific coding tasks.15.6kinstalls27Database MigrationA production-grade agentic plugin marketplace with 92 composable plugins, 199 domain-expert agents, and 162 skills that compile to five AI coding harnesses (Claude Code, Codex, Cursor, OpenCode, Gemini, Copilot). Each plugin isolates its own agents, commands, and skills - install only what you need. Includes orchestrators for multi-agent coordination (full-stack builds, security, ML, incident response) and tiered model selection (Fable 5 for long-horizon work down to Haiku for fast ops).14.5kinstalls28Async Python PatternsAsync Python Patterns is a skill within the wshobson/agents marketplace providing guidance on asynchronous programming in Python. It covers async/await patterns, asyncio best practices, and concurrent programming techniques. Developers use it when implementing async workflows, optimizing I/O-bound operations, or working with async frameworks.13.8kinstalls29Github Actions TemplatesProduction-ready GitHub Actions workflow templates for testing, building, and deploying applications. Includes patterns for Docker image builds, Kubernetes deployments, security scanning with Trivy and Snyk, matrix builds for multi-version testing, and reusable workflow composition.13.3kinstalls30Openapi Spec Generationopenapi-spec-generation is a skill for generating OpenAPI specifications directly from Python FastAPI or TypeScript code. It demonstrates code-first patterns where API specs are derived from models and route definitions rather than maintained separately. Developers use it during Build phase to keep documentation and specs synchronized with implementation.13.3kinstalls31Backtesting FrameworksA framework for building production-grade backtesting systems for trading strategies. Covers common pitfalls including look-ahead bias, survivorship bias, overfitting, and transaction costs. Includes walk-forward analysis and out-of-sample testing patterns.13.2kinstalls32Data StorytellingA skill for transforming raw data into compelling business narratives. Structures insights using story arcs, visualization, context, and persuasive techniques. Useful for executive presentations, quarterly business reviews, investor pitches, and data-driven reports.13.1kinstalls33Solidity SecuritySolidity Security teaches smart contract security best practices and vulnerability prevention patterns. Developers use this skill when writing secure smart contracts, auditing existing contracts, or implementing DeFi protocols. The skill covers reentrancy, overflow, access control, and gas optimization while maintaining security.12.9kinstalls34Godot Gdscript PatternsA skill for game development with Godot 4 and GDScript. Covers scene architecture, signals, typed properties, state machines, and game system patterns. Developers use it when building Godot games, implementing player/enemy systems, managing game state, and optimizing GDScript performance.12.8kinstalls35Terraform Module LibraryTerraform Module Library provides production-ready infrastructure-as-code patterns for AWS, Azure, GCP, and OCI. Developers use this skill when building reusable infrastructure components and standardizing cloud provisioning across organizations. The skill covers VPC, container orchestration, databases, and storage with test-driven infrastructure patterns.12.8kinstalls36React Native Designreact-native-design provides patterns for React Native cross-platform mobile development. It covers styling (StyleSheet, platform-specific), navigation (React Navigation stack/drawer/bottom-tab), and animations (Reanimated 3 shared values and worklets). It includes responsive layout patterns, gesture handling, and performance best practices. Developers use it to build high-quality native mobile experiences.12.4kinstalls37Python Code StyleThis skill teaches modern Python code style, linting, and documentation practices for maintainable codebases. It covers automated formatting with ruff, type checking with mypy/pyright, PEP 8 naming conventions, import organization, and Google-style docstrings. Developers use it when setting up project standards, configuring tools in pyproject.toml, writing or reviewing docstrings, and establishing team coding conventions. Key workflows include installing ruff and mypy, enabling strict type checking, documenting public APIs with consistent docstring formats, and automating style checks in CI/CD pipelines.12.3kinstalls38Design System Patternsdesign-system-patterns is a wshobson agents skill for building maintainable design systems across web and mobile. It covers primitive, semantic, and component token layers with naming by purpose, multi-platform generation, and CSS custom property theming including light/dark, system prefers-color-scheme, persistence, reduced motion, and high contrast. Component architecture sections span compound components, polymorphic as props, variant and size systems, slot composition, headless UI, and responsive style props. The token pipeline addresses Figma synchronization, Style Dictionary configuration, transforms, and CI/CD token updates. A quick-start TypeScript example shows gray and blue primitives mapped to semantic light and dark surfaces, borders, and interactive colors. Best practices warn against token sprawl, inconsistent naming, missing dark mode, hardcoded values, circular references, and platform gaps. Detailed worked examples live in references/details.md when the overview is insufficient. Use it when creating tokens, theme switching, multi-brand theming, or design-to-code foundations.12.3kinstalls39K8s Security Policiesk8s-security-policies provides comprehensive Kubernetes security implementation guide covering NetworkPolicy (network segmentation), PodSecurityPolicy/Pod Security Standards, RBAC (least-privilege access), Istio mTLS, and OPA Gatekeeper admission control. It includes CIS and NIST compliance mappings and troubleshooting. Developers use it to secure production Kubernetes clusters and enforce multi-tenant isolation.12.2kinstalls40Architecture Decision RecordsArchitecture Decision Records (ADRs) skill provides templates and workflows for capturing the context, rationale, and consequences of significant technical decisions. Developers use it when adopting new frameworks, selecting databases, designing APIs, or establishing decision-making processes. The skill covers five template formats (MADR, lightweight, Y-statement, deprecation, RFC), a directory structure with git-friendly organization, an ADR index with status tracking, and automated tooling via adr-tools. Key workflows include writing new records, superseding decisions, managing deprecations, and reviewing decisions across teams.12.1kinstalls41Gdpr Data HandlingThis skill provides a practical guide for building GDPR-compliant data systems covering consent management, data subject rights (access, erasure, portability), and privacy-by-design patterns. Developers use it when building systems that process EU personal data, implementing privacy controls, or conducting compliance reviews. Key workflows include documenting processing activities and legal bases under Article 6, implementing the six data subject rights with 30-day response SLAs, categorizing personal data by protection level (basic, sensitive Art. 9, criminal Art. 10, children's), and enforcing encryption and access controls. The skill emphasizes data minimization, continuous audits, and proper consent implementation (opt-in, non-bundled, separately documented).12.1kinstalls42React State ManagementComprehensive guide covering modern React state management patterns across local component state, global stores, and server state synchronization. Developers use this skill to architect state solutions for apps of any scale - from simple Zustand stores in small projects to complex Redux Toolkit + React Query setups in large applications. Key workflows include selecting the right tool by app complexity and state type, implementing optimistic updates, migrating legacy Redux codebases to Redux Toolkit using createSlice, and separating client state from server state concerns.12kinstalls43React Native ArchitectureThis skill provides production-ready patterns for React Native development using Expo, covering project structure, navigation with Expo Router, state management, native module integration, and offline-first architecture. Developers use it when starting new React Native or Expo projects, implementing complex navigation, integrating native APIs, or optimizing performance. Key workflows include setting up Expo projects with TypeScript, organizing components and services, implementing tab and auth navigation stacks, choosing between Expo and bare React Native, and following performance best practices like memoization and FlashList for long lists.11.9kinstalls44Kpi Dashboard DesignKPI Dashboard Design provides patterns for building dashboards across strategic, tactical, and operational levels. Developers use this skill to select SMART KPIs, structure hierarchical views (executive summary to detailed drilldowns), apply visualization best practices, and troubleshoot common issues like metric calculation misalignment, alert fatigue, and performance degradation. Core workflows include establishing metric governance, enabling drilldown paths from summary KPIs to root cause analysis, pre-aggregating metrics to avoid database strain on live dashboards, and aligning calculation methodology across teams (e.g., normalizing annual subscription plans to monthly revenue).11.9kinstalls45Uv Package Manageruv is an ultra-fast Python package installer and resolver written in Rust that replaces pip, pip-tools, and poetry for dependency management. Developers use it to set up projects, manage dependencies, create virtual environments, and install Python interpreters with significantly faster performance. Key workflows include initializing projects with `uv init`, adding/removing packages with `uv add`/`uv remove`, managing virtual environments via `uv venv` and `uv run`, pinning Python versions, and generating lockfiles for reproducible builds. Works cross-platform (Linux, macOS, Windows) and requires no Python installation.11.8kinstalls46Monorepo ManagementThis skill teaches monorepo architecture and tooling to manage multiple interdependent packages in a single repository. Developers use it when establishing new monorepos, migrating from multi-repo setups, or optimizing build performance. Core workflows include configuring Turborepo pipelines with task dependencies, structuring workspaces with shared packages, managing versioning across packages using Changesets, and debugging circular dependencies. The skill covers package manager setup (pnpm, npm, Yarn workspaces), build system configuration (Turborepo pipeline, Nx features), dependency management, atomic commits, and CI/CD integration for monorepos.11.6kinstalls47Interaction DesignThis skill teaches developers how to design and build engaging user interactions through motion, feedback patterns, and thoughtful state transitions. It covers microinteractions (button hovers, clicks), loading states (skeleton screens, progress bars), page transitions, gesture-based interactions (swipe-to-dismiss), and notification systems. Developers use it when adding polish to UI, improving perceived performance, or creating delightful experiences. Key workflows include timing guidelines (100-150ms for micro-feedback, 300-500ms for modals), easing functions (ease-out for entering, ease-in for exiting), and accessibility patterns (respecting prefers-reduced-motion). The skill emphasizes performance optimization using transform and opacity, spring-based physics, and interruptible animations.11.5kinstalls48Accessibility ComplianceThis skill teaches WCAG 2.2 Level AA/AAA compliance implementation for inclusive user interfaces. Covers semantic HTML, ARIA patterns, keyboard navigation, focus management, form accessibility, and mobile accessibility (VoiceOver, TalkBack). Developers use it when auditing accessibility violations, implementing screen reader support, building keyboard-navigable components, and ensuring compliance. Key workflows include testing with automated tools (axe, Lighthouse), manual testing with assistive technologies, and fixing common issues like missing alt text, poor contrast, keyboard traps, and unfocused form labels.11.5kinstalls49Python Project StructureThis skill teaches how to design well-organized Python projects using module cohesion, explicit interfaces via __all__, and flat directory hierarchies. Developers use it when starting new projects, reorganizing codebases, or defining public APIs. Key workflows include choosing between flat and nested structures, deciding test file placement (colocated vs. parallel), applying layered or domain-driven architecture patterns, and writing focused modules around single concepts. The skill covers patterns like one-concept-per-file, package initialization, consistent naming conventions, and absolute imports to ensure code remains discoverable and changes predictable.11.1kinstalls50Rag ImplementationRAG Implementation teaches developers to build Retrieval-Augmented Generation systems that combine LLMs with external knowledge sources to reduce hallucinations and provide grounded, factual responses. Covers vector database selection (Pinecone, Weaviate, Milvus, Chroma, Qdrant, pgvector), embedding models (Voyage, OpenAI, open-source), retrieval strategies (dense, sparse, hybrid, multi-query, HyDE), and reranking techniques. Includes a complete LangGraph-based code example demonstrating async retrieve-then-generate workflows with Claude and Anthropic embeddings, enabling developers to implement Q&A over proprietary documents, chatbots with current information, semantic search, documentation assistants, and research tools with source citation.11.1kinstalls51Stripe IntegrationThis skill covers implementing Stripe payment processing including checkout sessions, payment intents, subscriptions, webhooks, and customer management. Developers use it when building payment flows for one-time purchases, recurring billing, or marketplace transactions. Core workflows include setting up checkout sessions (recommended for most cases), handling subscription lifecycle events via webhooks (payment_intent.succeeded, customer.subscription.updated), managing customer records and payment methods, and testing with Stripe's test mode and card numbers. The skill emphasizes PCI-compliant patterns and provides Python SDK examples for quick integration.10.9kinstalls52Changelog AutomationThis skill teaches patterns and tools for automating changelog generation, release notes, and version management following industry standards like Keep a Changelog and Conventional Commits. Developers use it when setting up release workflows, implementing commit message standards, and generating GitHub/GitLab release notes. Key workflows include writing scoped commit messages (e.g. feat(auth), fix(checkout)), marking breaking changes with `!` or footer, referencing issues in commits, and validating commits via commitlint in CI pipelines. The skill covers semantic versioning integration, structured release note templates with highlights and upgrade guides, and best practices like one logical change per commit and never manually editing generated changelogs.10.9kinstalls53Deployment Pipeline DesignThis skill teaches architects and platform engineers how to design robust, secure deployment pipelines that balance speed with safety. It covers stage organization, approval gates, progressive delivery strategies (canary, blue-green, rolling), health check configuration, and automated rollback triggers. Developers use it when setting up multi-environment promotion workflows, implementing zero-downtime deployments, debugging failed gates, or reducing mean time to recovery. Key workflows include defining pipeline stages with job dependencies, configuring metric-based promotion gates, establishing deep readiness probes, and versioning migration rollback scripts for backward compatibility.10.9kinstalls54Auth Implementation PatternsSkill covers authentication and authorization patterns for building secure access control systems. Covers session-based auth, JWT tokens, OAuth2/OpenID Connect, and role-based access control (RBAC). Developers use this when implementing user authentication, securing REST/GraphQL APIs, adding social login, designing session management, or debugging auth issues. Key workflows include verifying identity, issuing credentials, permission checking, and policy enforcement. Includes best practices for password hashing, HTTPS, token expiration, secure cookies, input validation, rate limiting, CSRF protection, secret rotation, security logging, and MFA.10.8kinstalls55Debugging StrategiesThis skill teaches systematic debugging methodology combining the scientific method (observe, hypothesize, experiment, analyze) with practical tool usage across JavaScript, Python, and Go. Developers use it when tracking production issues, performance problems, memory leaks, or intermittent bugs that require structured investigation. Core workflows include reproducing issues consistently, gathering environment and error data, forming testable hypotheses, and isolating problems via binary search, differential debugging, or profiling. Covers Chrome DevTools, VS Code debugger, pdb, Delve, git bisect, heap snapshots, and performance profiling techniques.10.6kinstalls56Langchain ArchitectureThis skill teaches building production-grade LLM applications using LangChain 1.x and LangGraph for explicit agent orchestration, state management, and tool integration. Developers use it when creating autonomous AI agents with memory, implementing complex multi-step workflows, managing conversation state across sessions, and integrating LLMs with external APIs and document stores. Core workflows include designing StateGraph agents with typed state, implementing ReAct and Plan-and-Execute patterns, managing short and long-term memory via checkpointers, loading and chunking documents, and observing applications with LangSmith tracing.10.6kinstalls57Microservices PatternsThis skill teaches microservices architecture patterns for building distributed systems, including service decomposition strategies (business capability, DDD subdomains, strangler fig), communication approaches (REST, gRPC, GraphQL, Kafka, message queues), data management techniques (database per service, saga pattern for distributed transactions), and resilience patterns (circuit breaker, retry with backoff, bulkhead). Developers use this when decomposing monoliths, designing service boundaries, implementing inter-service communication, managing distributed data, or building systems requiring high availability and fault isolation.10.4kinstalls58Python Error HandlingPython error handling patterns for building robust applications through early input validation, meaningful exception design, and graceful failure recovery. Developers use this skill when validating API parameters, designing exception strategies for applications, handling batch operation failures, and converting external data to domain types. Key workflows include fail-fast validation before expensive operations, mapping errors to appropriate exception types, using Pydantic for structured input validation, chaining exceptions to preserve debug context, and tracking successes and failures separately in batch processing.10.4kinstalls59Web Component DesignThis skill teaches developers how to architect maintainable component libraries and design systems across React, Vue, and Svelte. It covers composition patterns (compound components, render props, slots), CSS-in-JS solutions (Tailwind, styled-components, Emotion, CSS Modules, Vanilla Extract), and component API design principles. Developers use this when building UI component libraries, implementing design systems, refactoring legacy components into modern patterns, or designing accessible, responsive components. Key workflows include choosing appropriate styling approaches, preventing prop drilling with context, implementing controlled/uncontrolled patterns, and applying memoization to optimize renders.10.3kinstalls60Visual Design FoundationsVisual Design Foundations teaches developers to build cohesive visual systems using typography, color theory, spacing, and iconography. It covers modular typography scales, 8-point grid spacing systems, semantic color tokens, and dark mode strategies with WCAG accessibility standards. Developers use this when establishing design tokens for new projects, creating spacing systems, selecting typefaces, building accessible color palettes, designing icon systems, improving visual hierarchy, and auditing design consistency. The skill includes practical workflows: CSS variable definitions for typography and spacing, Tailwind configuration examples, contrast ratio calculations, responsive fluid typography with clamp(), font-pairing guidelines, and component spacing conventions.10.3kinstalls61Grafana DashboardsThis skill covers designing and managing Grafana dashboards for comprehensive system observability using metrics from Prometheus and other sources. Developers use it to visualize application and infrastructure metrics, implement monitoring patterns like RED (Rate, Errors, Duration) and USE (Utilization, Saturation, Errors), and configure alerts. Key workflows include structuring dashboard hierarchies with stat panels and time series graphs, using variables for multi-service filtering, provisioning dashboards via code (Terraform/Ansible), and creating specialized dashboards for APIs, databases, and infrastructure monitoring.10.2kinstalls62Secrets ManagementImplement secure secrets management for CI CD pipelines using Vault AWS Secrets Manager or native platform solutions Use when handling sensitive credentials rotating secrets or securing CI CD environments name secrets-management description Implement secure secrets management for CI CD pipelines using Vault AWS Secrets Manager or native platform solutions Use when handling sensitive credentials rotating secrets or securing CI CD environments Secrets Management Secure secrets management practices for CI CD pipelines using Vault AWS Secrets Manager and other tools Purpose Implement secure secrets management in CI CD pipelines without hardcoding sensitive information When to Use Store API keys and credentials Manage database passwords Handle TLS certificates Rotate secrets automatically Implement least-privilege access Secrets Management Tools HashiCorp Vault Centralized secrets management Dynamic secrets generation Secret rotation Audit logging Fine-grained access control AWS Secrets Manager AWS-native solution Automatic rotation Integration with RDS CloudFormation support Azure Key Vault Azure-native solution HSM-backed keys Certificate management RBAC integration Google Secret Man.10.2kinstalls63Gitlab Ci PatternsBuild GitLab CI CD pipelines with multi-stage workflows caching and distributed runners for scalable automation Use when implementing GitLab CI CD optimizing pipeline performance or setting up automated testing and deployment name gitlab-ci-patterns description Build GitLab CI CD pipelines with multi-stage workflows caching and distributed runners for scalable automation Use when implementing GitLab CI CD optimizing pipeline performance or setting up automated testing and deployment GitLab CI Patterns Comprehensive GitLab CI CD pipeline patterns for automated testing building and deployment Purpose Create efficient GitLab CI pipelines with proper stage organization caching and deployment strategies When to Use Automate GitLab-based CI CD Implement multi-stage pipelines Configure GitLab Runners Deploy to Kubernetes from GitLab Implement GitOps workflows Basic Pipeline Structure yaml stages build test deploy variables DOCKER_DRIVER overlay2 DOCKER_TLS_CERTDIR certs build stage build image node 20 script npm ci npm run build artifacts paths dist expire_in 1 hour cache key CI_COMMIT_REF_SLUG paths node_modules test stage test image node 20 script npm ci npm run lint npm test coverage.10.2kinstalls64React ModernizationUpgrade React applications to latest versions migrate from class components to hooks and adopt concurrent features Use when modernizing React codebases migrating to React Hooks or upgrading to latest React versions name react-modernization description Upgrade React applications to latest versions migrate from class components to hooks and adopt concurrent features Use when modernizing React codebases migrating to React Hooks or upgrading to latest React versions React Modernization Master React version upgrades class to hooks migration concurrent features adoption and codemods for automated transformation When to Use This Skill Upgrading React applications to latest versions Migrating class components to functional components with hooks Adopting concurrent React features Suspense transitions Applying codemods for automated refactoring Modernizing state management patterns Updating to TypeScript Improving performance with React 18 features Version Upgrade Path React 16 17 18 Breaking Changes by Version React 17 Event delegation changes No event pooling Effect cleanup timing JSX transform no React import needed React 18 Automatic batching Concurrent rendering Strict Mode changes dou.10kinstalls65Python PackagingCreate distributable Python packages with proper project structure, setup.py/pyproject.toml, and publishing to PyPI. Use when packaging Python libraries, creating CLI tools, or distributing Python code. --- name: python-packaging description: Create distributable Python packages with proper project structure, setup.py/pyproject.toml, and publishing to PyPI. Use when packaging Python libraries, creating CLI tools, or distributing Python code. --- # Python Packaging Comprehensive guide to creating, structuring, and distributing Python packages using modern packaging tools, pyproject.toml, and publishing to PyPI. ## When to Use This Skill - Creating Python libraries for distribution - Building command-line tools with entry points - Publishing packages to PyPI or private repositories - Setting up Python project structure - Creating installable packages with dependencies - Building wheels and source distributions - Versioning and releasing Python packages - Creating namespace packages - Implementing package metadata and classifiers ## Core Concepts ### 1. Package Structure - **Source layout**: `src/package_name/` (recommended) - **Flat layout**: `package_name/` (simpler but less flexib.10kinstalls66Python Anti PatternsUse this skill when reviewing Python code for common anti-patterns to avoid Use as a checklist when reviewing code before finalizing implementations or when debugging issues that might stem from known bad practices name python-anti-patterns description Use this skill when reviewing Python code for common anti-patterns to avoid Use as a checklist when reviewing code before finalizing implementations or when debugging issues that might stem from known bad practices Python Anti-Patterns Checklist A reference checklist of common mistakes and anti-patterns in Python code Review this before finalizing implementations to catch issues early When to Use This Skill Reviewing code before merge Debugging mysterious issues Teaching or learning Python best practices Establishing team coding standards Refactoring legacy code Note This skill focuses on what to avoid For guidance on positive patterns and architecture see the python-design-patterns skill Infrastructure Anti-Patterns Scattered Timeout Retry Logic python BAD Timeout logic duplicated everywhere def fetch_user user_id try return requests get url timeout 30 except Timeout logger warning Timeout fetching user return None def fetch_orders.9.9kinstalls67Wcag Audit PatternsConduct WCAG 2.2 accessibility audits with automated testing, manual verification, and remediation guidance. Use when auditing websites for accessibility, fixing WCAG violations, or implementing accessible design patterns. --- name: wcag-audit-patterns description: Conduct WCAG 2.2 accessibility audits with automated testing, manual verification, and remediation guidance. Use when auditing websites for accessibility, fixing WCAG violations, or implementing accessible design patterns. --- # WCAG Audit Patterns Comprehensive guide to auditing web content against WCAG 2.2 guidelines with actionable remediation strategies. ## When to Use This Skill - Conducting accessibility audits - Fixing WCAG violations - Implementing accessible components - Preparing for accessibility lawsuits - Meeting ADA/Section 508 requirements - Achieving VPAT compliance ## Core Concepts ### 1. WCAG Conformance Levels | Level | Description | Required For | | ------- | ---------------------- | ----------------- | | **A** | Minimum accessibility | Legal baseline | | **AA** | Standard conformance | Most regulations | | **AAA** | Enhanced accessibility | Specialized needs | ### 2. POUR Principles ``` Perceivable:.9.7kinstalls68Startup Financial ModelingBuild comprehensive 3-5 year financial models with revenue projections, cost structures, cash flow analysis, and scenario planning for early-stage startups. Use this skill when creating financial projections, calculating burn rate or runway, modeling fundraising scenarios, or preparing investor-ready financials for a seed or Series A raise. --- name: startup-financial-modeling description: Build comprehensive 3-5 year financial models with revenue projections, cost structures, cash flow analysis, and scenario planning for early-stage startups. Use this skill when creating financial projections, calculating burn rate or runway, modeling fundraising scenarios, or preparing investor-ready financials for a seed or Series A raise. version: 1.0.0 --- # Startup Financial Modeling Build comprehensive 3-5 year financial models with revenue projections, cost structures, cash flow analysis, and scenario planning for early-stage startups. ## Overview Financial modeling provides the quantitative foundation for startup strategy, fundraising, and operational planning. Create realistic projections using cohort-based revenue modeling, detailed cost structures, and scenario analysis to support deci.9.6kinstalls69Bash Defensive PatternsMaster defensive Bash programming techniques for production-grade scripts. Use when writing robust shell scripts, CI/CD pipelines, or system utilities requiring fault tolerance and safety. --- name: bash-defensive-patterns description: Master defensive Bash programming techniques for production-grade scripts. Use when writing robust shell scripts, CI/CD pipelines, or system utilities requiring fault tolerance and safety. --- # Bash Defensive Patterns Comprehensive guidance for writing production-ready Bash scripts using defensive programming techniques, error handling, and safety best practices to prevent common pitfalls and ensure reliability. ## When to Use This Skill - Writing production automation scripts - Building CI/CD pipeline scripts - Creating system administration utilities - Developing error-resilient deployment automation - Writing scripts that must handle edge cases safely - Building maintainable shell script libraries - Implementing comprehensive logging and monitoring - Creating scripts that must work across different platforms ## Detailed patterns and worked examples Detailed pattern documentation lives in `references/details.md`.9.5kinstalls70Python Type SafetyPython type safety with type hints, generics, protocols, and strict type checking. Use when adding type annotations, implementing generic classes, defining structural interfaces, or configuring mypy/pyright. --- name: python-type-safety description: Python type safety with type hints, generics, protocols, and strict type checking. Use when adding type annotations, implementing generic classes, defining structural interfaces, or configuring mypy/pyright. --- # Python Type Safety Leverage Python's type system to catch errors at static analysis time. Type annotations serve as enforced documentation that tooling validates automatically. ## When to Use This Skill - Adding type hints to existing code - Creating generic, reusable classes - Defining structural interfaces with protocols - Configuring mypy or pyright for strict checking - Understanding type narrowing and guards - Building type-safe APIs and libraries ## Core Concepts ### 1. Type Annotations Declare expected types for function parameters, return values, and variables. Generics Write reusable code that preserves type information across different types.9.5kinstalls71Workflow Orchestration PatternsDesign durable workflows with Temporal for distributed systems Covers workflow vs activity separation saga patterns state management and determinism constraints Use when building long-running processes distributed transactions or microservice orchestration name workflow-orchestration-patterns description Design durable workflows with Temporal for distributed systems Covers workflow vs activity separation saga patterns state management and determinism constraints Use when building long-running processes distributed transactions or microservice orchestration Workflow Orchestration Patterns Master workflow orchestration architecture with Temporal covering fundamental design decisions resilience patterns and best practices for building reliable distributed systems When to Use Workflow Orchestration Ideal Use Cases Source docs temporal io Multi-step processes spanning machines services databases Distributed transactions requiring all-or-nothing semantics Long-running workflows hours to years with automatic state persistence Failure recovery that must resume from last successful step Business processes bookings orders campaigns approvals Entity lifecycle management inventory tracking ac.9.5kinstalls72Llm EvaluationImplement comprehensive evaluation strategies for LLM applications using automated metrics human feedback and benchmarking Use when testing LLM performance measuring AI application quality or establishing evaluation frameworks name llm-evaluation description Implement comprehensive evaluation strategies for LLM applications using automated metrics human feedback and benchmarking Use when testing LLM performance measuring AI application quality or establishing evaluation frameworks LLM Evaluation Master comprehensive evaluation strategies for LLM applications from automated metrics to human evaluation and A B testing When to Use This Skill Measuring LLM application performance systematically Comparing different models or prompts Detecting performance regressions before deployment Validating improvements from prompt changes Building confidence in production systems Establishing baselines and tracking progress over time Debugging unexpected model behavior Core Evaluation Types 1 Automated Metrics Fast repeatable scalable evaluation using computed scores Text Generation BLEU N-gram overlap translation ROUGE Recall-oriented summarization METEOR Semantic similarity BERTScore Embedding-b.9.5kinstalls73Unity Ecs PatternsMaster Unity ECS (Entity Component System) with DOTS, Jobs, and Burst for high-performance game development. Use when building data-oriented games, optimizing performance, or working with large entity counts. --- name: unity-ecs-patterns description: Master Unity ECS (Entity Component System) with DOTS, Jobs, and Burst for high-performance game development. Use when building data-oriented games, optimizing performance, or working with large entity counts. --- # Unity ECS Patterns Production patterns for Unity's Data-Oriented Technology Stack (DOTS) including Entity Component System, Job System, and Burst Compiler. ## When to Use This Skill - Building high-performance Unity games - Managing thousands of entities efficiently - Implementing data-oriented game systems - Optimizing CPU-bound game logic - Converting OOP game code to ECS - Using Jobs and Burst for parallelization ## Core Concepts ### 1. ECS vs OOP | Aspect | Traditional OOP | ECS/DOTS | | ----------- | ----------------- | --------------- | | Data layout | Object-oriented | Data-oriented | | Memory | Scattered | Contiguous | | Processing | Per-object | Batched | | Scaling | Poor with count | Linear scaling | | Best for |.9.4kinstalls74Protocol Reverse EngineeringMaster network protocol reverse engineering including packet analysis protocol dissection and custom protocol documentation Use when analyzing network traffic understanding proprietary protocols or debugging network communication name protocol-reverse-engineering description Master network protocol reverse engineering including packet analysis protocol dissection and custom protocol documentation Use when analyzing network traffic understanding proprietary protocols or debugging network communication Protocol Reverse Engineering Comprehensive techniques for capturing analyzing and documenting network protocols for security research interoperability and debugging Traffic Capture Wireshark Capture bash Capture on specific interface wireshark i eth0 k Capture with filter wireshark i eth0 k f port 443 Capture to file tshark i eth0 w capture pcap Ring buffer capture rotate files tshark i eth0 b filesize 100000 b files 10 w capture pcap tcpdump Capture bash Basic capture tcpdump i eth0 w capture pcap With filter tcpdump i eth0 port 8080 w capture pcap Capture specific bytes tcpdump i eth0 s 0 w capture pcap Full packet Real-time display tcpdump i eth0 X port 80 Man-in-the-Middle Capture.9.4kinstalls75Memory Safety PatternsImplement memory-safe programming with RAII, ownership, smart pointers, and resource management across Rust, C++, and C. Use when writing safe systems code, managing resources, or preventing memory bugs. --- name: memory-safety-patterns description: Implement memory-safe programming with RAII, ownership, smart pointers, and resource management across Rust, C++, and C. Use when writing safe systems code, managing resources, or preventing memory bugs. --- # Memory Safety Patterns Cross-language patterns for memory-safe programming including RAII, ownership, smart pointers, and resource management. ## When to Use This Skill - Writing memory-safe systems code - Managing resources (files, sockets, memory) - Preventing use-after-free and leaks - Implementing RAII patterns - Choosing between languages for safety - Debugging memory issues ## Core Concepts ### 1. Memory Bug Categories | Bug Type | Description | Prevention | | -------------------- | -------------------------------- | ----------------- | | **Use-after-free** | Access freed memory | Ownership, RAII | | **Double-free** | Free same memory twice | Smart pointers | | **Memory leak** | Never free memory | RAII, GC | | **Buffer ove.9.3kinstalls76Helm Chart ScaffoldingDesign, organize, and manage Helm charts for templating and packaging Kubernetes applications with reusable configurations. Use when creating Helm charts, packaging Kubernetes applications, or implementing templated deployments. --- name: helm-chart-scaffolding description: Design, organize, and manage Helm charts for templating and packaging Kubernetes applications with reusable configurations. Use when creating Helm charts, packaging Kubernetes applications, or implementing templated deployments. --- # Helm Chart Scaffolding Comprehensive guidance for creating, organizing, and managing Helm charts for packaging and deploying Kubernetes applications. ## Purpose This skill provides step-by-step instructions for building production-ready Helm charts, including chart structure, templating patterns, values management, and validation strategies. ## When to Use This Skill Use this skill when you need to: - Create new Helm charts from scratch - Package Kubernetes applications for distribution - Manage multi-environment deployments with Helm - Implement templating for reusable Kubernetes manifests - Set up Helm chart repositories - Follow Helm best practices and conventions ## Detailed p.9.2kinstalls77Stride Analysis PatternsApply STRIDE methodology to systematically identify threats. Use when analyzing system security, conducting threat modeling sessions, or creating security documentation. --- name: stride-analysis-patterns description: Apply STRIDE methodology to systematically identify threats. Use when analyzing system security, conducting threat modeling sessions, or creating security documentation. --- # STRIDE Analysis Patterns Systematic threat identification using the STRIDE methodology. ## When to Use This Skill - Starting new threat modeling sessions - Analyzing existing system architecture - Reviewing security design decisions - Creating threat documentation - Training teams on threat identification - Compliance and audit preparation ## Core Concepts ### 1. STRIDE Categories ``` S - Spoofing → Authentication threats T - Tampering → Integrity threats R - Repudiation → Non-repudiation threats I - Information → Confidentiality threats Disclosure D - Denial of → Availability threats Service E - Elevation of → Authorization threats Privilege ``` ### 2. Threat Analysis Matrix | Category | Question | Control Family | | ------------------- | ----------------------------------------- | -----------.9.2kinstalls78Threat Mitigation MappingMap identified threats to appropriate security controls and mitigations Use when prioritizing security investments creating remediation plans or validating control effectiveness name threat-mitigation-mapping description Map identified threats to appropriate security controls and mitigations Use when prioritizing security investments creating remediation plans or validating control effectiveness Threat Mitigation Mapping Connect threats to controls for effective security planning When to Use This Skill Prioritizing security investments Creating remediation roadmaps Validating control coverage Designing defense-in-depth Security architecture review Risk treatment planning Core Concepts 1 Control Categories Preventive Stop attacks before they occur Firewall Input validation Detective Identify attacks in progress IDS Log monitoring Corrective Respond and recover from attacks Incident response Backup restore 2 Control Layers Layer Examples Network Firewall WAF DDoS protection Application Input validation authentication Data Encryption access controls Endpoint EDR patch management Process Security training incident response 3 Defense in Depth Perimeter Firewall WAF Network Segmentation.9.1kinstalls79Cost OptimizationOptimize cloud costs across AWS, Azure, GCP, and OCI through resource rightsizing, tagging strategies, reserved instances, and spending analysis. Use when reducing cloud expenses, analyzing infrastructure costs, or implementing cost governance policies. --- name: cost-optimization description: Optimize cloud costs across AWS, Azure, GCP, and OCI through resource rightsizing, tagging strategies, reserved instances, and spending analysis. Use when reducing cloud expenses, analyzing infrastructure costs, or implementing cost governance policies. --- # Cloud Cost Optimization Strategies and patterns for optimizing cloud costs across AWS, Azure, GCP, and OCI. ## Purpose Implement systematic cost optimization strategies to reduce cloud spending while maintaining performance and reliability. ## When to Use - Reduce cloud spending - Right-size resources - Implement cost governance - Optimize multi-cloud costs - Meet budget constraints ## Cost Optimization Framework ### 1. Visibility - Implement cost allocation tags - Use cloud cost management tools - Set up budget alerts - Create cost dashboards ### 2. Right-Sizing - Analyze resource utilization - Downsize over-provisioned resources - Use.9.1kinstalls80Gitops WorkflowImplement GitOps workflows with ArgoCD and Flux for automated, declarative Kubernetes deployments with continuous reconciliation. Use when implementing GitOps practices, automating Kubernetes deployments, or setting up declarative infrastructure management. --- name: gitops-workflow description: Implement GitOps workflows with ArgoCD and Flux for automated, declarative Kubernetes deployments with continuous reconciliation. Use when implementing GitOps practices, automating Kubernetes deployments, or setting up declarative infrastructure management. --- # GitOps Workflow Complete guide to implementing GitOps workflows with ArgoCD and Flux for automated Kubernetes deployments. ## Purpose Implement declarative, Git-based continuous delivery for Kubernetes using ArgoCD or Flux CD, following OpenGitOps principles. ## When to Use This Skill - Set up GitOps for Kubernetes clusters - Automate application deployments from Git - Implement progressive delivery strategies - Manage multi-cluster deployments - Configure automated sync policies - Set up secret management in GitOps ## OpenGitOps Principles 1. **Declarative** - Entire system described declaratively 2. **Versioned and Immutable** -.9kinstalls81Embedding StrategiesSelect and optimize embedding models for semantic search and RAG applications. Use when choosing embedding models, implementing chunking strategies, or optimizing embedding quality for specific domains. --- name: embedding-strategies description: Select and optimize embedding models for semantic search and RAG applications. Use when choosing embedding models, implementing chunking strategies, or optimizing embedding quality for specific domains. --- # Embedding Strategies Guide to selecting and optimizing embedding models for vector search applications. ## When to Use This Skill - Choosing embedding models for RAG - Optimizing chunking strategies - Fine-tuning embeddings for domains - Comparing embedding model performance - Reducing embedding dimensions - Handling multilingual content ## Core Concepts ### 1. Embedding Model Comparison (2026) | Model | Dimensions | Max Tokens | Best For | | -------------------------- | ---------- | ---------- | ----------------------------------- | | **voyage-3-large** | 1024 | 32000 | Claude apps (Anthropic recommended) | | **voyage-3** | 1024 | 32000 | Claude apps, cost-effective | | **voyage-code-3** | 1024 | 32000 | Code search | | **voyage-fin.9kinstalls82Attack Tree ConstructionBuild comprehensive attack trees to visualize threat paths Use when mapping attack scenarios identifying defense gaps or communicating security risks to stakeholders name attack-tree-construction description Build comprehensive attack trees to visualize threat paths Use when mapping attack scenarios identifying defense gaps or communicating security risks to stakeholders Attack Tree Construction Systematic attack path visualization and analysis When to Use This Skill Visualizing complex attack scenarios Identifying defense gaps and priorities Communicating risks to stakeholders Planning defensive investments Penetration test planning Security architecture review Core Concepts 1 Attack Tree Structure Root Goal Sub-goal 1 Sub-goal 2 OR node AND node Attack Attack Attack Attack leaf leaf leaf leaf 2 Node Types Type Symbol Description OR Oval Any child achieves goal AND Rectangle All children required Leaf Box Atomic attack step 3 Attack Attributes Attribute Description Values Cost Resources needed Time Duration to execute Hours Days Weeks Skill Expertise required Low Medium High Detection Likelihood of detection Low Medium High Templates and detailed worked examples Full template lib.8.9kinstalls83Billing AutomationBuild automated billing systems for recurring payments, invoicing, subscription lifecycle, and dunning management. Use when implementing subscription billing, automating invoicing, or managing recurring payment systems. --- name: billing-automation description: Build automated billing systems for recurring payments, invoicing, subscription lifecycle, and dunning management. Use when implementing subscription billing, automating invoicing, or managing recurring payment systems. --- # Billing Automation Master automated billing systems including recurring billing, invoice generation, dunning management, proration, and tax calculation. ## When to Use This Skill - Implementing SaaS subscription billing - Automating invoice generation and delivery - Managing failed payment recovery (dunning) - Calculating prorated charges for plan changes - Handling sales tax, VAT, and GST - Processing usage-based billing - Managing billing cycles and renewals ## Core Concepts ### 1. Billing Cycles **Common Intervals:** - Monthly (most common for SaaS) - Annual (discounted long-term) - Quarterly - Weekly - Custom (usage-based, per-seat) ### 2. Subscription States ``` trial → active → past_due → cancele.8.9kinstalls84Go Concurrency PatternsMaster Go concurrency with goroutines, channels, sync primitives, and context. Use when building concurrent Go applications, implementing worker pools, or debugging race conditions. --- name: go-concurrency-patterns description: Master Go concurrency with goroutines, channels, sync primitives, and context. Use when building concurrent Go applications, implementing worker pools, or debugging race conditions. --- # Go Concurrency Patterns Production patterns for Go concurrency including goroutines, channels, synchronization primitives, and context management. ## When to Use This Skill - Building concurrent Go applications - Implementing worker pools and pipelines - Managing goroutine lifecycles - Using channels for communication - Debugging race conditions - Implementing graceful shutdown ## Core Concepts ### 1. Go Concurrency Primitives | Primitive | Purpose | | ----------------- | -------------------------------- | | `goroutine` | Lightweight concurrent execution | | `channel` | Communication between goroutines | | `select` | Multiplex channel operations | | `sync.Mutex` | Mutual exclusion | | `sync.WaitGroup` | Wait for goroutines to complete | | `context.Context` | Cancellation.8.9kinstalls85Market Sizing AnalysisCalculate TAM/SAM/SOM for market opportunities using top-down, bottom-up, and value theory methodologies. Use this skill when sizing markets, estimating addressable revenue, validating market opportunity for a new venture, or building investor-ready market analysis for a startup pitch or business plan. --- name: market-sizing-analysis description: Calculate TAM/SAM/SOM for market opportunities using top-down, bottom-up, and value theory methodologies. Use this skill when sizing markets, estimating addressable revenue, validating market opportunity for a new venture, or building investor-ready market analysis for a startup pitch or business plan. version: 1.0.0 --- # Market Sizing Analysis Comprehensive market sizing methodologies for calculating Total Addressable Market (TAM), Serviceable Available Market (SAM), and Serviceable Obtainable Market (SOM) for startup opportunities. ## Overview Market sizing provides the foundation for startup strategy, fundraising, and business planning. Calculate market opportunity using three complementary methodologies: top-down (industry reports), bottom-up (customer segment calculations), and value theory (willingness to pay).8.8kinstalls86Python ConfigurationPython configuration management via environment variables and typed settings. Use when externalizing config, setting up pydantic-settings, managing secrets, or implementing environment-specific behavior. --- name: python-configuration description: Python configuration management via environment variables and typed settings. Use when externalizing config, setting up pydantic-settings, managing secrets, or implementing environment-specific behavior. --- # Python Configuration Management Externalize configuration from code using environment variables and typed settings. Well-managed configuration enables the same code to run in any environment without modification. ## When to Use This Skill - Setting up a new project's configuration system - Migrating from hardcoded values to environment variables - Implementing pydantic-settings for typed configuration - Managing secrets and sensitive values - Creating environment-specific settings (dev/staging/prod) - Validating configuration at application startup ## Core Concepts ### 1. Externalized Configuration All environment-specific values (URLs, secrets, feature flags) come from environment variables, not code. Typed Settings Parse and vali.8.8kinstalls87Python ObservabilityPython observability patterns including structured logging, metrics, and distributed tracing. Use when adding logging, implementing metrics collection, setting up tracing, or debugging production systems. --- name: python-observability description: Python observability patterns including structured logging, metrics, and distributed tracing. Use when adding logging, implementing metrics collection, setting up tracing, or debugging production systems. --- # Python Observability Instrument Python applications with structured logs, metrics, and traces. When something breaks in production, you need to answer "what, where, and why" without deploying new code. ## When to Use This Skill - Adding structured logging to applications - Implementing metrics collection with Prometheus - Setting up distributed tracing across services - Propagating correlation IDs through request chains - Debugging production issues - Building observability dashboards ## Core Concepts ### 1. Structured Logging Emit logs as JSON with consistent fields for production environments. Machine-readable logs enable powerful queries and alerts. For local development, consider human-readable formats.8.8kinstalls88Prometheus ConfigurationSet up Prometheus for comprehensive metric collection, storage, and monitoring of infrastructure and applications. Use when implementing metrics collection, setting up monitoring infrastructure, or configuring alerting systems. --- name: prometheus-configuration description: Set up Prometheus for comprehensive metric collection, storage, and monitoring of infrastructure and applications. Use when implementing metrics collection, setting up monitoring infrastructure, or configuring alerting systems. --- # Prometheus Configuration Complete guide to Prometheus setup, metric collection, scrape configuration, and recording rules. ## Purpose Configure Prometheus for comprehensive metric collection, alerting, and monitoring of infrastructure and applications. ## When to Use - Set up Prometheus monitoring - Configure metric scraping - Create recording rules - Design alert rules - Implement service discovery ## Detailed patterns and worked examples Detailed pattern documentation lives in `references/details.md`. Read that file when the navigation tier above is insufficient. **Use consistent naming** for metrics (prefix_name_unit) 2. **Set appropriate scrape intervals** (15-60s typical) 3.8.7kinstalls89Context Driven Development>- --- name: context-driven-development description: >- Creates and maintains project context artifacts (product.md, tech-stack.md, workflow.md, tracks.md) in a `conductor/` directory. Scaffolds new projects from scratch, extracts context from existing codebases, validates artifact consistency before implementation, and synchronizes documents as the project evolves. Use when setting up a project, creating or updating product docs, managing a tech stack file, defining development workflows, tracking work units, onboarding to an existing codebase, or running project scaffolding. version: 1.0.0 --- # Context-Driven Development Guide for implementing and maintaining context as a managed artifact alongside code, enabling consistent AI interactions and team alignment through structured project documentation. ## When to Use This Skill - Setting up new projects with Conductor - Understanding the relationship between context artifacts - Maintaining consistency across AI-assisted development sessions - Onboarding team members to an existing Conductor project - Deciding when to update context documents - Managing greenfield vs brownfield project contexts ## Detailed patterns and worked examp.8.7kinstalls90Startup Metrics FrameworkTrack, calculate, and optimize key performance metrics for SaaS, marketplace, consumer, and B2B startups from seed through Series A, including unit economics, growth efficiency, and cash management. Use this skill when defining a metrics framework, calculating CAC/LTV/burn multiple, benchmarking business health, or preparing metrics dashboards for investors or board reporting. --- name: startup-metrics-framework description: Track, calculate, and optimize key performance metrics for SaaS, marketplace, consumer, and B2B startups from seed through Series A, including unit economics, growth efficiency, and cash management. Use this skill when defining a metrics framework, calculating CAC/LTV/burn multiple, benchmarking business health, or preparing metrics dashboards for investors or board reporting. version: 1.0.0 --- # Startup Metrics Framework Comprehensive guide to tracking, calculating, and optimizing key performance metrics for different startup business models from seed through Series A. ## Overview Track the right metrics at the right stage.8.7kinstalls91Data Quality FrameworksImplement data quality validation with Great Expectations, dbt tests, and data contracts. Use when building data quality pipelines, implementing validation rules, or establishing data contracts. --- name: data-quality-frameworks description: Implement data quality validation with Great Expectations, dbt tests, and data contracts. Use when building data quality pipelines, implementing validation rules, or establishing data contracts. --- # Data Quality Frameworks Production patterns for implementing data quality with Great Expectations, dbt tests, and data contracts to ensure reliable data pipelines. ## When to Use This Skill - Implementing data quality checks in pipelines - Setting up Great Expectations validation - Building comprehensive dbt test suites - Establishing data contracts between teams - Monitoring data quality metrics - Automating data validation in CI/CD ## Core Concepts ### 1. Data Quality Dimensions | Dimension | Description | Example Check | | ---------------- | ------------------------ | -------------------------------------------------- | | **Completeness** | No missing values | `expect_column_values_to_not_be_null` | | **Uniqueness** | No duplicates | `expect_c.8.7kinstalls92Memory ForensicsMaster memory forensics techniques including memory acquisition process analysis and artifact extraction using Volatility and related tools Use when analyzing memory dumps investigating incidents or performing malware analysis from RAM captures name memory-forensics description Master memory forensics techniques including memory acquisition process analysis and artifact extraction using Volatility and related tools Use when analyzing memory dumps investigating incidents or performing malware analysis from RAM captures Memory Forensics Comprehensive techniques for acquiring analyzing and extracting artifacts from memory dumps for incident response and malware analysis When to Use This Skill Performing memory analysis during incident response or breach investigation Extracting malware artifacts processes injected code network connections from a RAM capture Acquiring volatile memory from a live Windows Linux macOS system before shutdown Using Volatility 3 Rekall to triage memory dumps Recovering credentials browser sessions or open files from process memory Memory Acquisition Live Acquisition Tools Windows powershell WinPmem Recommended winpmem_mini_x64 exe memory raw DumpIt DumpIt e.8.7kinstalls93K8s Manifest GeneratorCreate production-ready Kubernetes manifests for Deployments Services ConfigMaps and Secrets following best practices and security standards Use when generating Kubernetes YAML manifests creating K8s resources or implementing production-grade Kubernetes configurations name k8s-manifest-generator description Create production-ready Kubernetes manifests for Deployments Services ConfigMaps and Secrets following best practices and security standards Use when generating Kubernetes YAML manifests creating K8s resources or implementing production-grade Kubernetes configurations Kubernetes Manifest Generator Step-by-step guidance for creating production-ready Kubernetes manifests including Deployments Services ConfigMaps Secrets and PersistentVolumeClaims Purpose This skill provides comprehensive guidance for generating well-structured secure and production-ready Kubernetes manifests following cloud-native best practices and Kubernetes conventions When to Use This Skill Use this skill when you need to Create new Kubernetes Deployment manifests Define Service resources for network connectivity Generate ConfigMap and Secret resources for configuration management Create PersistentVolumeClaim.8.7kinstalls94Dependency UpgradeManage major dependency version upgrades with compatibility analysis staged rollout and comprehensive testing Use when upgrading framework versions updating major dependencies or managing breaking changes in libraries name dependency-upgrade description Manage major dependency version upgrades with compatibility analysis staged rollout and comprehensive testing Use when upgrading framework versions updating major dependencies or managing breaking changes in libraries Dependency Upgrade Master major dependency version upgrades compatibility analysis staged upgrade strategies and comprehensive testing approaches When to Use This Skill Upgrading major framework versions Updating security-vulnerable dependencies Modernizing legacy dependencies Resolving dependency conflicts Planning incremental upgrade paths Testing compatibility matrices Automating dependency updates Semantic Versioning Review MAJOR MINOR PATCH e g 2 3 1 MAJOR Breaking changes MINOR New features backward compatible PATCH Bug fixes backward compatible 2 3 1 2 3 1 3 0 0 minor updates 2 3 1 2 3 1 2 4 0 patch updates 2 3 1 exact version Dependency Analysis Audit Dependencies bash npm npm outdated npm audit npm audit fix.8.7kinstalls95Cqrs ImplementationImplement Command Query Responsibility Segregation for scalable architectures. Use when separating read and write models, optimizing query performance, or building event-sourced systems. --- name: cqrs-implementation description: Implement Command Query Responsibility Segregation for scalable architectures. Use when separating read and write models, optimizing query performance, or building event-sourced systems. --- # CQRS Implementation Comprehensive guide to implementing CQRS (Command Query Responsibility Segregation) patterns. ## When to Use This Skill - Separating read and write concerns - Scaling reads independently from writes - Building event-sourced systems - Optimizing complex query scenarios - Different read/write data models needed - High-performance reporting requirements ## Core Concepts ### 1. CQRS Architecture ``` ┌─────────────┐ │ Client │ └──────┬──────┘ │ ┌────────────┴────────────┐ │ │ ▼ ▼ ┌─────────────┐ ┌─────────────┐ │ Commands │ │ Queries │ │ API │ │ API │ └──────┬──────┘ └──────┬──────┘ │ │ ▼ ▼ ┌─────────────┐ ┌─────────────┐ │ Command │ │ Query │ │ Handlers │ │ Handlers │ └──────┬──────┘ └──────┬──────┘ │ │ ▼ ▼ ┌─────────────┐ ┌─────────────┐ │ Write │──.8.6kinstalls96Dbt Transformation PatternsMaster dbt (data build tool) for analytics engineering with model organization, testing, documentation, and incremental strategies. Use when building data transformations, creating data models, or implementing analytics engineering best practices. --- name: dbt-transformation-patterns description: Master dbt (data build tool) for analytics engineering with model organization, testing, documentation, and incremental strategies. Use when building data transformations, creating data models, or implementing analytics engineering best practices. --- # dbt Transformation Patterns Production-ready patterns for dbt (data build tool) including model organization, testing strategies, documentation, and incremental processing. ## When to Use This Skill - Building data transformation pipelines with dbt - Organizing models into staging, intermediate, and marts layers - Implementing data quality tests - Creating incremental models for large datasets - Documenting data models and lineage - Setting up dbt project structure ## Core Concepts ### 1. Model Layers (Medallion Architecture) ``` sources/ Raw data definitions ↓ staging/ 1:1 with source, light cleaning ↓ intermediate/ Business logic, joins.8.6kinstalls97Airflow Dag PatternsBuild production Apache Airflow DAGs with best practices for operators sensors testing and deployment Use when creating data pipelines orchestrating workflows or scheduling batch jobs name airflow-dag-patterns description Build production Apache Airflow DAGs with best practices for operators sensors testing and deployment Use when creating data pipelines orchestrating workflows or scheduling batch jobs Apache Airflow DAG Patterns Production-ready patterns for Apache Airflow including DAG design operators sensors testing and deployment strategies When to Use This Skill Creating data pipeline orchestration with Airflow Designing DAG structures and dependencies Implementing custom operators and sensors Testing Airflow DAGs locally Setting up Airflow in production Debugging failed DAG runs Core Concepts 1 DAG Design Principles Principle Description Idempotent Running twice produces same result Atomic Tasks succeed or fail completely Incremental Process only new changed data Observable Logs metrics alerts at every step 2 Task Dependencies python Linear task1 task2 task3 Fan-out task1 task2 task3 task4 Fan-in task1 task2 task3 task4 Complex task1 task2 task4 task1 task3 task4 Quick Star.8.6kinstalls98Python ResiliencePython resilience patterns including automatic retries, exponential backoff, timeouts, and fault-tolerant decorators. Use when adding retry logic, implementing timeouts, building fault-tolerant services, or handling transient failures. --- name: python-resilience description: Python resilience patterns including automatic retries, exponential backoff, timeouts, and fault-tolerant decorators. Use when adding retry logic, implementing timeouts, building fault-tolerant services, or handling transient failures. --- # Python Resilience Patterns Build fault-tolerant Python applications that gracefully handle transient failures, network issues, and service outages. Resilience patterns keep systems running when dependencies are unreliable. ## When to Use This Skill - Adding retry logic to external service calls - Implementing timeouts for network operations - Building fault-tolerant microservices - Handling rate limiting and backpressure - Creating infrastructure decorators - Designing circuit breakers ## Core Concepts ### 1. Transient vs Permanent Failures Retry transient errors (network timeouts, temporary service issues). Don't retry permanent errors (invalid credentials, bad requests).8.6kinstalls99Temporal Python TestingTest Temporal workflows with pytest, time-skipping, and mocking strategies. Covers unit testing, integration testing, replay testing, and local development setup. Use when implementing Temporal workflow tests or debugging test failures. --- name: temporal-python-testing description: Test Temporal workflows with pytest, time-skipping, and mocking strategies. Covers unit testing, integration testing, replay testing, and local development setup. Use when implementing Temporal workflow tests or debugging test failures. --- # Temporal Python Testing Strategies Comprehensive testing approaches for Temporal workflows using pytest, progressive disclosure resources for specific testing scenarios. ## When to Use This Skill - **Unit testing workflows** - Fast tests with time-skipping - **Integration testing** - Workflows with mocked activities - **Replay testing** - Validate determinism against production histories - **Local development** - Set up Temporal server and pytest - **CI/CD integration** - Automated testing pipelines - **Coverage strategies** - Achieve ≥80% test coverage ## Testing Philosophy **Recommended Approach** (Source: docs.temporal.io/develop/python/testing-suite): - Write.8.5kinstalls100Competitive LandscapeAnalyze competition, identify differentiation opportunities, and develop winning market positioning strategies using Porter's Five Forces, Blue Ocean Strategy, and positioning maps. Use this skill when evaluating competitors, assessing market positioning, identifying sustainable competitive advantages, or preparing competitive strategy analysis for a startup or investor pitch. --- name: competitive-landscape description: Analyze competition, identify differentiation opportunities, and develop winning market positioning strategies using Porter's Five Forces, Blue Ocean Strategy, and positioning maps. Use this skill when evaluating competitors, assessing market positioning, identifying sustainable competitive advantages, or preparing competitive strategy analysis for a startup or investor pitch. version: 1.0.0 --- # Competitive Landscape Analysis Comprehensive frameworks for analyzing competition, identifying differentiation opportunities, and developing winning market positioning strategies. ## Overview Understand competitive dynamics using proven frameworks (Porter's Five Forces, Blue Ocean Strategy, positioning maps) to identify opportunities and craft defensible competitive adva.8.5kinstalls101Risk Metrics CalculationCalculate portfolio risk metrics including VaR, CVaR, Sharpe, Sortino, and drawdown analysis. Use when measuring portfolio risk, implementing risk limits, or building risk monitoring systems. --- name: risk-metrics-calculation description: Calculate portfolio risk metrics including VaR, CVaR, Sharpe, Sortino, and drawdown analysis. Use when measuring portfolio risk, implementing risk limits, or building risk monitoring systems. --- # Risk Metrics Calculation Comprehensive risk measurement toolkit for portfolio management, including Value at Risk, Expected Shortfall, and drawdown analysis. ## When to Use This Skill - Measuring portfolio risk - Implementing risk limits - Building risk dashboards - Calculating risk-adjusted returns - Setting position sizes - Regulatory reporting ## Core Concepts ### 1. Risk Metric Categories | Category | Metrics | Use Case | | ----------------- | --------------- | -------------------- | | **Volatility** | Std Dev, Beta | General risk | | **Tail Risk** | VaR, CVaR | Extreme losses | | **Drawdown** | Max DD, Calmar | Capital preservation | | **Risk-Adjusted** | Sharpe, Sortino | Performance | ### 2. Time Horizons ``` Intraday: Minute/hourly VaR for day.8.5kinstalls102Ml Pipeline WorkflowBuild end-to-end MLOps pipelines from data preparation through model training, validation, and production deployment. Use when creating ML pipelines, implementing MLOps practices, or automating model training and deployment workflows. --- name: ml-pipeline-workflow description: Build end-to-end MLOps pipelines from data preparation through model training, validation, and production deployment. Use when creating ML pipelines, implementing MLOps practices, or automating model training and deployment workflows. --- # ML Pipeline Workflow Complete end-to-end MLOps pipeline orchestration from data preparation through model deployment. ## Overview This skill provides comprehensive guidance for building production ML pipelines that handle the full lifecycle: data ingestion → preparation → training → validation → deployment → monitoring. ## When to Use This Skill - Building new ML pipelines from scratch - Designing workflow orchestration for ML systems - Implementing data → model → deployment automation - Setting up reproducible training workflows - Creating DAG-based ML orchestration - Integrating ML components into production systems ## What This Skill Provides ### Core Capabilities 1.8.5kinstalls103Shellcheck ConfigurationMaster ShellCheck static analysis configuration and usage for shell script quality. Use when setting up linting infrastructure, fixing code issues, or ensuring script portability. --- name: shellcheck-configuration description: Master ShellCheck static analysis configuration and usage for shell script quality. Use when setting up linting infrastructure, fixing code issues, or ensuring script portability. --- # ShellCheck Configuration and Static Analysis Comprehensive guidance for configuring and using ShellCheck to improve shell script quality, catch common pitfalls, and enforce best practices through static code analysis. ## When to Use This Skill - Setting up linting for shell scripts in CI/CD pipelines - Analyzing existing shell scripts for issues - Understanding ShellCheck error codes and warnings - Configuring ShellCheck for specific project requirements - Integrating ShellCheck into development workflows - Suppressing false positives and configuring rule sets - Enforcing consistent code quality standards - Migrating scripts to meet quality gates ## Detailed patterns and worked examples Detailed pattern documentation lives in `references/details.md`.8.5kinstalls104Angular MigrationMigrate from AngularJS to Angular using hybrid mode, incremental component rewriting, and dependency injection updates. Use when upgrading AngularJS applications, planning framework migrations, or modernizing legacy Angular code. --- name: angular-migration description: Migrate from AngularJS to Angular using hybrid mode, incremental component rewriting, and dependency injection updates. Use when upgrading AngularJS applications, planning framework migrations, or modernizing legacy Angular code. --- # Angular Migration Master AngularJS to Angular migration, including hybrid apps, component conversion, dependency injection changes, and routing migration. ## When to Use This Skill - Migrating AngularJS (1.x) applications to Angular (2+) - Running hybrid AngularJS/Angular applications - Converting directives to components - Modernizing dependency injection - Migrating routing systems - Updating to latest Angular versions - Implementing Angular best practices ## Migration Strategies ### 1. Big Bang (Complete Rewrite) - Rewrite entire app in Angular - Parallel development - Switch over at once - **Best for:** Small apps, green field projects ### 2.8.5kinstalls105Python Background JobsPython background job patterns including task queues, workers, and event-driven architecture. Use when implementing async task processing, job queues, long-running operations, or decoupling work from request/response cycles. --- name: python-background-jobs description: Python background job patterns including task queues, workers, and event-driven architecture. Use when implementing async task processing, job queues, long-running operations, or decoupling work from request/response cycles. --- # Python Background Jobs & Task Queues Decouple long-running or unreliable work from request/response cycles. Return immediately to the user while background workers handle the heavy lifting asynchronously. ## When to Use This Skill - Processing tasks that take longer than a few seconds - Sending emails, notifications, or webhooks - Generating reports or exporting data - Processing uploads or media transformations - Integrating with unreliable external services - Building event-driven architectures ## Core Concepts ### 1. Task Queue Pattern API accepts request, enqueues a job, returns immediately with a job ID.8.5kinstalls106Event Store DesignDesign and implement event stores for event-sourced systems Use when building event sourcing infrastructure choosing event store technologies or implementing event persistence patterns name event-store-design description Design and implement event stores for event-sourced systems Use when building event sourcing infrastructure choosing event store technologies or implementing event persistence patterns Event Store Design Comprehensive guide to designing event stores for event-sourced applications When to Use This Skill Designing event sourcing infrastructure Choosing between event store technologies Implementing custom event stores Optimizing event storage and retrieval Setting up event store schemas Planning for event store scaling Core Concepts 1 Event Store Architecture Event Store Stream 1 Stream 2 Stream 3 Aggregate Aggregate Aggregate Event 1 Event 1 Event 1 Event 2 Event 2 Event 2 Event 3 Event 4 Global Position 1 2 3 4 5 6 2 Event Store Requirements Requirement Description Append-only Events are immutable only appends Ordered Per-stream and global ordering Versioned Optimistic concurrency control Subscriptions Real-time event notifications Idempotent Handle duplicate write.8.5kinstalls107Web3 TestingTest smart contracts comprehensively using Hardhat and Foundry with unit tests integration tests and mainnet forking Use when testing Solidity contracts setting up blockchain test suites or validating DeFi protocols name web3-testing description Test smart contracts comprehensively using Hardhat and Foundry with unit tests integration tests and mainnet forking Use when testing Solidity contracts setting up blockchain test suites or validating DeFi protocols Web3 Smart Contract Testing Master comprehensive testing strategies for smart contracts using Hardhat Foundry and advanced testing patterns When to Use This Skill Writing unit tests for smart contracts Setting up integration test suites Performing gas optimization testing Fuzzing for edge cases Forking mainnet for realistic testing Automating test coverage reporting Verifying contracts on Etherscan Hardhat Testing Setup javascript hardhat config js require nomicfoundation hardhat-toolbox require nomiclabs hardhat-etherscan require hardhat-gas-reporter require solidity-coverage module exports solidity version 0 8 19 settings optimizer enabled true runs 200 networks hardhat forking url process env MAINNET_RPC_URL blockNumber 1500.8.4kinstalls108Incident Runbook TemplatesCreate structured incident response runbooks with step-by-step procedures, escalation paths, and recovery actions. Use this skill when building a service outage runbook for a payment processing system; creating database incident procedures covering connection pool exhaustion, replication lag, and disk space alerts; onboarding new on-call engineers who need step-by-step recovery guides written for --- name: incident-runbook-templates description: Create structured incident response runbooks with step-by-step procedures, escalation paths, and recovery actions. Use this skill when building a service outage runbook for a payment processing system; creating database incident procedures covering connection pool exhaustion, replication lag, and disk space alerts; onboarding new on-call engineers who need step-by-step recovery guides written for a 3 AM brain; or standardizing escalation matrices across multiple engineering teams. --- # Incident Runbook Templates Production-ready templates for incident response runbooks covering detection, triage, mitigation, resolution, and communication. ## When to Use This Skill - Creating incident response procedures - Building service-specific runbook.8.4kinstalls109Nx Workspace PatternsConfigure and optimize Nx monorepo workspaces. Use when setting up Nx, configuring project boundaries, optimizing build caching, or implementing affected commands. --- name: nx-workspace-patterns description: Configure and optimize Nx monorepo workspaces. Use when setting up Nx, configuring project boundaries, optimizing build caching, or implementing affected commands. --- # Nx Workspace Patterns Production patterns for Nx monorepo management. ## When to Use This Skill - Setting up new Nx workspaces - Configuring project boundaries - Optimizing CI with affected commands - Implementing remote caching - Managing dependencies between projects - Migrating to Nx ## Core Concepts ### 1. Nx Architecture ``` workspace/ ├── apps/ # Deployable applications │ ├── web/ │ └── api/ ├── libs/ # Shared libraries │ ├── shared/ │ │ ├── ui/ │ │ └── utils/ │ └── feature/ │ ├── auth/ │ └── dashboard/ ├── tools/ # Custom executors/generators ├── nx.json # Nx configuration └── workspace.json # Project configuration ``` ### 2. Library Types | Type | Purpose | Example | | --------------- | -------------------------------- | ------------------- | | **feature** | Smart components, business logic | `feature.8.4kinstalls110Workflow PatternsUse this skill when implementing tasks according to Conductor's TDD workflow, handling phase checkpoints, managing git commits for tasks, or understanding the verification protocol. --- name: workflow-patterns description: Use this skill when implementing tasks according to Conductor's TDD workflow, handling phase checkpoints, managing git commits for tasks, or understanding the verification protocol. version: 1.0.0 --- # Workflow Patterns Guide for implementing tasks using Conductor's TDD workflow, managing phase checkpoints, handling git commits, and executing the verification protocol that ensures quality throughout implementation. ## When to Use This Skill - Implementing tasks from a track's plan.md - Following TDD red-green-refactor cycle - Completing phase checkpoints - Managing git commits and notes - Understanding quality assurance gates - Handling verification protocols - Recording progress in plan files ## Detailed patterns and worked examples Detailed pattern documentation lives in `references/details.md`. Read that file when the navigation tier above is insufficient.8.4kinstalls111Python Resource ManagementPython resource management with context managers, cleanup patterns, and streaming. Use when managing connections, file handles, implementing cleanup logic, or building streaming responses with accumulated state. --- name: python-resource-management description: Python resource management with context managers, cleanup patterns, and streaming. Use when managing connections, file handles, implementing cleanup logic, or building streaming responses with accumulated state. --- # Python Resource Management Manage resources deterministically using context managers. Resources like database connections, file handles, and network sockets should be released reliably, even when exceptions occur. ## When to Use This Skill - Managing database connections and connection pools - Working with file handles and I/O - Implementing custom context managers - Building streaming responses with state - Handling nested resource cleanup - Creating async context managers ## Core Concepts ### 1. Context Managers The `with` statement ensures resources are released automatically, even on exceptions. Protocol Methods `__enter__`/`__exit__` for sync, `__aenter__`/`__aexit__` for async resource management.8.4kinstalls112Hybrid Search ImplementationCombine vector and keyword search for improved retrieval. Use when implementing RAG systems, building search engines, or when neither approach alone provides sufficient recall. --- name: hybrid-search-implementation description: Combine vector and keyword search for improved retrieval. Use when implementing RAG systems, building search engines, or when neither approach alone provides sufficient recall. --- # Hybrid Search Implementation Patterns for combining vector similarity and keyword-based search. ## When to Use This Skill - Building RAG systems with improved recall - Combining semantic understanding with exact matching - Handling queries with specific terms (names, codes) - Improving search for domain-specific vocabulary - When pure vector search misses keyword matches ## Core Concepts ### 1. Hybrid Search Architecture ``` Query → ┬─► Vector Search ──► Candidates ─┐ │ │ └─► Keyword Search ─► Candidates ─┴─► Fusion ─► Results ``` ### 2. Fusion Methods | Method | Description | Best For | | ----------------- | ------------------------ | --------------- | | **RRF** | Reciprocal Rank Fusion | General purpose | | **Linear** | Weighted sum of scores | Tunable balance | | **Cross-en.8.4kinstalls113Multi Cloud ArchitectureDesign multi-cloud architectures using a decision framework to select and integrate services across AWS Azure GCP and OCI Use when building multi-cloud systems avoiding vendor lock-in or leveraging best-of-breed services from multiple providers name multi-cloud-architecture description Design multi-cloud architectures using a decision framework to select and integrate services across AWS Azure GCP and OCI Use when building multi-cloud systems avoiding vendor lock-in or leveraging best-of-breed services from multiple providers Multi-Cloud Architecture Decision framework and patterns for architecting applications across AWS Azure GCP and OCI Purpose Design cloud-agnostic architectures and make informed decisions about service selection across cloud providers When to Use Design multi-cloud strategies Migrate between cloud providers Select cloud services for specific workloads Implement cloud-agnostic architectures Optimize costs across providers Cloud Service Comparison Compute Services AWS Azure GCP OCI Use Case EC2 Virtual Machines Compute Engine Compute IaaS VMs ECS Container Instances Cloud Run Container Instances Containers EKS AKS GKE OKE Kubernetes Lambda Functions Cloud Funct.8.4kinstalls114Similarity Search PatternsImplement efficient similarity search with vector databases. Use when building semantic search, implementing nearest neighbor queries, or optimizing retrieval performance. --- name: similarity-search-patterns description: Implement efficient similarity search with vector databases. Use when building semantic search, implementing nearest neighbor queries, or optimizing retrieval performance. --- # Similarity Search Patterns Patterns for implementing efficient similarity search in production systems. ## When to Use This Skill - Building semantic search systems - Implementing RAG retrieval - Creating recommendation engines - Optimizing search latency - Scaling to millions of vectors - Combining semantic and keyword search ## Core Concepts ### 1. Distance Metrics | Metric | Formula | Best For | | ------------------ | ------------------ | --------------------- | --- | -------------- | | **Cosine** | 1 - (A·B)/(‖A‖‖B‖) | Normalized embeddings | | **Euclidean (L2)** | √Σ(a-b)² | Raw embeddings | | **Dot Product** | A·B | Magnitude matters | | **Manhattan (L1)** | Σ | a-b | | Sparse vectors | ### 2. Index Types ``` ┌─────────────────────────────────────────────────┐ │ Index Types │ ├─────.8.4kinstalls115Vector Index TuningOptimize vector index performance for latency, recall, and memory. Use when tuning HNSW parameters, selecting quantization strategies, or scaling vector search infrastructure. --- name: vector-index-tuning description: Optimize vector index performance for latency, recall, and memory. Use when tuning HNSW parameters, selecting quantization strategies, or scaling vector search infrastructure. --- # Vector Index Tuning Guide to optimizing vector indexes for production performance. ## When to Use This Skill - Tuning HNSW parameters - Implementing quantization - Optimizing memory usage - Reducing search latency - Balancing recall vs speed - Scaling to billions of vectors ## Core Concepts ### 1. Index Type Selection ``` Data Size Recommended Index ──────────────────────────────────────── < 10K vectors → Flat (exact search) 10K - 1M → HNSW 1M - 100M → HNSW + Quantization > 100M → IVF + PQ or DiskANN ``` ### 2. HNSW Parameters | Parameter | Default | Effect | | ------------------ | ------- | ---------------------------------------------------- | | **M** | 16 | Connections per node, ↑ = better recall, more memory | | **efConstruction** | 100 | Build quality, ↑ = better index, slower build.8.3kinstalls116Distributed TracingImplement distributed tracing with Jaeger and Tempo to track requests across microservices and identify performance bottlenecks. Use when debugging microservices, analyzing request flows, or implementing observability for distributed systems. --- name: distributed-tracing description: Implement distributed tracing with Jaeger and Tempo to track requests across microservices and identify performance bottlenecks. Use when debugging microservices, analyzing request flows, or implementing observability for distributed systems. --- # Distributed Tracing Implement distributed tracing with Jaeger and Tempo for request flow visibility across microservices. ## Purpose Track requests across distributed systems to understand latency, dependencies, and failure points. ## When to Use - Debug latency issues - Understand service dependencies - Identify bottlenecks - Trace error propagation - Analyze request paths ## Detailed patterns and worked examples Detailed pattern documentation lives in `references/details.md`. Read that file when the navigation tier above is insufficient. **Sample appropriately** (1-10% in production) 2. **Add meaningful tags** (user_id, request_id) 3.8.3kinstalls117Binary Analysis PatternsMaster binary analysis patterns including disassembly, decompilation, control flow analysis, and code pattern recognition. Use when analyzing executables, understanding compiled code, or performing static analysis on binaries. --- name: binary-analysis-patterns description: Master binary analysis patterns including disassembly, decompilation, control flow analysis, and code pattern recognition. Use when analyzing executables, understanding compiled code, or performing static analysis on binaries. --- # Binary Analysis Patterns Comprehensive patterns and techniques for analyzing compiled binaries, understanding assembly code, and reconstructing program logic. ## When to Use This Skill - Reverse-engineering an unknown executable to understand its behavior - Analyzing malware or obfuscated binaries with Ghidra / IDA Pro / Binary Ninja - Recognizing common assembly idioms (function prologues, switch tables, vtable dispatch) - Reconstructing high-level control flow from compiled code - Identifying compiler-introduced patterns (stack canaries, PIC trampolines) ## Detailed section: Disassembly Fundamentals Originally a 2047-byte section in this SKILL.md. Moved to `references/details.md`.8.3kinstalls118Spark OptimizationOptimize Apache Spark jobs with partitioning caching shuffle optimization and memory tuning Use when improving Spark performance debugging slow jobs or scaling data processing pipelines name spark-optimization description Optimize Apache Spark jobs with partitioning caching shuffle optimization and memory tuning Use when improving Spark performance debugging slow jobs or scaling data processing pipelines Apache Spark Optimization Production patterns for optimizing Apache Spark jobs including partitioning strategies memory management shuffle optimization and performance tuning When to Use This Skill Optimizing slow Spark jobs Tuning memory and executor configuration Implementing efficient partitioning strategies Debugging Spark performance issues Scaling Spark pipelines for large datasets Reducing shuffle and data skew Core Concepts 1 Spark Execution Model Driver Program Job triggered by action Stages separated by shuffles Tasks one per partition 2 Key Performance Factors Factor Impact Solution Shuffle Network I O disk I O Minimize wide transformations Data Skew Uneven task duration Salting broadcast joins Serialization CPU overhead Use Kryo columnar formats Memory GC pressure spil.8.3kinstalls119Saga OrchestrationImplement saga patterns for distributed transactions and cross-aggregate workflows. Use this skill when implementing distributed transactions across microservices where 2PC is unavailable, designing compensating actions for failed order workflows that span inventory, payment, and shipping services, building event-driven saga coordinators for travel booking systems that must roll back hotel, flight --- name: saga-orchestration description: Implement saga patterns for distributed transactions and cross-aggregate workflows. Use this skill when implementing distributed transactions across microservices where 2PC is unavailable, designing compensating actions for failed order workflows that span inventory, payment, and shipping services, building event-driven saga coordinators for travel booking systems that must roll back hotel, flight, and car rental reservations atomically, or debugging stuck saga states in production where compensation steps never complete. --- # Saga Orchestration Patterns for managing distributed transactions and long-running business processes without two-phase commit. ## Inputs and Outputs **What you provide:** - Service boundaries and ownership (which service.8.3kinstalls120Anti Reversing TechniquesUnderstand anti-reversing, obfuscation, and protection techniques encountered during software analysis. Use this skill when analyzing malware evasion techniques, when implementing anti-debugging protections for CTF challenges, when reverse engineering packed binaries, or when building security research tools that need to detect virtualized environments. --- name: anti-reversing-techniques description: Understand anti-reversing, obfuscation, and protection techniques encountered during software analysis. Use this skill when analyzing malware evasion techniques, when implementing anti-debugging protections for CTF challenges, when reverse engineering packed binaries, or when building security research tools that need to detect virtualized environments. --- > **AUTHORIZED USE ONLY**: This skill contains dual-use security techniques. Before proceeding with any bypass or analysis: > > 1. **Verify authorization**: Confirm you have explicit written permission from the software owner, or are operating within a legitimate security context (CTF, authorized pentest, malware analysis, security research) > 2. **Document scope**: Ensure your activities fall within the defined scope of your auth.8.3kinstalls121Paypal IntegrationIntegrate PayPal payment processing with support for express checkout, subscriptions, and refund management. Use when implementing PayPal payments, processing online transactions, or building e-commerce checkout flows. --- name: paypal-integration description: Integrate PayPal payment processing with support for express checkout, subscriptions, and refund management. Use when implementing PayPal payments, processing online transactions, or building e-commerce checkout flows. --- # PayPal Integration Master PayPal payment integration including Express Checkout, IPN handling, recurring billing, and refund workflows. ## When to Use This Skill - Integrating PayPal as a payment option - Implementing express checkout flows - Setting up recurring billing with PayPal - Processing refunds and payment disputes - Handling PayPal webhooks (IPN) - Supporting international payments - Implementing PayPal subscriptions ## Core Concepts ### 1. Payment Products **PayPal Checkout** - One-time payments - Express checkout experience - Guest and PayPal account payments **PayPal Subscriptions** - Recurring billing - Subscription plans - Automatic renewals **PayPal Payouts** - Send money to multiple reci.8.3kinstalls122Hybrid Cloud NetworkingConfigure secure high-performance connectivity between on-premises infrastructure and cloud platforms using VPN and dedicated connections Use when building hybrid cloud architectures connecting data centers to cloud or implementing secure cross-premises networking name hybrid-cloud-networking description Configure secure high-performance connectivity between on-premises infrastructure and cloud platforms using VPN and dedicated connections Use when building hybrid cloud architectures connecting data centers to cloud or implementing secure cross-premises networking Hybrid Cloud Networking Configure secure high-performance connectivity between on-premises and cloud environments using VPN Direct Connect ExpressRoute Interconnect and FastConnect Purpose Establish secure reliable network connectivity between on-premises data centers and cloud providers AWS Azure GCP OCI When to Use Connect on-premises to cloud Extend datacenter to cloud Implement hybrid active-active setups Meet compliance requirements Migrate to cloud gradually Connection Options AWS Connectivity 1 Site-to-Site VPN IPSec VPN over internet Up to 1 25 Gbps per tunnel Cost-effective for moderate bandwidth Higher latency.8.3kinstalls123Sast ConfigurationConfigure Static Application Security Testing (SAST) tools for automated vulnerability detection in application code. Use when setting up security scanning, implementing DevSecOps practices, or automating code vulnerability detection. --- name: sast-configuration description: Configure Static Application Security Testing (SAST) tools for automated vulnerability detection in application code. Use when setting up security scanning, implementing DevSecOps practices, or automating code vulnerability detection. --- # SAST Configuration Static Application Security Testing (SAST) tool setup, configuration, and custom rule creation for comprehensive security scanning across multiple programming languages. ## Overview This skill provides comprehensive guidance for setting up and configuring SAST tools including Semgrep, SonarQube, and CodeQL. Use this skill when you need to: - Set up SAST scanning in CI/CD pipelines - Create custom security rules for your codebase - Configure quality gates and compliance policies - Optimize scan performance and reduce false positives - Integrate multiple SAST tools for defense-in-depth ## Core Capabilities ### 1.8.3kinstalls124Screen Reader TestingTest web applications with screen readers including VoiceOver, NVDA, and JAWS. Use when validating screen reader compatibility, debugging accessibility issues, or ensuring assistive technology support. --- name: screen-reader-testing description: Test web applications with screen readers including VoiceOver, NVDA, and JAWS. Use when validating screen reader compatibility, debugging accessibility issues, or ensuring assistive technology support. --- # Screen Reader Testing Practical guide to testing web applications with screen readers for comprehensive accessibility validation. ## When to Use This Skill - Validating screen reader compatibility - Testing ARIA implementations - Debugging assistive technology issues - Verifying form accessibility - Testing dynamic content announcements - Ensuring navigation accessibility ## Core Concepts ### 1. Major Screen Readers | Screen Reader | Platform | Browser | Usage | | ------------- | --------- | -------------- | ----- | | **VoiceOver** | macOS/iOS | Safari | ~15% | | **NVDA** | Windows | Firefox/Chrome | ~31% | | **JAWS** | Windows | Chrome/IE | ~40% | | **TalkBack** | Android | Chrome | ~10% | | **Narrator** | Windows | Edge | ~4% | ###.8.3kinstalls125Postmortem WritingWrite effective blameless postmortems with root cause analysis timelines and action items Use when conducting incident reviews writing postmortem documents or improving incident response processes name postmortem-writing description Write effective blameless postmortems with root cause analysis timelines and action items Use when conducting incident reviews writing postmortem documents or improving incident response processes Postmortem Writing Comprehensive guide to writing effective blameless postmortems that drive organizational learning and prevent incident recurrence When to Use This Skill Conducting post-incident reviews Writing postmortem documents Facilitating blameless postmortem meetings Identifying root causes and contributing factors Creating actionable follow-up items Building organizational learning culture Core Concepts 1 Blameless Culture Blame-Focused Blameless Who caused this What conditions allowed this Someone made a mistake The system allowed this mistake Punish individuals Improve systems Hide information Share learnings Fear of speaking up Psychological safety 2 Postmortem Triggers SEV1 or SEV2 incidents Customer-facing outages 15 minutes Data loss or securi.8.3kinstalls126Turborepo CachingConfigure Turborepo for efficient monorepo builds with local and remote caching Use when setting up Turborepo optimizing build pipelines or implementing distributed caching name turborepo-caching description Configure Turborepo for efficient monorepo builds with local and remote caching Use when setting up Turborepo optimizing build pipelines or implementing distributed caching Turborepo Caching Production patterns for Turborepo build optimization When to Use This Skill Setting up new Turborepo projects Configuring build pipelines Implementing remote caching Optimizing CI CD performance Migrating from other monorepo tools Debugging cache misses Core Concepts 1 Turborepo Architecture Workspace Root apps web package json docs package json packages ui package json config package json turbo json package json 2 Pipeline Concepts Concept Description dependsOn Tasks that must complete first cache Whether to cache outputs outputs Files to cache inputs Files that affect cache key persistent Long-running tasks dev servers Templates Template 1 turbo json Configuration json schema https turbo build schema json globalDependencies env env local globalEnv NODE_ENV VERCEL_URL pipeline build depen.8.2kinstalls127Projection PatternsBuild read models and projections from event streams. Use when implementing CQRS read sides, building materialized views, or optimizing query performance in event-sourced systems. --- name: projection-patterns description: Build read models and projections from event streams. Use when implementing CQRS read sides, building materialized views, or optimizing query performance in event-sourced systems. --- # Projection Patterns Comprehensive guide to building projections and read models for event-sourced systems. ## When to Use This Skill - Building CQRS read models - Creating materialized views from events - Optimizing query performance - Implementing real-time dashboards - Building search indexes from events - Aggregating data across streams ## Core Concepts ### 1. Projection Architecture ``` ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ Event Store │────►│ Projector │────►│ Read Model │ │ │ │ │ │ (Database) │ │ ┌─────────┐ │ │ ┌─────────┐ │ │ ┌─────────┐ │ │ │ Events │ │ │ │ Handler │ │ │ │ Tables │ │ │ └─────────┘ │ │ │ Logic │ │ │ │ Views │ │ │ │ │ └─────────┘ │ │ │ Cache │ │ └─────────────┘ └─────────────┘ └─────────────┘ ``` ### 2. Projection Types | Type | Description | U.8.2kinstalls128Employment Contract TemplatesCreate employment contracts, offer letters, and HR policy documents following legal best practices. Use when drafting employment agreements, creating HR policies, or standardizing employment documentation. --- name: employment-contract-templates description: Create employment contracts, offer letters, and HR policy documents following legal best practices. Use when drafting employment agreements, creating HR policies, or standardizing employment documentation. --- # Employment Contract Templates Templates and patterns for creating legally sound employment documentation including contracts, offer letters, and HR policies. ## When to Use This Skill - Drafting employment contracts - Creating offer letters - Writing employee handbooks - Developing HR policies - Standardizing employment documentation - Onboarding documentation ## Core Concepts ### 1. Employment Document Types | Document | Purpose | When Used | | ----------------------- | ----------------------- | ------------- | | **Offer Letter** | Initial job offer | Pre-hire | | **Employment Contract** | Formal agreement | Hire | | **Employee Handbook** | Policies & procedures | Onboarding | | **NDA** | Confidentiality | Before acce.8.2kinstalls129Pci ComplianceImplement PCI DSS compliance requirements for secure handling of payment card data and payment systems. Use when securing payment processing, achieving PCI compliance, or implementing payment card security measures. --- name: pci-compliance description: Implement PCI DSS compliance requirements for secure handling of payment card data and payment systems. Use when securing payment processing, achieving PCI compliance, or implementing payment card security measures. --- # PCI Compliance Master PCI DSS (Payment Card Industry Data Security Standard) compliance for secure payment processing and handling of cardholder data. ## When to Use This Skill - Building payment processing systems - Handling credit card information - Implementing secure payment flows - Conducting PCI compliance audits - Reducing PCI compliance scope - Implementing tokenization and encryption - Preparing for PCI DSS assessments ## PCI DSS Requirements (12 Core Requirements) ### Build and Maintain Secure Network 1. Install and maintain firewall configuration 2. Don't use vendor-supplied defaults for passwords ### Protect Cardholder Data 3.8.2kinstalls130Defi Protocol TemplatesImplement DeFi protocols with production-ready templates for staking AMMs governance and lending systems Use when building decentralized finance applications or smart contract protocols name defi-protocol-templates description Implement DeFi protocols with production-ready templates for staking AMMs governance and lending systems Use when building decentralized finance applications or smart contract protocols DeFi Protocol Templates Production-ready templates for common DeFi protocols including staking AMMs governance lending and flash loans When to Use This Skill Building staking platforms with reward distribution Implementing AMM Automated Market Maker protocols Creating governance token systems Developing lending borrowing protocols Integrating flash loan functionality Launching yield farming platforms Staking Contract solidity SPDX-License-Identifier MIT pragma solidity 0 8 0 import openzeppelin contracts token ERC20 IERC20 sol import openzeppelin contracts security ReentrancyGuard sol import openzeppelin contracts access Ownable sol contract StakingRewards is ReentrancyGuard Ownable IERC20 public stakingToken IERC20 public rewardsToken uint256 public rewardRate 100 Rewards pe.8.2kinstalls131Bats Testing PatternsMaster Bash Automated Testing System (Bats) for comprehensive shell script testing. Use when writing tests for shell scripts, CI/CD pipelines, or requiring test-driven development of shell utilities. --- name: bats-testing-patterns description: Master Bash Automated Testing System (Bats) for comprehensive shell script testing. Use when writing tests for shell scripts, CI/CD pipelines, or requiring test-driven development of shell utilities. --- # Bats Testing Patterns Comprehensive guidance for writing comprehensive unit tests for shell scripts using Bats (Bash Automated Testing System), including test patterns, fixtures, and best practices for production-grade shell testing. ## When to Use This Skill - Writing unit tests for shell scripts - Implementing test-driven development (TDD) for scripts - Setting up automated testing in CI/CD pipelines - Testing edge cases and error conditions - Validating behavior across different shell environments - Building maintainable test suites for scripts - Creating fixtures for complex test scenarios - Testing multiple shell dialects (bash, sh, dash) ## Detailed patterns and worked examples Detailed pattern documentation lives in `references/det.8.1kinstalls132Team Composition AnalysisDesign optimal team structures, hiring plans, compensation strategies, and equity allocation for early-stage startups from pre-seed through Series A. Use this skill when planning headcount, determining which roles to hire next, setting compensation or equity ranges, designing org structure, or building a hiring budget aligned to funding milestones. --- name: team-composition-analysis description: Design optimal team structures, hiring plans, compensation strategies, and equity allocation for early-stage startups from pre-seed through Series A. Use this skill when planning headcount, determining which roles to hire next, setting compensation or equity ranges, designing org structure, or building a hiring budget aligned to funding milestones. version: 1.0.0 --- # Team Composition Analysis Design optimal team structures, hiring plans, compensation strategies, and equity allocation for early-stage startups from pre-seed through Series A. ## Overview Build the right team at the right time with appropriate compensation and equity. Plan role-by-role hiring aligned with revenue milestones, budget constraints, and market benchmarks.8.1kinstalls133Service Mesh ObservabilityImplement comprehensive observability for service meshes including distributed tracing metrics and visualization Use when setting up mesh monitoring debugging latency issues or implementing SLOs for service communication name service-mesh-observability description Implement comprehensive observability for service meshes including distributed tracing metrics and visualization Use when setting up mesh monitoring debugging latency issues or implementing SLOs for service communication Service Mesh Observability Complete guide to observability patterns for Istio Linkerd and service mesh deployments When to Use This Skill Setting up distributed tracing across services Implementing service mesh metrics and dashboards Debugging latency and error issues Defining SLOs for service communication Visualizing service dependencies Troubleshooting mesh connectivity Core Concepts 1 Three Pillars of Observability Observability Metrics Traces Logs Request rate Span context Access logs Error rate Latency Error details Latency P50 Dependencies Debug info Saturation Bottlenecks Audit trail 2 Golden Signals for Mesh Signal Description Alert Threshold Latency Request duration P50 P99 P99 500ms Traffic Re.8.1kinstalls134Slo ImplementationDefine and implement Service Level Indicators (SLIs) and Service Level Objectives (SLOs) with error budgets and alerting. Use when establishing reliability targets, implementing SRE practices, or measuring service performance. --- name: slo-implementation description: Define and implement Service Level Indicators (SLIs) and Service Level Objectives (SLOs) with error budgets and alerting. Use when establishing reliability targets, implementing SRE practices, or measuring service performance. --- # SLO Implementation Framework for defining and implementing Service Level Indicators (SLIs), Service Level Objectives (SLOs), and error budgets. ## Purpose Implement measurable reliability targets using SLIs, SLOs, and error budgets to balance reliability with innovation velocity. ## When to Use - Define service reliability targets - Measure user-perceived reliability - Implement error budgets - Create SLO-based alerts - Track reliability goals ## SLI/SLO/SLA Hierarchy ``` SLA (Service Level Agreement) ↓ Contract with customers SLO (Service Level Objective) ↓ Internal reliability target SLI (Service Level Indicator) ↓ Actual measurement ``` ## Defining SLIs ### Common SLI Types #### 1.8.1kinstalls135Track ManagementUse this skill when creating, managing, or working with Conductor tracks - the logical work units for features, bugs, and refactors. Applies to spec.md, plan.md, and track lifecycle operations. --- name: track-management description: Use this skill when creating, managing, or working with Conductor tracks - the logical work units for features, bugs, and refactors. Applies to spec.md, plan.md, and track lifecycle operations. version: 1.0.0 --- # Track Management Guide for creating, managing, and completing Conductor tracks - the logical work units that organize features, bugs, and refactors through specification, planning, and implementation phases. ## When to Use This Skill - Creating new feature, bug, or refactor tracks - Writing or reviewing spec.md files - Creating or updating plan.md files - Managing track lifecycle from creation to completion - Understanding track status markers and conventions - Working with the tracks.md registry - Interpreting or updating track metadata ## Detailed patterns and worked examples Detailed pattern documentation lives in `references/details.md`.8kinstalls136On Call Handoff PatternsMaster on-call shift handoffs with context transfer, escalation procedures, and documentation. Use this skill when transitioning on-call responsibilities between engineers and ensuring the incoming responder has full situational awareness, when writing a shift summary that captures active incidents, ongoing investigations, and recent changes, when handing off mid-incident so a fresh engineer can t --- name: on-call-handoff-patterns description: Master on-call shift handoffs with context transfer, escalation procedures, and documentation. Use this skill when transitioning on-call responsibilities between engineers and ensuring the incoming responder has full situational awareness, when writing a shift summary that captures active incidents, ongoing investigations, and recent changes, when handing off mid-incident so a fresh engineer can take over the incident commander role without losing context, when onboarding a new engineer to the on-call rotation for the first time, or when auditing and improving the quality of existing handoff processes across teams.8kinstalls137Bazel Build OptimizationOptimize Bazel builds for large-scale monorepos. Use when configuring Bazel, implementing remote execution, or optimizing build performance for enterprise codebases. --- name: bazel-build-optimization description: Optimize Bazel builds for large-scale monorepos. Use when configuring Bazel, implementing remote execution, or optimizing build performance for enterprise codebases. --- # Bazel Build Optimization Production patterns for Bazel in large-scale monorepos. ## When to Use This Skill - Setting up Bazel for monorepos - Configuring remote caching/execution - Optimizing build times - Writing custom Bazel rules - Debugging build issues - Migrating to Bazel ## Core Concepts ### 1. Bazel Architecture ``` workspace/ ├── WORKSPACE.bazel # External dependencies ├── .bazelrc # Build configurations ├── .bazelversion # Bazel version ├── BUILD.bazel # Root build file ├── apps/ │ └── web/ │ └── BUILD.bazel ├── libs/ │ └── utils/ │ └── BUILD.bazel └── tools/ └── bazel/ └── rules/ ``` ### 2. Key Concepts | Concept | Description | | ----------- | -------------------------------------- | | **Target** | Buildable unit (library, binary, test) | | **Package** | Directory with BUILD file | | **Labe.8kinstalls138Istio Traffic ManagementConfigure Istio traffic management including routing load balancing circuit breakers and canary deployments Use when implementing service mesh traffic policies progressive delivery or resilience patterns name istio-traffic-management description Configure Istio traffic management including routing load balancing circuit breakers and canary deployments Use when implementing service mesh traffic policies progressive delivery or resilience patterns Istio Traffic Management Comprehensive guide to Istio traffic management for production service mesh deployments When to Use This Skill Configuring service-to-service routing Implementing canary or blue-green deployments Setting up circuit breakers and retries Load balancing configuration Traffic mirroring for testing Fault injection for chaos engineering Core Concepts 1 Traffic Management Resources Resource Purpose Scope VirtualService Route traffic to destinations Host-based DestinationRule Define policies after routing Service-based Gateway Configure ingress egress Cluster edge ServiceEntry Add external services Mesh-wide 2 Traffic Flow Client Gateway VirtualService DestinationRule Service routing policies pods Templates Template 1 Basi.8kinstalls139Nft StandardsImplement NFT standards ERC-721 ERC-1155 with proper metadata handling minting strategies and marketplace integration Use when creating NFT contracts building NFT marketplaces or implementing digital asset systems name nft-standards description Implement NFT standards ERC-721 ERC-1155 with proper metadata handling minting strategies and marketplace integration Use when creating NFT contracts building NFT marketplaces or implementing digital asset systems NFT Standards Master ERC-721 and ERC-1155 NFT standards metadata best practices and advanced NFT features When to Use This Skill Creating NFT collections art gaming collectibles Implementing marketplace functionality Building on-chain or off-chain metadata Creating soulbound tokens non-transferable Implementing royalties and revenue sharing Developing dynamic evolving NFTs ERC-721 Non-Fungible Token Standard solidity SPDX-License-Identifier MIT pragma solidity 0 8 0 import openzeppelin contracts token ERC721 extensions ERC721URIStorage sol import openzeppelin contracts token ERC721 extensions ERC721Enumerable sol import openzeppelin contracts access Ownable sol import openzeppelin contracts utils Counters sol contract MyNFT is ERC.8kinstalls140Mtls ConfigurationConfigure mutual TLS (mTLS) for zero-trust service-to-service communication. Use when implementing zero-trust networking, certificate management, or securing internal service communication. --- name: mtls-configuration description: Configure mutual TLS (mTLS) for zero-trust service-to-service communication. Use when implementing zero-trust networking, certificate management, or securing internal service communication. --- # mTLS Configuration Comprehensive guide to implementing mutual TLS for zero-trust service mesh communication. ## When to Use This Skill - Implementing zero-trust networking - Securing service-to-service communication - Certificate rotation and management - Debugging TLS handshake issues - Compliance requirements (PCI-DSS, HIPAA) - Multi-cluster secure communication ## Core Concepts ### 1. mTLS Flow ``` ┌─────────┐ ┌─────────┐ │ Service │ │ Service │ │ A │ │ B │ └────┬────┘ └────┬────┘ │ │ ┌────┴────┐ TLS Handshake ┌────┴────┐ │ Proxy │◄───────────────────────────►│ Proxy │ │(Sidecar)│ 1. Encrypted Channel │ │ └─────────┘ └─────────┘ ``` ### 2. Certificate Hierarchy ``` Root CA (Self-signed, long-lived) │ ├── Intermediate CA (Cluster-level) │ │ │ ├── Workload Cer.8kinstalls141Linkerd PatternsThe linkerd-patterns skill provides production patterns for Linkerd, the lightweight security-focused Kubernetes service mesh. It covers control plane components including destiny, identity, and proxy-inject alongside data plane sidecar proxies wrapping application pods. Key resources include ServiceProfile for per-route metrics retries and timeouts, TrafficSplit for canary and A/B deployments, Server for server-side policies, and ServerAuthorization for access control. Templates walk through CLI installation, cluster validation, CRD and control plane setup, viz extension install, namespace injection labels, service profile YAML, traffic split manifests, and authorization policies. Use cases span automatic mTLS, canary routing, per-route observability, retry and timeout configuration, and multi-cluster mesh topologies. The skill targets teams wanting minimal-overhead zero-trust networking compared to heavier mesh alternatives. Use when setting up Linkerd, configuring traffic policies, or implementing service mesh security on Kubernetes.7.9kinstalls142Parallel DebuggingThe parallel-debugging skill applies Analysis of Competing Hypotheses with parallel agent investigation for hard bugs. Agents generate hypotheses across six failure modes: logic errors, data issues, state problems, integration failures, resource issues, and environment mismatches. Evidence must cite file and line references with strength ratings from direct to correlational, testimonial, or absence. Confidence levels guide whether hypotheses are high, medium, or low before arbitration categorizes results as confirmed, plausible, falsified, or inconclusive. The protocol ranks confirmed causes by confidence, evidence count, causal chain strength, and contradicting evidence, then validates fixes against root cause, regression risk, reproduction cases, edge coverage, and test updates. Use when bugs have multiple plausible causes, initial debugging failed, issues span modules, you need systematic root cause analysis, or you want to reduce confirmation bias during investigation.7.6kinstalls143Parallel Feature DevelopmentThe parallel-feature-development skill coordinates multi-agent feature implementation with clear ownership and integration rules. Agents assign files by directory, logical module, or architectural layer, enforcing one owner per file and sequential change requests when sharing is unavoidable. Interface contract files owned by a lead provide read-only API types both implementers import without editing. Integration patterns include vertical slices per feature, horizontal layers across features, or hybrid mixes with shared infrastructure streams. Branch strategies cover single feature branches with strict ownership or sub-branches per implementer with explicit merge points. Troubleshooting guidance addresses blocking on shared code via stub interfaces, barrel file conflicts, wrong decomposition mid-stream, and drifting contracts between API and test owners. Related skills include team-composition-patterns and team-communication-protocols for handoffs. Use when decomposing large features for parallel agents, establishing file boundaries, designing contracts, or choosing slice versus layer strategies.7.5kinstalls144Task Coordination Strategiestask-coordination-strategies is an agent skill for breaking complex work into parallelizable units, designing dependency graphs, writing effective task descriptions, and monitoring workload across agent teams. Decomposition strategies split work by architectural layer, functional component, cross-cutting concern, or file ownership boundaries to reduce merge conflicts and maximize parallelism. Dependency graph design favors wide shallow graphs, identifies critical paths, uses blockedBy sparingly, and avoids circular deadlocks with patterns for independent, sequential, and diamond flows. Task descriptions should include objective, owned files, requirements, interface contracts, acceptance criteria, and explicit out-of-scope boundaries using the provided template. Workload monitoring covers idle teammates, blockers, and overload signals with rebalancing via TaskList, TaskUpdate, and SendMessage. Use when coordinating multi-agent implementation, integration testing gates, or critical path planning for parallel execution.7.4kinstalls145Multi Reviewer Patternsmulti-reviewer-patterns is an agent skill for coordinating parallel code reviews across quality dimensions with deduplication severity calibration and consolidated reporting. Review dimensions include Security Performance Architecture Testing and Accessibility with recommended combinations per scenario such as API endpoints getting Security Performance Architecture and frontend components getting Architecture Testing Accessibility. Finding deduplication merges same file line same issue findings credits all reviewers keeps different issues separate uses highest severity on conflicts and tags co-located distinct problems. Severity calibration defines Critical High Medium and Low with rules like external exploitable vulnerabilities as Critical or High performance hot path issues at least Medium and style-only issues as Low. The consolidated report template groups findings by severity with location dimension description impact and fix sections plus a per-dimension summary table and overall recommendation. Use when organizing multi-reviewer reviews calibrating severity consistently or producing unified PR review reports.7.4kinstalls146Team Communication ProtocolsDefines structured communication protocols for agent teams using message, broadcast, and shutdown_request types. Developers use this when establishing communication norms for newly spawned teams, coordinating integration handoffs between parallel implementers, or managing graceful team shutdown after task completion. Includes plan approval workflows where teammates create plans in read-only mode then request lead review via ExitPlanMode, and troubleshooting patterns for deadlocks, rejected shutdowns, and broadcast overuse. Key workflows cover message type selection (direct vs broadcast), teammate discovery via config.json, and anti-patterns like broadcasting routine updates or micromanaging via messages.7.3kinstalls147Team Composition PatternsThis skill provides patterns for composing multi-agent teams in Claude Code's Agent Teams feature. Developers use it to decide team size (1-5 agents based on task complexity), select specialized agent types (team-reviewer, team-debugger, team-implementer, team-lead, general-purpose, Explore, Plan) with specific tool access, choose preset configurations (Review, Debug, Feature, Fullstack, Research, Security, Migration teams), and configure display modes (tmux, iTerm2, in-process). The skill maps complexity levels to team sizes, explains which agent types can write files versus read-only, defines role boundaries to avoid overlap, and provides troubleshooting for common coordination issues. It enables spawning the right number of agents with appropriate capabilities for parallel code review, debugging, feature development, research, security audits, and migrations.7.3kinstalls148Evaluation MethodologyThe evaluation-methodology skill pluginEval quality methodology - dimensions, rubrics, statistical methods, and scoring formulas. Use this skill when understanding how plugin quality is measured, when interpreting a low score on a specific dimension, when deciding how to improve a skill's triggering accuracy or orchestration fitness, when calibrating scoring thresholds for your marketplace, or when explaining quality badges to external partners like Neon.. Evaluation Methodology This document is the authoritative reference for how PluginEval measures plugin and skill quality. It covers the three evaluation layers, all ten scoring dimensions, the composite formula, badge thresholds, anti-pattern flags, Elo ranking, and actionable improvement tips. Related: Full rubric anchors --- The Three Evaluation Layers PluginEval stacks three complementary layers. Each layer produces a score between 0.0 and 1.0 for each applicable dimension, and later layers override or blend with earlier ones according to per-dimension blend weights. Layer 1 - Static Analysis Speed: < 2 seconds. The static analyzer ( layers/static.py ) runs six sub-checks directly against the parsed SKILL.md: Sub-check What.4.8kinstalls149HadsHADS (Human-AI Document Standard) is a Markdown convention for technical documentation that separates authoritative facts, context, and known issues into four block types: [SPEC], [NOTE], [BUG], and [?]. Developers use it when writing docs that AI models will read before humans, converting existing documentation, validating HADS compliance, or optimizing for token-efficient AI consumption. The format requires an H1 title, version declaration, and AI reading manifest. Key workflows include generating new HADS documents with terse spec blocks and narrative notes, converting existing READMEs into structured HADS format, validating document structure, and summarizing docs by reading only spec and bug blocks. No tooling required - standard Markdown files only. Four block types ([SPEC], [NOTE], [BUG], [?]) explicitly signal content type to AI models AI manifest required before first content section - tells models what to read and skip Terse [SPEC] blocks use bullets, tables, code instead of prose for token efficiency [BUG] blocks require symptom + cause + fix - surfaces hard-won knowledge Standard .md file extension with no custom tooling or4.3kinstalls150Block No Verify HookBlock-no-verify hook is a PreToolUse configuration guard that intercepts Bash tool calls from AI agents (Claude Code, Codex, etc.) and rejects commands containing bypass flags like --no-verify and --no-gpg-sign before execution. Developers use it when setting up agent-driven projects to enforce commit quality gates, linting, formatting, security scanning, and GPG signing policies. The hook inspects every shell command via regex pattern matching against $TOOL_INPUT, exits with code 2 to block the tool call if a bypass flag is detected, or code 0 to allow normal execution. Installation is per-project (.claude/settings.json) or global (~/.claude/settings.json). The configuration is extendable to block additional dangerous flags. PreToolUse hook matcher targets only Bash calls without interfering with Read, Edit, or Grep tools. Blocks --no-verify and --no-gpg-sign flags via grep regex pattern inspection of $TOOL_INPUT. Exit code 2 signal rejects tool call entirely; exit code 0 allows normal execution. Installable per-project or globally; works alongside other PreToolUse hooks in same configuration. Extendable pattern to block additional dangerous flags like --force or --force-with-lea.4.2kinstalls151Protect Mcp Setupprotect-mcp adds cryptographic governance to Claude Code by intercepting every tool call (Bash, Edit, Write, WebFetch) with Cedar policy enforcement and Ed25519-signed receipts. Policies are evaluated before execution; denials block the tool outright. Each decision produces a tamper-evident, hash-chained receipt verifiable offline via @veritasacta/verify. Receipts record tool name, input/output hashes, decision, policy digest, and timestamp. No external server required. Designed for regulated environments (finance, healthcare, research) where audit trails must survive third-party verification without trusting the operator.3.6kinstalls152Signed Audit Trails RecipeSigned Audit Trails is a cookbook skill for cryptographically signed receipts on every Claude Code tool call before adopting the protect-mcp runtime hooks. Each Bash, Edit, Write, or WebFetch invocation is evaluated against a Cedar policy in PreToolUse and signed as a JCS-canonical Ed25519 receipt in PostToolUse, hash-chained for tamper detection. Auditors verify offline with npx @veritasacta/verify receipts/*.json without network trust. The walkthrough covers .claude/settings.json hook wiring, sample protect.cedar rules that forbid destructive Bash while permitting safe git and npm patterns, receipt field anatomy, tamper demos, and GitHub Actions jobs that gate merges on intact chains. Cryptography invariants follow RFC 8785 JCS canonicalization and RFC 8032 Ed25519 with parent_receipt_hash linkage. The skill documents SLSA provenance composition via agent-commit byproducts, cross-implementation interop with protect-mcp, protect-mcp-adk, and sb-runtime, and pitfalls around private key commits, hook quoting, and missing policy flags in production.3.4kinstalls153Review Agent SetupReview Agent Governance gates AI agent review-surface actions behind explicit human approval with Ed25519-signed receipts for every allow or deny decision. Install the wshobson/agents review-agent-governance plugin, copy review-governance.cedar policy to the project, and create a gitignored review-receipts directory plus signing key. Cedar policy denies review actions unconditionally until a human opens an approval window via touch .review-approved or the /approve-review slash command, then closes it immediately after. Covered actions include gh pr review, gh pr merge, issue triage, release publish, CI workflow edits, protected branch pushes, and external notification webhooks. Dry-run mode with REVIEW_APPROVAL_FLAG=./.never-approve forces full policy evaluation with no bypass for audit runs. Receipt chains verify offline via npx @veritasacta/verify and /list-pending surfaces recent denials inside Claude Code. The skill composes alongside protect-mcp with stacked PreToolUse hooks requiring both policies to pass.2.9kinstalls154ScanScans the codebase to generate project-doc.md and AGENTS.md. Use when bootstrapping a new agent-driven repo, refreshing project documentation after architectural changes, or running a delta scan to detect drift. Runs a full scan on first use and a smart delta scan on subsequent runs. Uses understand-anything + context-mode when available, falls back to native tools otherwise. Only updates AGENTS.m --- name: scan description: Scans the codebase to generate project-doc.md and AGENTS.md. Use when bootstrapping a new agent-driven repo, refreshing project documentation after architectural changes, or running a delta scan to detect drift. Runs a full scan on first use and a smart delta scan on subsequent runs. Uses understand-anything + context-mode when available, falls back to native tools otherwise. Only updates AGENTS.md on detected architectural changes with human confirmation. --- # Codebase Scanner You are a technical analyst. Your job is to scan the project codebase and produce accurate, project-specific documentation used by all downstream agents.2.2kinstalls155Recsys Pipeline ArchitectThe recsys-pipeline-architect skill encodes composable six-stage pattern for recommendation ranking feed pipelines inspired by xAI For You algorithm scaffolding. Stages fetch candidates enrich metadata drop ineligible score survivors sort top K fire async side effects. Index plus scaffold helps specify scoring and item types while pipeline shape stays constant for top-K user-context problems. Use designing feeds search ranking content recommendations or auditing whether recsys maps fetch-enrich-filter-score-rank-side-effect rather than one-off ML shapes in production systems. Six stages fetch enrich filter score rank side effects. Top-K user context problem shape. Scaffold from For You algorithm pattern. Scoring and items vary skeleton constant. Production pipeline not offline-only. Recsys pipeline architect scaffold. User asks recommendation pipeline.1.9kinstalls156Social PublishingSocial Publishing is an agent-first social media skill from wshobson/agents (version 1.0.0, MIT license) integrating the SocialClaw API. One workspace API key covers 13 platforms—X, LinkedIn, Instagram, Facebook Pages, TikTok, Discord, Telegram, YouTube, Reddit, WordPress, and Pinterest—without per-platform OAuth setup. Developers provide SOCIALCLAW_API_KEY and use the skill when publishing, scheduling, or managing social content programmatically from coding agents. The skill suits campaign launches, release announcements, and automated posting pipelines where the same message must reach multiple channels through a unified REST workflow rather than manual dashboard posting.1.3kinstalls