API Development Claude 技能

Resilience Patterns

Implements production-grade fault tolerance and reliability patterns for distributed systems and LLM integrations.

API Design Framework

Standardizes the architecture and implementation of production-grade REST, GraphQL, and gRPC APIs using industry best practices.

Advanced MCP Patterns

Implements production-grade Model Context Protocol patterns for tool orchestration, resource lifecycle management, and horizontal scaling.

RFC 9457 API Error Handling

Standardizes HTTP API error responses using the machine-readable RFC 9457 Problem Details format for robust backend services.

Strawberry GraphQL Patterns

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

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.

Advanced Python Asyncio

Implements high-performance Python concurrency using modern 3.11+ asyncio features and structured concurrency patterns.

Domain-Driven Design (DDD) Patterns

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

DDD Aggregate Design Patterns

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

Distributed Locking Patterns

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

FastAPI Clean Architecture Enforcer

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

Strawberry GraphQL Development

Builds type-safe, production-ready GraphQL APIs using the Strawberry library and FastAPI integration.

Advanced Celery Orchestration

Implements complex background task patterns, enterprise workflows, and production-grade monitoring for Celery in Python environments.

API Versioning Strategies

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

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.

Advanced FastAPI Patterns

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

MCP Server Building

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

Idempotency Patterns

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

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.

Streaming API Patterns

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

Message Queue Patterns

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

Caching Strategies & Redis Patterns

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

Streaming API Patterns

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

Python Background Job Patterns

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

Transactional Outbox Pattern

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

Saga Patterns for Distributed Transactions

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