API Development Claude 技能

Swift for Linux

Installs and configures the Swift programming language on Debian Linux for high-performance server-side development.

Elixir System Architect

Architects production-ready Elixir and Phoenix systems using Ash Framework and OTP best practices for AI-driven development.

Type Safety & Validation Mastery

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

API Versioning Strategies

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

CQRS Design Patterns

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

gRPC Python Microservices

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

Advanced TanStack Query v5

Implements high-performance data fetching, caching, and optimistic UI updates using TanStack Query v5 best practices.

Strawberry GraphQL Development

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

LLM Streaming & Real-time Patterns

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

Idempotency Patterns

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

Advanced Python Asyncio Patterns

Implements high-performance Python concurrency using modern structured patterns, TaskGroups, and robust error handling for Python 3.11+ 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.

LangGraph State & Persistence

Manages persistent workflow states, fault-tolerant execution recovery, and multi-threaded conversation memory for LangGraph agents.

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.

RFC 9457 API Error Handling

Implements RFC 9457 Problem Details to provide standardized, machine-readable HTTP API error responses for modern backend services.

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.

Caching Strategies & Redis Patterns

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

Clean Architecture & DDD Patterns

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

Message Queue Patterns

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

API Design Framework

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

Streaming API Patterns

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

Aggregate Design Patterns

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

Streaming API Patterns

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

Rate Limiting Patterns

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

Advanced Python Asyncio

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

Resilience Patterns

Implements production-grade fault tolerance and resilience patterns for distributed systems and LLM-based workflows.

API Idempotency Patterns

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