@wshobson

hads teaches claude to read, generate, and validate human-ai document standard markdown files. covers block types, required structure, reading/generation rules, validation criteria, and design rationale with examples and quick reference.

screen-reader-testing provides hands-on procedures for validating web accessibility across voiceover, nvda, jaws, and talkback. covers setup, command reference, test checklists, common issues with fixes, and focus management patterns.

python-code-style covers linting, formatting, type checking, naming conventions, and documentation standards using modern tooling like ruff and mypy. includes configuration patterns, docstring examples, and ci integration guidance.

evaluation-methodology documents plugineval's three-layer quality framework, dimension weights, anti-pattern penalties, and elo ranking. it supplies rubric anchors, composite formulas, cli commands, and systematic improvement strategies.

wshobson-architecture-patterns covers clean architecture, hexagonal architecture, and domain-driven design tactical patterns with concrete code examples, layer dependency rules, and anti-patterns to avoid in practice.

review-agent-governance gates ai agent actions on github and external surfaces behind explicit human approval, producing signed receipts for audit. targets pr reviews, issue triage, releases, ci edits, and protected branch pushes.

multi-reviewer-patterns provides structured guidance for running parallel code reviews across security, performance, architecture and other dimensions, with explicit deduplication rules, severity calibration criteria, and a consolidated reporting template.

wshobson-python-code-style covers linting, formatting, type checking, and naming conventions with concrete tool configs (ruff, mypy, pyright) and docstring patterns. practical patterns for modern python projects but lacks failure mode discussion.

wshobson-incident-runbook-templates provides structured templates for building incident response procedures with severity matrices, escalation paths, and communication workflows. includes practical troubleshooting patterns for common runbook failures like outdated commands and missing prerequisites.

python-background-jobs covers task queue patterns, idempotency strategies, and job state management for decoupling long-running work from request/response cycles. uses celery examples with guidance on retries, timeouts, and failure handling.

python-type-safety covers type annotations, generics, protocols, and type narrowing to catch errors statically. includes patterns for annotating signatures, modern union syntax, generic classes, and strict mypy/pyright configuration.

python-anti-patterns provides a categorized checklist of common python mistakes across infrastructure, architecture, error handling, resources, types, and testing. includes bad/good code examples and centralized reference table for quick review before finalization.

bats-testing-patterns provides concrete examples for unit testing shell scripts using bats, covering setup/teardown, mocking, fixtures, and ci/cd integration with practical code samples throughout.

python-project-structure provides patterns for organizing python codebases with clear module boundaries, explicit public apis via __all__, and layered or domain-driven architectures. covers file naming, import strategy, test placement, and anti-patterns to avoid.

wshobson-dotnet-backend-patterns covers clean architecture, dependency injection, async patterns, configuration management, result types, ef core, dapper, and multi-level caching for building production .net apis. includes code examples but lacks operational guidance on failure modes.

memory-forensics covers live and post-mortem memory acquisition across windows, linux, and macos, with volatility 3 workflows for malware analysis, incident response, and artifact extraction including process injection detection and rootkit hunting.

python-configuration covers externalized config management via pydantic-settings, typed validation, environment variables, and secrets handling. teaches fail-fast validation at startup and sensible local development defaults.

error-handling-patterns covers exceptions, result types, custom error hierarchies, and resilience patterns (retry, circuit breaker, graceful degradation) across python, typescript, rust, and go with working code examples.

code-review-excellence provides a structured approach to conducting effective code reviews across multiple dimensions. it covers mindset, feedback techniques, phased review procedures, language-specific patterns, and handles common friction points like disagreements and difficult conversations.

postgresql-table-design covers normalization, data type selection, indexing strategies, and partition patterns for postgres schemas. addresses common gotchas like missing fk indexes, null handling in unique constraints, and mvcc implications.

task-coordination-strategies provides decomposition patterns (by layer, component, concern, ownership), dependency graph design with blockedBy/blocks semantics, and structured task description templates with acceptance criteria. includes workload monitoring signals and rebalancing heuristics for multi-agent coordination.

