Claude Skills by paulpas

'"Implements Monte Carlo sampling, simulation methods, and stochastic

'"Implements deep neural networks, backpropagation, activation functions

'"Analyzes observational data using matching methods, propensity scores

'"Implements multi-armed bandits, contextual bandits, exploration-exploitation

'"Implements privacy-preserving machine learning including differential

'"Provides Designs and analyzes randomized controlled trials (RCTs)

'"Evaluates regression models using MSE, RMSE, MAE, MAPE, R-squared

'"Implements reproducible research practices including code organization

'"Analyzes statistical power, sample size determination, effect size

'"Implements support vector machines (SVM) with kernel methods, support

'"Implements synthetic control methods, difference-in-differences estimation

'"Implements ARIMA, exponential smoothing, state-space models, LSTM networks

'"Implements topic modeling using Latent Dirichlet Allocation (LDA)

'"Implements decision trees, random forests, gradient boosting (XGBoost"

Designs and implements domain-specific languages (embedded DSLs with Python/Go idioms, external DSLs with PEG/ANTLR/Lark parsers) for configuration, query, and rule engines in production systems.

Integrates Elasticsearch using elasticsearch-py 8.x with patterns for

Integrates ElevenLabs API (text-to-speech, voice cloning, speech-to-text,

Designs and implements production REST APIs and GraphQL schemas with versioning, authentication, pagination, rate limiting, OpenAPI documentation, and error handling for scalable service interfaces.

Designs robust error handling strategies including typed exception hierarchies, graceful degradation, retry with exponential backoff, circuit breakers, structured logging, and panic prevention across software systems.

Resolves contradictions between SOLID, DRY, KISS, and YAGNI principles using a structured decision framework with trade-off analysis and domain-context scoring for architecture decisions.

Enforces core software engineering principles (SOLID, DRY, KISS, separation

Evaluates competing engineering options using weighted decision matrices,

Implements Microsoft Entra ID (Azure AD) API integration (Users, Groups,

Implements modern error handling patterns (Result types, error wrapping, retry with backoff, circuit breakers, panic recovery) to eliminate unchecked exceptions and silent failures in production systems.

Implements modern Python error handling patterns including custom exception hierarchies, context propagation, result types, and graceful degradation for resilient production systems.

'"Async pub/sub event bus with typed events, mixed sync/async dispatch"

Implements event-driven architecture patterns including pub/sub messaging with RabbitMQ and Kafka, schema registry management, dead letter queue handling, idempotent consumer design, database outbox pattern, and event streaming for asynchronous system coordination.

Implements event-driven architecture patterns (pub/sub, event sourcing,

Implements event schema versioning strategies (semantic versioning, forward/backward compatibility, schema registry, deprecation lifecycle) to evolve event contracts in production event-driven systems without breaking consumers.

Implements event sourcing pattern (event store, aggregate roots, projections,

Persists application state as an append-only immutable event log, enabling

Facilitates collaborative EventStorming workshops to discover bounded

Manages eventual consistency challenges in distributed systems — read model reconciliation, conflict resolution with CRDTs and vector clocks, anti-corruption layers, and stale read mitigation for event-driven architectures.

Implements expression evaluation engines (arithmetic, conditional logic, string manipulation, function dispatch) for configuration-driven workflows, rule engines, and dynamic computation without hard-coded code paths.

Designs robust extensible software frameworks with plugin architectures, configuration-driven extension points, and validation patterns — enabling third-party contributors while maintaining core stability and API contract guarantees.

Implements the GoF Factory Method pattern for polymorphic object creation in Python using ABC-based factories, registration decorators, and type dispatch to replace if/elif chains with extensible factory hierarchies.

Implements FastAPI application patterns including dependency injection, Pydantic v2 models, async handlers, JWT authentication, middleware chains, background tasks, and production deployment strategies for high-performance Python web services.

'"FastAPI application structure with typed error hierarchy, global exception"

Implements feature flag systems with progressive delivery, A/B testing, and gradual rollout strategies for safe application-level feature deployment without code changes.

Integrates Firebase using firebase-admin 7.x with patterns for Firestore

Evaluates and integrates new frameworks into existing projects using

Orchestrates structured framework adoption through phased rollout planning,

Systematically learns, evaluates, and applies new software frameworks using proven methodology — source code analysis, prototype validation, pattern mapping, and iterative adoption for maximum engineering impact.

Translates framework requirements into concrete architectural decisions including module boundaries, layering strategies, extension point placement, data flow design, and dependency topology that respect the chosen framework's paradigms.

Runs structured, code-level comparison workflows between competing frameworks through spike projects, side-by-side implementations, developer experience measurement, and ecosystem analysis to produce evidence-based selection recommendations.

Translates framework constraints into concrete architectural blueprints

Implements framework-driven design patterns (Inversion of Control, Dependency Injection, lifecycle hooks, plugin architectures) to build extensible applications that leverage modern framework constraints instead of bypassing them.

Systematically elicits evaluation criteria across technical, team, ecosystem, security, deployment, integration, cost, and viability dimensions to prevent hype-driven framework selection. Produces structured requirement matrices, weighted scoring frameworks, and decision records with documented trade-offs.

Runs automated empirical evaluation of software frameworks through reproducible benchmark harnesses, dependency graph security auditing, integration feasibility testing, and maintenance cost modeling to produce quantitative selection data.

Evaluates and scores competing frameworks using weighted criteria matrices,