sethdford/claude-skills - Page 3

solid-principles

SOLID principles (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) for object-oriented design.

connection-pool-management

Pool sizing, connection lifetime, health checks, and resource exhaustion prevention.

data-integrity-patterns

Constraints, triggers, audit trails, referential integrity, and data validation.

index-design

B-tree indexes, composite indexes, covering indexes, UNIQUE indexes, and index trade-offs.

migration-strategy

Safe schema migrations, backward compatibility, zero-downtime deployments, and rollback strategies.

query-optimization

EXPLAIN PLAN analysis, index selection, join strategies, and slow query debugging.

schema-design

Database schema design with normalization, relationships, constraints, and data integrity.

transaction-management

ACID properties, isolation levels, locks, deadlocks, and transaction design.

binary-search-debugging

Using bisect/git bisect to isolate failure to exact commit or code path.

concurrency-debugging

Race conditions, deadlocks, thread analysis, happens-before relationships.

log-analysis

Parsing logs, correlation analysis, reconstructing timeline of failures.

memory-leak-detection

Detecting memory leaks through heap dumps, retention analysis, and reference tracing.

performance-profiling

CPU/memory profiling, identifying bottlenecks, flame graphs, hotspot analysis.

postmortem-analysis

Writing comprehensive postmortems: timeline, root cause, prevention, action items.

root-cause-analysis

Five Whys, fishbone diagrams, identifying systemic causes not just symptoms.

systematic-debugging

Disciplined methodology to isolate bugs through hypothesis-driven testing. Form hypotheses, test them with minimal changes, narrow scope systematically. Use when bugs are unclear or reproduce intermittently.

alerting-strategy

SLO-based alerting, threshold tuning, incident escalation, runbooks, and on-call management.

ci-cd-pipeline-design

GitHub Actions, GitLab CI, Jenkins; stages, artifacts, caching, and deployment automation.

deployment-strategy

Blue-green, canary, rolling deployments, traffic shifting, and safe release strategies.

dockerfile-best-practices

Dockerfile best practices, layer optimization, multi-stage builds, security, and image size reduction.

feature-flag-design

Designing feature flags for gradual rollouts, A/B testing, and safe feature releases.

infrastructure-as-code

Terraform, CloudFormation, reproducible infrastructure, version control, and IaC best practices.

log-aggregation

ELK Stack, structured logging, log query patterns, and centralized log management.

monitoring-instrumentation

Metrics, logs, traces (observability); choosing what to measure, dashboards, and incident response.

code-review-checklist

Systematic code review process, feedback templates, approval criteria, and review best practices.

documentation-strategy

Documentation levels and types (README, architecture, API, runbooks), keeping docs current and discoverable.

git-workflow

Feature branches, commit hygiene, rebasing vs. merging, and collaborative workflows.

incident-response

SEV classification, incident command system, communication, and incident response procedures.

on-call-runbook

Runbook templates, escalation procedures, playbooks, and incident playbooks.

pair-programming-guide

Effective pair programming, driver/navigator roles, tools, and collaboration patterns.

technical-writing

Clear technical documentation, API docs, architecture decision records, and runbooks.

algorithm-analysis

Big O notation, time/space complexity analysis, and choosing efficient algorithms.

concurrency-patterns

Actor model, CSP (Communicating Sequential Processes), lock-free patterns, async/await.

data-structure-selection

Choosing optimal data structures based on access patterns and performance requirements.

design-patterns

Gang of Four patterns (Creational, Structural, Behavioral) and when to apply them.

functional-patterns

Higher-order functions, composition, monads, immutability, and functional programming idioms.

reactive-patterns

Streams, observables, event-driven reactive systems, backpressure, and reactive programming.

resource-management

RAII (Resource Acquisition Is Initialization), cleanup patterns, resource leaks, and lifetime management.

state-management

Finite state machines, event sourcing, CQRS (Command Query Responsibility Segregation), and state modeling.

integration-test-design

Testing multiple components together; contract verification; real I/O (database, HTTP). Use when testing component interactions.