wshobson-python-project-structure covers module cohesion, explicit public api design via __all__, and directory layout patterns ranging from flat hierarchies to domain-driven organization. actionable for new projects and reorganization work.

parallel-debugging structures root cause analysis through competing hypotheses across six failure categories (logic, data, state, integration, resource, environment), with evidence collection standards and arbitration protocols to reduce confirmation bias.

python-observability covers structured logging, metrics, and distributed tracing patterns for python applications. teaches correlation id propagation, semantic log levels, and the four golden signals for production debugging without redeployment.

javascript-testing-patterns covers unit, integration, and component testing across jest and vitest with concrete examples for mocking, async operations, and dependency injection. punts advanced scenarios to external references rather than completing the narrative.

deployment-pipeline-design covers multi-stage ci/cd architecture with approval gates, environment promotion, and deployment orchestration patterns. balances automation with safety controls for varied infrastructure targets.

projection-patterns addresses building read models and materialized views from event streams, covering four projection types and five templates with emphasis on idempotency, checkpointing, and safe rebuild strategies.

async-python-patterns covers asyncio fundamentals, event loops, coroutines, and concurrent execution patterns for I/O-bound workloads. includes decision guidance, five core patterns with code examples, and common pitfalls.

memory-safety-patterns covers raii, ownership models, and smart pointers across rust, c++, and c. provides concrete code examples for preventing use-after-free, leaks, and data races, with language-specific patterns and debugging tools.

github-actions-templates provides copy-paste workflow patterns for common ci/cd tasks like testing, docker builds, and kubernetes deployments. patterns are concrete but lack guidance on when to choose between them or how to adapt for non-standard scenarios.

wshobson-architecture-decision-records provides templates and governance patterns for capturing technical decisions. covers lifecycle management, review processes, and multiple template formats (madr, lightweight, y-statement, deprecation, rfc). lacks specific trigger phrases and acknowledges few failure modes.

block-no-verify-hook intercepts git bypass flags (--no-verify, --no-gpg-sign, --no-edit) in PreToolUse hooks to prevent ai agents from skipping pre-commit safety mechanisms like linting and signing.

terraform-module-library covers patterns for building reusable infrastructure modules across aws, azure, gcp, and oci using standard directory layouts, input validation, and terratest testing. provides concrete vpc and rds examples with composition patterns.

wshobson-bats-testing-patterns provides shell script testing patterns using bats with error condition examples, ci/cd integration snippets, and helper utilities. lacks procedural sequencing and assumes existing bats familiarity.

wshobson-visual-design-foundations provides concrete token definitions and css examples for typography, color, spacing, and iconography but lacks procedural steps for actually applying these systems to a design problem.

service-mesh-observability covers metrics, traces, and logs across istio and linkerd with concrete prometheus queries, jaeger setup, and dashboard templates. practical but procedurally thin on implementation sequencing and failure recovery.

rag-implementation covers vector database selection, embedding model choices, retrieval strategies (dense, sparse, hybrid), and reranking approaches. includes a working langgraph example but lacks failure modes and production hardening details.

wshobson-mobile-ios-design covers swiftui patterns, navigation structures, and system integration for ios development. provides code examples and hig principles but lacks actionable procedures for design decisions.

web3-testing covers unit, integration, and mainnet fork testing for solidity contracts using hardhat and foundry. includes fuzzing, gas measurement, and snapshot-based test isolation with working code examples.

nextjs-app-router-patterns covers server/client rendering modes, file conventions, and architectural decisions for next.js 14+ applications. includes layout setup, data fetching with revalidation, and best practices for server components and parallel routes.

rust-async-patterns covers production-ready concurrent patterns for tokio-based applications, including task coordination, channels, error handling, and debugging with tokio-console. teaches when to apply patterns like joinset, broadcast channels, and cancellation tokens in real systems.

llm-evaluation catalogs metric types (automated, human, llm-as-judge) and provides a python skeleton for running evaluation suites, but lacks deployment guidance, failure recovery, and concrete validation workflows.

