kalilurrahman/kr-claudiator-skills - Page 8

vision-screenshot-to-code

Turn a UI screenshot or Figma export into production-ready React + Tailwind + shadcn code with accessibility, responsive breakpoints, and semantic tokens.

webhook-retry-design

Design webhook delivery with retries, signed payloads, and DLQs.

workflow-orchestration

Design workflow orchestration systems for complex, multi-step business processes. Outputs orchestration pattern selection, Temporal/Airflow implementation, error handling strategy, and observability.

working-agreement

Draft a working agreement between two collaborating teams.

data-contracts

Define and enforce schema and SLA agreements between data producers and consumers. Outputs a contract specification, compatibility policy, CI and runtime enforcement pipeline, and a versioning/migration plan for breaking changes.

enterprise-sales-enablement

Equip sales teams with the product knowledge, tools, and materials needed to win enterprise deals. Outputs battle cards, objection handling guides, demo scripts, and pricing approval workflows.

api-mocking

Mock external APIs for development and testing. Outputs mock server setup, request/response matching rules, contract-driven mocks, and CI integration.

background-jobs

Design background job systems for async task processing. Outputs job queue design, worker configuration, retry strategies, failure handling, and monitoring patterns.

clean-architecture

Structure codebases using Clean Architecture principles with clear layer separation, dependency inversion, and domain-centric design. Outputs folder structure, layer contracts, and dependency rules.

code-generation

Design and implement code generation pipelines from schemas, OpenAPI specs, or domain models. Outputs generator architecture, template design, validation strategy, and CI integration.

code-splitting

Implement code splitting to reduce initial bundle size and improve web application load time. Outputs splitting strategy, lazy loading patterns, preloading rules, and performance measurement approach.

configuration-management

Design robust configuration management for applications across environments. Outputs configuration schema, validation, secret handling, feature flag integration, and change management.

data-serialization

Choose and implement data serialization formats for APIs, storage, and messaging. Outputs format comparison, schema design, versioning strategy, and performance benchmarks.

event-storming

Facilitate event storming workshops to discover domain events, commands, aggregates, and bounded contexts. Outputs event map, domain vocabulary, bounded contexts, and modelling insights.

functional-programming

Apply functional programming principles to write predictable, testable code. Outputs pure function patterns, immutability strategies, composition pipelines, and FP-style refactoring examples.

graphql-design

Design GraphQL schemas, resolvers, and APIs for flexible data fetching. Outputs schema design, resolver architecture, N+1 prevention, pagination patterns, and security controls.

hexagonal-architecture

Design hexagonal (ports and adapters) architecture to isolate business logic from infrastructure. Outputs port definitions, adapter implementations, dependency flow diagram, and testing strategy.

microservices-communication

Design communication patterns between microservices. Outputs synchronous vs asynchronous decision framework, service discovery approach, circuit breaker configuration, and observability strategy.

null-object-pattern

Eliminate null checks and NullPointerExceptions using the Null Object pattern. Outputs null object implementations, optional type usage, and refactoring strategies for null-heavy codebases.

observer-pattern

Implement the Observer pattern for event-driven decoupled communication. Outputs event bus implementations, typed event systems, and async observer patterns.

outbox-pattern

Implement the Transactional Outbox pattern to reliably publish events alongside database writes. Outputs outbox table schema, message relay implementation, and at-least-once delivery guarantees.

performance-profiling

Profile and optimise application performance using systematic measurement. Outputs hotspot analysis, flame graphs, optimisation recommendations, and before/after benchmarks.

plugin-architecture

Design extensible plugin systems that let third parties extend your application without modifying core code. Outputs plugin interface design, registry patterns, sandboxing strategy, and versioning contracts.

repository-pattern

Implement the Repository pattern to abstract data access from business logic. Outputs repository interfaces, implementations, unit-of-work pattern, and testing with fakes.

retry-patterns

Implement retry patterns for resilient distributed systems. Outputs retry strategies, exponential backoff, circuit breaker integration, idempotency requirements, and failure budget design.

service-layer-design

Design the service layer that coordinates business logic, transactions, and cross-cutting concerns between controllers and domain models. Outputs service interfaces, transaction boundaries, and orchestration patterns.

solid-principles

Apply SOLID principles to write maintainable, extensible object-oriented code. Outputs principle-by-principle analysis, refactoring examples, and design decision guidelines.

trunk-based-development

Implement trunk-based development for fast, safe integration. Outputs branching rules, feature flag strategy, CI requirements, and team workflow guidelines.

twelve-factor-app

Apply the Twelve-Factor App methodology to build scalable, maintainable cloud-native applications. Outputs compliance checklist, configuration audit, and refactoring recommendations.

type-system-design

Design expressive type systems that catch bugs at compile time. Outputs type hierarchy, branded/nominal types, discriminated unions, generic constraints, and type-safe API patterns.

argocd-deployment

Deploy and manage applications with Argo CD GitOps. Outputs Application manifests, sync strategies, health checks, RBAC configuration, and multi-environment promotion workflows.

cloud-cost-allocation

Implement cloud cost allocation, tagging policies, and showback/chargeback systems. Outputs tagging standards, cost allocation reports, anomaly detection, and team budget dashboards.

cloud-migration

Plan and execute cloud migrations using the 6R strategies. Outputs assessment framework, migration waves, risk analysis, cutover plan, and success metrics.

cloud-networking

Design and implement cloud network architecture with VPCs, subnets, security groups, and private connectivity. Outputs network topology, security group rules, PrivateLink configuration, and routing tables.

database-ops

Operate databases in production with zero-downtime migrations, connection pooling, backup verification, and performance monitoring. Outputs migration workflow, pooler config, monitoring queries, and runbooks.

deployment-strategies

Select and implement the right deployment strategy for your release. Covers rolling, blue-green, canary, feature flags, and shadow deployments with rollback procedures.

dora-metrics

Implement DORA metrics to measure software delivery performance. Outputs metric definitions, data collection pipeline, dashboards, and improvement strategies for each performance tier.

ebpf-observability

Implement eBPF-based observability for deep kernel-level insights without application instrumentation. Outputs eBPF tool selection, network tracing, performance profiling, and security monitoring patterns.

edge-computing

Design and deploy edge computing architectures that process data close to the source. Outputs edge node topology, workload placement strategy, synchronisation patterns, and observability approach.

environment-management

Design and manage multiple deployment environments for development, staging, and production. Outputs environment topology, promotion workflow, configuration management, and parity strategy.