API Development Habilidades de Claude

Python Async Patterns

Implements high-performance asynchronous programming patterns in Python using asyncio, async/await, and concurrent.futures.

Elixir System Architect

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

CQRS Design Patterns

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

Backend Architecture Enforcer

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

gRPC Python Microservices

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

LangGraph State & Persistence

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

Aggregate Design Patterns

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

Type Safety & Validation Mastery

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

Advanced Python Asyncio Patterns

Implements high-performance Python concurrency using modern structured patterns, TaskGroups, and robust error handling for Python 3.11+ applications.

Idempotency Patterns

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

MCP Server Building

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

Saga Patterns for Distributed Transactions

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

Advanced TanStack Query v5

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

Advanced FastAPI Patterns

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

Streaming API Patterns

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

API Rate Limiting Patterns

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

API Versioning Strategies

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

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.

Transactional Outbox Pattern

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

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.

Resilience Patterns

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

Rate Limiting Patterns

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

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.

Strawberry GraphQL Development

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

Clean Architecture Patterns

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

Strawberry GraphQL Patterns

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