wshobson-interaction-design covers motion design, microinteractions, and state transitions via code examples and timing guidelines. lacks decision trees and explicit failure recovery. useful reference but not a runbook.

nft-standards covers erc-721 and erc-1155 implementation with metadata handling, royalties, and minting mechanics. provides working solidity templates but lacks systematic procedure and error recovery guidance.

wshobson-team-composition-analysis provides hiring benchmarks, compensation tables, and equity allocation ranges for early-stage startups through series a, organized by funding stage and role category.

mobile-ios-design covers swiftui patterns, navigation, and apple human interface guidelines for building native ios apps. includes code examples for layouts, system integration, and common pitfalls.

postmortem-writing covers blameless incident review methodology, offering templates for timeline analysis, 5-whys root cause investigation, and facilitation guidance. emphasizes systems thinking over individual blame.

interaction-design covers microinteractions, transitions, loading states, and gesture patterns using motion libraries and css animations. includes timing guidelines, easing functions, and accessibility considerations for reduced-motion support.

uv-package-manager covers python dependency management, virtual environments, and project setup using the rust-based uv tool. provides installation, package workflows, version pinning, and migration patterns from pip and poetry.

dependency-upgrade covers semantic versioning, staged rollout phases, breaking change handling via codemods, and multi-layer testing (unit, integration, visual, e2e). includes automation configs for renovate and dependabot with rollback scaffolding.

monorepo-management covers turborepo and nx setup, workspace configuration, package structure patterns, and publishing strategies for multi-package repositories. practical for initial setup and optimization, but lacks decision frameworks and failure recovery.

startup-metrics-framework provides a reference compendium of formulas and benchmarks for tracking saas, marketplace, consumer, and b2b metrics across funding stages. it reads as a metrics encyclopedia rather than an actionable skill.

airflow-dag-patterns covers dag design principles, task dependency patterns, and production deployment strategies with a quick-start example. best practices section addresses common pitfalls but lacks depth on testing, custom operators, and failure recovery.

wshobson-code-review-excellence covers systematic code review with emphasis on constructive feedback, security patterns, and language-specific checks. provides frameworks for prioritizing concerns and handling disagreements, though lacks concrete decision logic for merge/reject verdicts.

sast-configuration covers setup and tuning of semgrep, sonarqube, and codeql for automated code scanning. provides ci/cd integration patterns, custom rule examples, and troubleshooting guidance across multiple languages.

architecture-patterns covers clean, hexagonal, and domain-driven design with directory structures and code examples for python backends, though lacks concrete procedural steps and edge case acknowledgment.

bash-defensive-patterns covers strict mode, quoting discipline, error trapping, and input validation for production shell scripts. includes best practices for logging, idempotency, and cross-platform compatibility.

kpi-dashboard-design covers patterns for multi-level dashboards (strategic, tactical, operational) with department-specific templates, layout examples, and implementation code for sales, marketing, product and finance teams.

signed-audit-trails-recipe documents a cryptographic receipt pattern for claude code tool calls, covering cedar policy evaluation, ed25519 signing, and offline verification workflows. teaching-focused, references runtime implementation separately.

angular-migration covers hybrid app setup, component and service conversion patterns, and dependency injection interop between angularjs and angular. lacks step-by-step migration sequencing and failure recovery guidance.

openapi-spec-generation provides patterns for creating and maintaining openapi 3.1 specifications across design-first, code-first, and hybrid approaches. covers spec structure, best practices, and validation but lacks procedural depth.

gitops-workflow covers argocd and flux cd setup for declarative kubernetes deployments, including repository structure, sync policies, progressive delivery patterns, and secret management with external secrets operator and sealed secrets.

wshobson-protocol-reverse-engineering provides tools and techniques for traffic capture, binary parsing, and protocol analysis, with working code examples in python and lua but minimal decision logic or failure recovery.

wshobson-dbt-transformation-patterns covers medallion architecture, naming conventions, and project structure for dbt analytics engineering. includes configuration templates and best practice do's/don'ts but lacks procedural depth for actual implementation.

