@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.

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.

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.

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.

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.

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.

protect-mcp enforces cedar policy gates on claude code tool calls and produces ed25519-signed, hash-chained receipts for offline verification. designed for compliance contexts where audit trails must be tamper-evident and third-party verifiable.

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-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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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-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.

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.

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.

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.

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.

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.

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.

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-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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

turborepo-caching covers monorepo build optimization through local and remote caching configuration, but stops short of actionable implementation details and concrete configuration examples needed for real-world deployment.

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-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.

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.

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-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-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-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.

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.

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.

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.

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).

PluginEval quality methodology — dimensions, rubrics, statistical methods, and scoring formulas. Use this skill when understanding how plugin quality is…

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

Coordinate parallel code reviews across multiple quality dimensions with finding deduplication, severity calibration, and consolidated reporting. Use this…

Implement Linkerd service mesh patterns for lightweight, security-focused service mesh deployments. Use when setting up Linkerd, configuring traffic policies,…

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…

Configure Static Application Security Testing (SAST) tools for automated vulnerability detection in application code. Use when setting up security scanning,…

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

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

Implement distributed tracing with Jaeger and Tempo to track requests across microservices and identify performance bottlenecks. Use when debugging…

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

Combine vector and keyword search for improved retrieval. Use when implementing RAG systems, building search engines, or when neither approach alone provides…

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

Python background job patterns including task queues, workers, and event-driven architecture. Use when implementing async task processing, job queues,…

Migrate from AngularJS to Angular using hybrid mode, incremental component rewriting, and dependency injection updates. Use when upgrading AngularJS…

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

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

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

Calculate portfolio risk metrics including VaR, CVaR, Sharpe, Sortino, and drawdown analysis. Use when measuring portfolio risk, implementing risk limits, 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…

Track, calculate, and optimize key performance metrics for SaaS, marketplace, consumer, and B2B startups from seed through Series A, including unit economics,…

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

Python observability patterns including structured logging, metrics, and distributed tracing. Use when adding logging, implementing metrics collection, setting…

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

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

Apply STRIDE methodology to systematically identify threats. Use when analyzing system security, conducting threat modeling sessions, or creating security…

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

Build automated billing systems for recurring payments, invoicing, subscription lifecycle, and dunning management. Use when implementing subscription billing,…

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

Implement GitOps workflows with ArgoCD and Flux for automated, declarative Kubernetes deployments with continuous reconciliation. Use when implementing GitOps…

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

Implement comprehensive evaluation strategies for LLM applications using automated metrics, human feedback, and benchmarking. Use when testing LLM performance,…

Conduct WCAG 2.2 accessibility audits with automated testing, manual verification, and remediation guidance. Use when auditing websites for accessibility,…

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,…

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

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

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

Master authentication and authorization patterns including JWT, OAuth2, session management, and RBAC to build secure, scalable access control systems. Use when…

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 project organization, module architecture, and public API design. Use when setting up new projects, organizing modules, defining public interfaces with…

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

Implement WCAG 2.2 compliant interfaces with mobile accessibility, inclusive design patterns, and assistive technology support. Use when auditing…

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

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

Build scalable design systems with design tokens, theming infrastructure, and component architecture patterns. Use when creating design tokens, implementing…

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

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…

Generate and maintain OpenAPI 3.1 specifications from code, design-first specs, and validation patterns. Use when creating API documentation, generating SDKs,…

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

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

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

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

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

Implement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. Use this skill when designing…

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…

Use this skill when designing or reviewing a PostgreSQL-specific schema. Covers best-practices, data types, indexing, constraints, performance patterns, and…

Master REST and GraphQL API design principles to build intuitive, scalable, and maintainable APIs that delight developers. Use when designing new APIs,…

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,…

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

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

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 smart contract security best practices to prevent common vulnerabilities and implement secure Solidity patterns. Use when writing smart contracts, auditing existing contracts, or implementing security measures for blockchain applications.

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.

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 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.

Python code style, linting, formatting, naming conventions, and documentation standards. Use when writing new code, reviewing style, configuring linters, writing docstrings, or establishing project standards.

Build scalable design systems with Tailwind CSS v4, design tokens, component libraries, and responsive patterns. Use when creating component libraries, implementing design systems, or standardizing UI patterns.

Implement modern responsive layouts using container queries, fluid typography, CSS Grid, and mobile-first breakpoint strategies. Use when building adaptive interfaces, implementing fluid layouts, or creating component-level responsive behavior.

Master REST and GraphQL API design principles to build intuitive, scalable, and maintainable APIs that delight developers. Use when designing new APIs, reviewing API specifications, or establishing API design standards.

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.

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.

Design and implement microinteractions, motion design, transitions, and user feedback patterns. Use when adding polish to UI interactions, implementing loading states, or creating delightful user experiences.

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.

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.

Build production-ready Node.js backend services with Express/Fastify, implementing middleware patterns, error handling, authentication, database integration, and API design best practices. Use when creating Node.js servers, REST APIs, GraphQL backends, or microservices architectures.

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.