API Development Agent Skills

Streaming API Patterns

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

Clean Architecture & DDD Patterns

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

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.

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.

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.

Advanced Celery Orchestration

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

Advanced TanStack Query v5

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

Resilience Patterns

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

MCP Server Building

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

Rate Limiting Patterns

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

Async Connection Pooling

Optimizes database and HTTP connection lifecycles in high-concurrency Python asynchronous applications.

Strawberry GraphQL Development

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

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.

Python Background Jobs

Implements asynchronous task processing, distributed job queues, and scheduled workers using Celery, ARQ, and Redis.

Distributed Locking Patterns

Implements robust distributed locking mechanisms using Redis and PostgreSQL to coordinate shared resources across multiple service instances.

Backend Architecture Enforcer

Enforces FastAPI Clean Architecture principles by validating layer separation and dependency injection patterns in real-time.

Claude Prompt Caching Optimizer

Optimizes LLM token costs and latency by implementing provider-native prompt caching for Claude and OpenAI.

API Versioning Strategies

Implements robust API versioning patterns and lifecycle policies for evolving production-grade REST services.

LLM Streaming Patterns

Implements high-performance real-time token streaming and Server-Sent Events (SSE) for AI-powered applications.

MCP Server Development

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

CQRS Architecture Patterns

Implements Command Query Responsibility Segregation (CQRS) patterns to separate read and write operations for high-performance, scalable systems.

Aggregate Design Patterns

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

FastAPI Advanced Patterns

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

Resilience Patterns

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