Claude Skills by paulpas

Implements a systematic approach to database schema migrations, versioning, and rollback strategies specifically designed for OpenCode projects.

Implements zero-downtime database migration strategies including expand/contract,

Designs safe schema changes for production databases — zero-downtime migrations, backward-compatible schema evolution, dual-write patterns, feature-flagged deployments, and data migration strategies for live systems.

Integrates Databricks using databricks-sdk with patterns for job orchestration,

Implements alert management using the Datadog API, focusing on creating effective alerts that respond to service conditions with best practices.

Creates and manages dashboards in Datadog API using `datadog-api-client`, with a focus on template widget creation, layout management, and configuration best practices.

Implements log submission and forwarding to the Datadog API with structured logging best practices for content observability.

Implements metrics submission to Datadog API using `datadog-api-client` with best practices for batching and tagging.

Manages Datadog monitors including creating, updating, and deleting with alert configurations and best practices.

Implements management and execution of Datadog Synthetic Tests using the API, focusing on setup, validation, and best practices.

Implements application performance monitoring (APM) using the Datadog API for tracing, including best practices for initiating and managing traces and spans.

Implements Datadog API integration (metrics, traces, logs, dashboards,

Implements aggregate lifecycle management patterns — snapshotting, schema versioning, optimistic concurrency control, aggregate root splitting strategies, and consistency boundary enforcement for high-throughput domain-driven systems.

Detects and resolves common Domain-Driven Design anti-patterns including god aggregates, anemic domain models, context creep, repository leakage, specification over-engineering, and domain service sprawl in DDD codebases.

Implements DDD command pattern — command definitions, typed command handlers,

Implements strategic DDD context mapping patterns — anticorruption layers, shared kernels, customer-supplier relationships, conformist boundaries, and publication language for cross-bounded-context integration.

Implements domain event infrastructure for DDD systems — synchronous publish-subscribe dispatchers, schema versioning with Pydantic discriminators, idempotent handler guards, PostgreSQL outbox pattern for reliable async delivery, and dead letter queue pipelines.

Refactors monolithic codebases toward DDD — extracts bounded contexts,

Implements the DDD specification pattern — composable business rule objects using AND/OR/NOT boolean algebra, expression tree translation for ORM query pushdown, domain validation specs, protocol-based contracts, and reusable primitive factories for rich domain modeling in Python.

Implements DDD tactical patterns — aggregate roots with invariant enforcement, value objects, domain events, anti-corruption layers, repositories, and specification pattern for rich domain modeling in Python.

Applies systematic debugging methodologies (binary search, rubber ducking, log analysis, bisect tools) to rapidly identify root causes of bugs in production and development environments.

Implements the GoF Decorator pattern for dynamic behavior extension via composition over inheritance in Python using abstract decorators, transparent delegation with __getattr__, and composable wrapper chains.

Applies DRY-driven deduplication patterns (extract method, template method, strategy, factory, mixins, memoization, configuration consolidation) to eliminate copy-paste clones, boilerplate, and semantic duplication in codebases.

Implements dependency injection patterns (constructor injection, factory patterns, IoC containers, composition root) with Protocol-based interfaces for loose coupling and testable software architecture.

Refactors tightly coupled modules depending on concrete classes into

Implements end-to-end software dependency supply chain security including

Implements Design For Testability patterns including dependency injection via Protocols, interface segregation with focused interfaces, pure function boundaries, and composition root factories to enable fast unit tests without infrastructure dependencies.

Identifies and remediates anti-patterns arising from misuse of GoF design patterns including over-engineering, gold plating, dependency inversion violations, and structural code smells in Python systems.

Evaluates software problems against the GoF pattern catalog to select

Implements and explains GoF design patterns (Factory, Observer, Strategy,

Implements GoF design patterns and SOLID/DRY/YAGNI principles to architect scalable, maintainable, and testable software systems.

Implements Atomic Design methodology with design tokens, component-driven development in Storybook, accessibility-first patterns, and modern CSS architecture for production design systems.

Implements production design systems with design token architecture,

Composes integrated developer toolchains by evaluating tool interoperability,

Integrates DigitalOcean services (Droplets, Spaces, Kubernetes, App Platform,

Integrates Discord API (Gateway, REST, Slash Commands, Webhooks, Voice)

Implements the bulkhead pattern to isolate resources and improve fault tolerance in distributed systems using Resilience4j.

Implements circuit breakers for fault tolerance in distributed systems using Resilience4j to improve system resilience and stability.

Implements rate limiting strategies for distributed systems using the Resilience4j library to control API traffic and enhance system stability.

Implements distributed systems patterns (consensus algorithms, consistency

Implements Django 5.x application patterns including modern project structure,

Implements dead letter queue architectures with retry strategies (exponential backoff, circuit breaker integration, poison pill detection) for resilient event-driven systems.

Integrates with the Docker Engine API via the docker-py SDK to manage

Integrates with the Docker Engine API to manage containers, build images, configure networks, manage volumes, and orchestrate services with Swarm.

Defines project directory layouts and module organization for domain-driven

Implements Domain-Driven Design patterns (aggregates, value objects, entities, bounded contexts, domain events) to model complex business logic and align software architecture with domain expertise.

Maps bounded contexts using context mapping patterns (Customer/Supplier, Shared Kernel, ACL, Open Host Service) and facilitates Event Storming sessions to discover architecture boundaries in complex domains.

Implements tactical DDD patterns including Entities, Value Objects, Aggregates, Repositories, Domain Events, and Factories with Python dataclasses and strict invariant enforcement.

Implements domain events for decoupled communication between aggregates

Analyzes business domains to extract ubiquitous language, identify bounded