API Development Agent Skills

API Rate Limiting Patterns

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

Streaming API Patterns

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

Saga Patterns for Distributed Transactions

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

Advanced FastAPI Patterns

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

Transactional Outbox Pattern

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

Clean Architecture & DDD Patterns

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

RFC 9457 API Error Handling

Standardizes HTTP API error responses using the machine-readable RFC 9457 Problem Details format for robust 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.

Python Background Job Patterns

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

Strawberry GraphQL Patterns

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

Rate Limiting Patterns

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

Advanced Celery Orchestration

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

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.

Message Queue Patterns

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

API Idempotency Patterns

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

CQRS Architecture Patterns

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

Advanced Celery Orchestration

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

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.

MCP Server Development

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

Advanced Python Asyncio

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

Streaming API Patterns

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

FastAPI Clean Architecture Enforcer

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

Temporal.io Workflow Orchestration

Orchestrates durable, fault-tolerant distributed applications using Temporal.io for complex, long-running business processes.

Type Safety & Validation Patterns

Implements end-to-end type safety and runtime validation using Zod, tRPC, and Prisma for robust TypeScript and Python applications.

LangGraph Functional API

Simplifies AI workflow development using Python decorators for orchestration, parallel execution, and state persistence.

gRPC Python Services

Implements high-performance microservice communication using gRPC and Protocol Buffers for Python-based backend systems.

Distributed Locking Patterns

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