ml-pipeline-workflow outlines mlops orchestration from data ingestion through model deployment. covers dag patterns, validation frameworks, and deployment strategies across airflow, dagster, and kubernetes. prescriptive on architecture but thin on operational detail.

competitive-landscape provides structured frameworks (porter's five forces, blue ocean strategy, positioning maps) for analyzing market dynamics and identifying differentiation opportunities, but lacks specific execution triggers and concrete failure mode handling.

startup-financial-modeling covers revenue projections, cost structures, and cash flow analysis for early-stage companies. provides templates for saas, marketplace, and e-commerce models with scenario planning and validation checkpoints, but lacks executable procedures and specific tool integration.

slo-implementation defines service level indicators, objectives and error budgets to balance reliability targets with development velocity. includes prometheus rules, burn rate calculations, multi-window alerting and compliance review frameworks.

react-state-management covers patterns and tool selection across local, global, server, and form state, with code examples for zustand and redux toolkit migration but lacks step-by-step decision procedures and failure recovery.

react-native-design covers styling patterns, react navigation, and reanimated 3 for cross-platform mobile apps. provides a working component example and best practices but lacks procedural depth for implementation tasks.

design-system-patterns covers token hierarchies, theming infrastructure, and component architecture for building consistent ui foundations. emphasizes naming conventions, multi-platform generation, and figma-to-code workflows but lacks actionable step-by-step procedures.

react-modernization covers version upgrades across react 16-18, class-to-hooks migration patterns, concurrent features like suspense, and codemod automation. includes typescript guidance and performance optimization techniques.

k8s-manifest-generator covers best practices for building deployments, services, configmaps, secrets, and pvcs with resource limits, health checks, and security contexts. references external details documentation.

pci-compliance outlines the 12 core pci dss requirements for payment card data handling, including tokenization, encryption, and audit logging strategies with compliance level guidance.

team-composition-analysis provides templated hiring plans, compensation benchmarks, and equity allocation ranges for pre-seed through series a startups. lacks actionable decision procedures, failure mode handling, and integration with real hiring data or market signals.

temporal-python-testing covers pytest-based testing strategies for temporal workflows, including unit testing with time-skipping, integration testing with mocked activities, replay testing for determinism validation, and ci/cd pipeline setup.

wshobson-grafana-dashboards covers dashboard design patterns, panel types, and provisioning templates. lacks actionable procedures for common failure modes and decision logic for dashboard architecture choices.

workflow-orchestration-patterns documents when to apply temporal-based orchestration in distributed systems, emphasizing use cases over concrete implementation. introduces saga patterns and state management but lacks procedural depth.

hybrid-cloud-networking covers connectivity patterns and configuration snippets for aws, azure, gcp, and oci. lacks procedural depth, decision trees, and explicit failure recovery paths.

prompt-engineering-patterns covers six core capability areas including few-shot learning, chain-of-thought reasoning, structured outputs, prompt optimization, templates, and role-based design with patterns for testing, versioning, and monitoring.

scan generates project-doc.md and AGENTS.md from codebase inspection, with optional plugin enhancements and native fallback paths for plugin unavailability.

python-resource-management covers deterministic cleanup patterns using context managers for connections, file handles, and streaming scenarios, with guidance on custom and async implementations.

python-packaging outlines modern python distribution workflows with pyproject.toml setup, but lacks actionable procedures and doesn't address common pitfalls like version conflicts or failed uploads.

api-design-principles covers rest and graphql fundamentals, versioning strategies, and common pitfalls. treatment remains conceptual rather than prescriptive, lacking worked decision trees for real design trade-offs.

gdpr-data-handling outlines legal bases, data categories, and subject rights with do/don't guidelines, but lacks concrete implementation procedures for consent flows, dsr handling, or compliance workflows.

auth-implementation-patterns covers authentication and authorization fundamentals including session, jwt, and oauth2 strategies with best practices and common pitfalls, but lacks actionable implementation procedures.

on-call-handoff-patterns provides templates and timing guidance for shift transitions including incident context, escalation procedures, and checklists for both outgoing and incoming engineers.

wshobson-on-call-handoff-patterns covers shift transition choreography, incident context transfer, and documentation discipline. provides timing templates and troubleshooting patterns but lacks concrete procedural depth and actionable checklists.

wcag-audit-patterns provides conformance level taxonomy and violation categories but lacks procedural depth. it references external detail documentation and offers best-practice checklist rather than executable audit workflow.

helm-chart-scaffolding covers chart creation, templating patterns, values management, and validation for kubernetes application packaging. provides best practices and basic troubleshooting but lacks actionable step sequences.

nodejs-backend-patterns outlines architectural approaches for express/fastify services including middleware, authentication, and database layers, but lacks concrete procedural steps and actionable decision trees.

team-communication-protocols defines message type selection and team coordination patterns for multi-agent systems, covering direct messaging, broadcast, and shutdown workflows with documented anti-patterns.

distributed-tracing covers implementing jaeger and tempo for request visibility across microservices. includes best practices for sampling, context propagation, and overhead monitoring with basic troubleshooting patterns.

security-requirement-extraction bridges threat models and actionable requirements through structured categorization, traceability rules, and testability constraints. maps threats to functional, non-functional, and constraint-based security controls.

accessibility-compliance covers wcag 2.2 implementation patterns, screen reader support, keyboard navigation, and mobile accessibility testing. references external detail docs for worked examples.

stride-analysis-patterns provides categorical threat taxonomy and a decision matrix for systematic security review, but lacks step-by-step execution guidance and defers concrete procedures to external references.

mobile-android-design covers material design 3 and jetpack compose patterns for building native android apps, with material theming, adaptive layouts, and accessibility guidance, but lacks procedural depth and concrete decision logic.

wshobson-prompt-engineering-patterns covers techniques for few-shot learning, chain-of-thought reasoning, structured outputs, and prompt optimization. includes code examples and best practices but lacks procedural depth and failure mode handling.

incident-runbook-templates provides structured scaffolding for incident response procedures including severity classification, but lacks executable detail. the skill reads as a starter framework rather than actionable runbooks with concrete steps and failure handling.

multi-cloud-architecture provides service comparison tables and four architectural patterns (single provider with dr, best-of-breed, geographic distribution, cloud-agnostic abstraction) with a four-phase migration strategy. lacks concrete decision logic and failure handling.

uv-package-manager covers installation, virtual environment setup, dependency management, and python version pinning for the rust-based uv tool. procedural patterns are provided but lack failure recovery and edge case handling.

wshobson-solidity-security provides pattern examples for reentrancy guards, integer overflow prevention, and access control testing via hardhat, but lacks structured decision flows and systematic vulnerability enumeration.

wshobson-rust-async-patterns covers tokio fundamentals, task spawning, channels, and error handling for concurrent rust systems. delegates deep patterns to external references/details.md file.

hybrid-search-implementation covers combining vector and keyword search via fusion methods like RRF and cross-encoders, with best practices for tuning and reranking. concrete templates live elsewhere.

parallel-feature-development provides guidance on decomposing features into parallel work streams, establishing file ownership boundaries, and coordinating multi-agent implementation through interface contracts and integration strategies.

vector-index-tuning covers parameter selection and quantization strategies for HNSW and other index types, with decision tables mapping data scale to index choice and guidance on balancing latency against recall.

wshobson-react-native-architecture provides project structure, expo setup, and navigation patterns for react native development. lacks procedural depth, edge case handling, and decision trees for production scenarios.

k8s-security-policies covers network segmentation, pod security standards, rbac configuration, and admission control via templates and examples. references benchmarks for compliance validation and includes troubleshooting commands.

gitlab-ci-patterns covers multi-stage pipeline construction with docker builds, kubernetes deployments, and security scanning templates. lacks detailed procedural steps and explicit failure handling.

visual-design-foundations provides modular templates for typography scales, spacing grids, semantic color tokens, and icon systems with wcag compliance guidance, but lacks concrete procedural steps and failure mode handling.

database-migration covers sequelize, typeorm, and prisma migrations with zero-downtime patterns, schema transformations, and rollback strategies across postgresql, mysql, and other platforms.

spark-optimization covers partitioning, caching, shuffle reduction, and memory configuration for apache spark jobs, with patterns for join strategies, data formats, and query plan debugging.

wshobson-helm-chart-scaffolding covers helm chart creation and organization with best practice checklists and basic troubleshooting commands, but lacks actionable procedures and failure mode handling.

defi-protocol-templates provides solidity code samples for staking and amm contracts but lacks procedural guidance, failure mode analysis, and integration instructions. suitable only as a code reference, not a skill.

unity-ecs-patterns covers dots fundamentals, component design, and system architecture for high-performance games. lacks worked examples, concrete decision flows, and failure recovery strategies.

attack-tree-construction provides conceptual grounding and ascii diagrams for threat modeling, but lacks procedural depth. no worked example, no decision tree for when to use AND vs OR nodes, no guidance on tree scope or depth limits.

backtesting-frameworks outlines approaches to building trading strategy backtests with bias mitigation. content covers conceptual foundations but lacks actionable implementation details and concrete walkthroughs.

brand-landingpage guides users through brand identity and visual strategy to produce a landing page, but the actual execution procedure is undefined and the skill ends at setup without covering the design interview, generation loop, or output contract.

risk-metrics-calculation provides conceptual grounding in portfolio risk measurement (var, cvar, sharpe, sortino, drawdown) but lacks actionable procedural steps, concrete trigger conditions, and implementation specifics needed for cross-vendor orchestration.

billing-automation outlines subscription lifecycle states, dunning recovery, and proration concepts. the quickstart snippet shows api calls but lacks end-to-end decision logic, error handling, and integration choreography needed for production systems.

changelog-automation documents conventional commits and keep a changelog format with examples and best practices, but lacks concrete automation procedures, tooling guidance, and failure handling.

context-driven-development outlines managing project documentation artifacts (product.md, tech-stack.md, workflow.md, tracks.md) alongside code, but lacks concrete procedures and decision logic to be actionable.

wshobson-tailwind-design-system documents tailwind css v4 setup with design tokens and theming via css variables, but lacks actionable procedures for building actual components and omits error handling or migration failure scenarios.

wshobson-auth-implementation-patterns covers authentication and authorization concepts, strategies, and best practices but lacks concrete, step-by-step implementation procedures and decision logic needed to apply patterns in real systems.

wshobson-backtesting-frameworks outlines common biases in strategy backtesting and identifies mitigation patterns like walk-forward analysis and out-of-sample validation, but lacks concrete implementation procedures or executable workflows.

wshobson-market-sizing-analysis covers tam/sam/som frameworks and three analytical methodologies (top-down, bottom-up, value theory) for market opportunity estimation. lacks concrete procedures, decision logic, and failure handling.

employment-contract-templates provides templated language for offer letters, employment agreements, and handbook sections with jurisdiction and classification guidance, but lacks actionable procedures and edge case handling.

wshobson-gdpr-data-handling covers legal bases, data categories, and subject rights with best practice do's and don'ts, but lacks concrete procedures for implementing consent flows, dsar handling, or compliance audits.

wshobson-api-design-principles covers rest and graphql design patterns, versioning strategies, and best practices, but lacks concrete procedures and actionable workflows for real design decisions.

threat-mitigation-mapping provides conceptual frameworks for linking security threats to preventive, detective, and corrective controls across network, application, data, endpoint, and process layers, but lacks actionable procedures for execution.

wshobson-nodejs-backend-patterns covers framework selection and best practice checklists for node.js services, but lacks concrete procedural guidance, worked examples, and decision logic needed for implementation.

modern-javascript-patterns documents es6+ syntax and functional programming conventions. lacks concrete procedures, executable steps, and measurable outcomes. reads as a style guide rather than a skill with verifiable completion criteria.

protocol-reverse-engineering provides wireshark command snippets for packet capture but lacks procedural depth, decision logic, and systematic guidance for actual protocol dissection or documentation.

anti-reversing-techniques documents protection mechanisms encountered in authorized malware analysis and security research, but lacks actionable procedures and specific trigger conditions for real-world application.

nx-workspace-patterns describes when to apply nx monorepo management but lacks substantive procedure. the content is incomplete, offering intent and trigger contexts without actionable steps or failure-mode recovery.

data-quality-frameworks outlines conceptual foundations for implementing validation with great expectations, dbt tests, and data contracts. content stops at definitions without actionable procedure or failure guidance.

wshobson-godot-gdscript-patterns outlines godot architecture and gdscript syntax basics with a player class example, but lacks concrete procedural guidance for implementing the advertised patterns (signals, state machines, optimization).

Design optimal agent team compositions with sizing heuristics, preset configurations, and agent type selection. Use this skill when deciding how many agents to…

Configure mutual TLS (mTLS) for zero-trust service-to-service communication. Use when implementing zero-trust networking, certificate management, or securing…

Configure Istio traffic management including routing, load balancing, circuit breakers, and canary deployments. Use when implementing service mesh traffic…

Optimize Bazel builds for large-scale monorepos. Use when configuring Bazel, implementing remote execution, or optimizing build performance for enterprise…

Use this skill when creating, managing, or working with Conductor tracks - the logical work units for features, bugs, and refactors. Applies to spec.md,…

Integrate PayPal payment processing with support for express checkout, subscriptions, and refund management. Use when implementing PayPal payments, processing…

Implement saga patterns for distributed transactions and cross-aggregate workflows. Use this skill when implementing distributed transactions across…

Implement efficient similarity search with vector databases. Use when building semantic search, implementing nearest neighbor queries, or optimizing retrieval…

Master binary analysis patterns including disassembly, decompilation, control flow analysis, and code pattern recognition. Use when analyzing executables,…

Use this skill when implementing tasks according to Conductor's TDD workflow, handling phase checkpoints, managing git commits for tasks, or understanding the…

Design and implement event stores for event-sourced systems. Use when building event sourcing infrastructure, choosing event store technologies, or…

Master dbt (data build tool) for analytics engineering with model organization, testing, documentation, and incremental strategies. Use when building data…

Implement Command Query Responsibility Segregation for scalable architectures. Use when separating read and write models, optimizing query performance, or…

Master ShellCheck static analysis configuration and usage for shell script quality. Use when setting up linting infrastructure, fixing code issues, or ensuring…

Set up Prometheus for comprehensive metric collection, storage, and monitoring of infrastructure and applications. Use when implementing metrics collection,…

Python resilience patterns including automatic retries, exponential backoff, timeouts, and fault-tolerant decorators. Use when adding retry logic, implementing…

Master Go concurrency with goroutines, channels, sync primitives, and context. Use when building concurrent Go applications, implementing worker pools, or…

Calculate TAM/SAM/SOM for market opportunities using top-down, bottom-up, and value theory methodologies. Use this skill when sizing markets, estimating…

Select and optimize embedding models for semantic search and RAG applications. Use when choosing embedding models, implementing chunking strategies, or…

Optimize cloud costs across AWS, Azure, GCP, and OCI through resource rightsizing, tagging strategies, reserved instances, and spending analysis. Use when…

Implement secure secrets management for CI/CD pipelines using Vault, AWS Secrets Manager, or native platform solutions. Use when handling sensitive…

Create and manage production Grafana dashboards for real-time visualization of system and application metrics. Use when building monitoring dashboards,…

Design microservices architectures with service boundaries, event-driven communication, and resilience patterns. Use when building distributed systems,…

Master React, Vue, and Svelte component patterns including CSS-in-JS, composition strategies, and reusable component architecture. Use when building UI…

Design LLM applications using LangChain 1.x and LangGraph for agents, memory, and tool integration. Use when building LangChain applications, implementing AI…

Master systematic debugging techniques, profiling tools, and root cause analysis to efficiently track down bugs across any codebase or technology stack. Use…

Python error handling patterns including input validation, exception hierarchies, and partial failure handling. Use when implementing validation logic,…

Implement Stripe payment processing for robust, PCI-compliant payment flows including checkout, subscriptions, and webhooks. Use when integrating Stripe…

Build production React Native apps with Expo, navigation, native modules, offline sync, and cross-platform patterns. Use when developing mobile apps,…

Master smart contract security best practices to prevent common vulnerabilities and implement secure Solidity patterns. Use when writing smart contracts,…

Transform data into compelling narratives using visualization, context, and persuasive structure. Use when presenting analytics to stakeholders, creating data…

Master Godot 4 GDScript patterns including signals, scenes, state machines, and optimization. Use when building Godot games, implementing game systems, or…

Write and maintain Architecture Decision Records (ADRs) following best practices for technical decision documentation. Use when documenting significant…

Master C#/.NET backend development patterns for building robust APIs, MCP servers, and enterprise applications. Covers async/await, dependency injection,…

Master advanced Git workflows including rebasing, cherry-picking, bisect, worktrees, and reflog to maintain clean history and recover from any situation. Use…

Master SQL query optimization, indexing strategies, and EXPLAIN analysis to dramatically improve database performance and eliminate slow queries. Use when…

Implement modern responsive layouts using container queries, fluid typography, CSS Grid, and mobile-first breakpoint strategies. Use when building adaptive…

Python design patterns including KISS, Separation of Concerns, Single Responsibility, and composition over inheritance. Use this skill when designing a new…

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…

Create production-ready FastAPI projects with async patterns, dependency injection, and comprehensive error handling. Use when building new FastAPI…

Implement comprehensive testing strategies with pytest, fixtures, mocking, and test-driven development. Use when writing Python tests, setting up test suites,…

Profile and optimize Python code using cProfile, memory profilers, and performance best practices. Use when debugging slow Python code, optimizing bottlenecks,…

Build scalable design systems with Tailwind CSS v4, design tokens, component libraries, and responsive patterns. Use when creating component libraries,…

Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe…

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.

Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe applications. Use when implementing complex type logic, creating reusable type utilities, or ensuring compile-time type safety in TypeScript projects.

Implement WCAG 2.2 compliant interfaces with mobile accessibility, inclusive design patterns, and assistive technology support. Use when auditing accessibility, implementing ARIA patterns, building for screen readers, or ensuring inclusive user experiences.

>-

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.

Transform data into compelling narratives using visualization, context, and persuasive structure. Use when presenting analytics to stakeholders, creating data reports, or building executive presentations.

Design effective KPI dashboards with metrics selection, visualization best practices, and real-time monitoring patterns. Use this skill when building an executive SaaS metrics dashboard tracking MRR, churn, and LTV/CAC ratios; designing an operations center with live service health and request throughput; creating a cohort retention analysis view for a product team; or debugging a dashboard where metrics contradict each other due to inconsistent calculation methodology.

Python configuration management via environment variables and typed settings. Use when externalizing config, setting up pydantic-settings, managing secrets, or implementing environment-specific behavior.

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.

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.

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.

Build Retrieval-Augmented Generation (RAG) systems for LLM applications with vector databases and semantic search. Use when implementing knowledge-grounded AI, building document Q&A systems, or integrating LLMs with external knowledge bases.

Master React Native styling, navigation, and Reanimated animations for cross-platform mobile development. Use when building React Native apps, implementing navigation patterns, or creating performant animations.

Design LLM applications using LangChain 1.x and LangGraph for agents, memory, and tool integration. Use when building LangChain applications, implementing AI agents, or creating complex LLM workflows.

Create production-ready GitHub Actions workflows for automated testing, building, and deploying applications. Use when setting up CI/CD with GitHub Actions, automating development workflows, or creating reusable workflow templates.

Master Material Design 3 and Jetpack Compose patterns for building native Android apps. Use when designing Android interfaces, implementing Compose UI, or following Google's Material Design guidelines.

Create production-ready FastAPI projects with async patterns, dependency injection, and comprehensive error handling. Use when building new FastAPI applications or setting up backend API projects.

Optimize vector index performance for latency, recall, and memory. Use when tuning HNSW parameters, selecting quantization strategies, or scaling vector search infrastructure.

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.