API Development Claudeスキル

Message Queue Patterns

Implements robust asynchronous communication and event-driven architectures using Kafka, RabbitMQ, Redis, and Postgres.

Clean Architecture Patterns

Implements SOLID principles, hexagonal architecture, and Domain-Driven Design (DDD) patterns for building maintainable and testable backends.

Saga Patterns for Distributed Transactions

Implements orchestration and choreography patterns to maintain data consistency across distributed microservices.

Rate Limiting Patterns

Implements robust API rate limiting and request throttling using Redis-backed distributed patterns like Token Bucket and Sliding Window.

API Idempotency Patterns

Implements exactly-once semantics and request deduplication for reliable distributed systems and APIs.

Streaming API Patterns

Implements production-ready real-time data streaming patterns using SSE, WebSockets, and ReadableStream for high-performance applications.

Caching Strategies & Redis Patterns

Implements high-performance Redis caching patterns including cache-aside, write-through, and stampede prevention for backend services.

Message Queue Patterns

Implements high-performance asynchronous messaging and event-driven architectures using RabbitMQ, Kafka, and Redis Streams.

Transactional Outbox Pattern

Implements reliable, atomic event publishing to ensure consistency between database state and message brokers.

Python Background Job Patterns

Implement scalable, asynchronous task processing and job queues using Celery, ARQ, and Redis in Python backends.

Clean Architecture & DDD Patterns

Implements maintainable, decoupled backend systems using SOLID principles, hexagonal architecture, and Domain-Driven Design (DDD).

Advanced FastAPI Patterns

Implements production-ready FastAPI architectures including lifespan management, dependency injection, and high-performance middleware.

API Rate Limiting Patterns

Protects web services and APIs from abuse by implementing distributed rate limiting strategies using Redis and modern algorithms.

Saga Patterns for Distributed Transactions

Implements robust saga patterns to manage distributed transactions and maintain consistency across microservices through orchestration and choreography.

MCP Server Building

Develops custom Model Context Protocol (MCP) servers to extend Claude's capabilities with specialized tools, data resources, and prompt templates.

Streaming API Patterns

Implements production-ready real-time data streaming using Server-Sent Events (SSE), WebSockets, and ReadableStream APIs.

Idempotency Patterns

Implements robust idempotency and deduplication patterns for APIs and distributed systems to ensure exactly-once execution.

CQRS Design Patterns

Implements Command Query Responsibility Segregation (CQRS) to optimize data access by separating read and write operations into distinct models.

API Versioning Strategies

Implements robust API versioning patterns and lifecycle policies to ensure backward compatibility and smooth service evolution.

Distributed Locking Patterns

Implements exclusive resource access and prevents race conditions across distributed service instances using Redis and PostgreSQL.

gRPC Python Microservices

Implements high-performance microservice communication in Python using gRPC and Protobuf for robust, type-safe APIs.

Type Safety & Validation Mastery

Implements end-to-end type safety and runtime validation using Zod, tRPC, Prisma, and advanced TypeScript patterns.

LLM Streaming & Real-time Patterns

Implements production-ready real-time token streaming, SSE endpoints, and tool-call handling for AI applications.

DDD Aggregate Design Patterns

Implements Domain-Driven Design (DDD) aggregate patterns to manage consistency boundaries and business invariants in complex backend systems.

FastAPI Clean Architecture Enforcer

Enforces strict layer separation and Clean Architecture patterns in FastAPI projects through automated, blocking validation.

Advanced Celery Orchestration

Implements sophisticated Celery task patterns including complex workflows, priority queuing, and enterprise-grade monitoring.

Domain-Driven Design (DDD) Patterns

Implements Domain-Driven Design tactical patterns to model complex business logic using entities, value objects, and bounded contexts.

Domain-Driven Design (DDD) Patterns

Models complex business logic using tactical DDD patterns including entities, value objects, and bounded contexts.

MCP Advanced Patterns

Implements production-grade Model Context Protocol patterns for high-performance tool orchestration and resource management.

Strawberry GraphQL Patterns

Builds type-safe, production-ready GraphQL APIs in Python using Strawberry and FastAPI with advanced patterns for performance and scalability.