API Development Habilidades de Claude

Rust Domain Error Strategy

Architects resilient Rust applications by designing structured domain error hierarchies and recovery strategies.

Rust Type-Driven Design

Enforces robust software architecture by leveraging Rust's type system to make invalid application states unrepresentable at compile-time.

Domain Modeling for Rust

Guides the implementation of Domain-Driven Design (DDD) patterns in Rust to create robust, invariant-safe business logic.

Rust Web Domain Service

Streamlines the creation of high-performance Rust web services by providing expert guidance on async architecture, state management, and framework patterns.

API Contract Sync Manager

Ensures synchronization between API specifications and code implementations while detecting breaking changes and generating type-safe clients.

MCP Server Builder

Guides the creation of high-quality Model Context Protocol (MCP) servers for seamless LLM integration with external services.

V3 Agentic Core Implementation

Implements a robust Domain-Driven Design and clean architecture foundation for modular TypeScript agent systems.

Backend Architecture Patterns

Implements professional backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design for scalable systems.

Supabase Python Backend

Bootstraps production-ready FastAPI backends integrated with Supabase Auth and SQLModel database abstraction.

.NET Backend Development Patterns

Architects robust, production-grade .NET APIs and enterprise backends using modern C# design patterns and industry best practices.

Scala Pro Engineer

Architects enterprise-grade Scala solutions using advanced functional programming, distributed systems, and high-performance reactive patterns.

Inertia.js for Boring Stack

Streamlines Inertia.js implementation in Sails.js applications for building modern single-page apps without complex APIs.

Rust Module & API Architect

Enforces best practices for Rust crate structure, module visibility, and stable public API design.

Rust Core Polyglot Architecture

Architects high-performance Rust core libraries designed for seamless cross-language integration and efficient document processing.

FFI & Language Interop Standards

Establishes rigorous memory safety standards for Rust Foreign Function Interface (FFI) and cross-language integration.

Modern Python Performance Standards

Enforces high-performance Python 3.10+ standards using functional paradigms, strict typing, and high-speed serialization.

TypeScript Bindings Patterns

Streamlines the creation of idiomatic TypeScript bindings and SDKs for high-performance Rust-based core libraries.

Polyglot Error Handling

Standardizes error conversion and context preservation across Rust, Python, TypeScript, Ruby, Go, and Java boundaries.

Rust Module Organizer

Standardizes Rust project structure using private modules with public re-exports for clean, maintainable APIs.

Modern Python 3.13 Specialist

Develops high-performance backends and data pipelines using Python 3.13+, FastAPI, Django, and modern async patterns.

.NET Concurrency Patterns

Guides .NET developers in selecting and implementing the optimal concurrency abstractions, from simple async/await to advanced actor models.

C# API Design & Compatibility

Implements extend-only design principles to build stable, backward-compatible C# APIs and distributed systems.

Akka.Hosting Actor Patterns

Provides standardized patterns and extension methods for building testable, sharded entity actors using Akka.NET and Akka.Hosting.

Akka.NET Best Practices

Guides developers through architecting robust, scalable distributed systems using Akka.NET actor patterns and cluster management.

Microsoft Extensions Configuration Patterns

Implements robust, strongly-typed configuration patterns for .NET applications using Microsoft.Extensions.Options.

.NET Serialization Expert

Guides developers in choosing and implementing high-performance, AOT-compatible serialization formats like Protobuf, MessagePack, and System.Text.Json.

.NET Dependency Injection Patterns

Organizes and optimizes Microsoft.Extensions.DependencyInjection registrations using composable extension methods for cleaner and more maintainable .NET applications.

Go Development Specialist

Develops high-performance Go 1.23+ backend systems, microservices, and CLI tools using modern frameworks like Fiber and Gin.

Speakeasy SDK Generation Diagnosis

Troubleshoots and resolves SDK generation failures by analyzing OpenAPI specifications and applying optimal fix strategies.

OpenAPI Overlay & Validation Fixer

Resolves OpenAPI linting and validation errors by applying non-destructive overlays to source specifications.