API Development Agent Skills

LLM Integration Patterns

Implements production-grade patterns for LLM API usage, streaming, function calling, RAG pipelines, and cost optimization.

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.

Domain Modeling for Rust

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

Rust Domain Error Strategy

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

Rust Error Handling Strategy

Optimizes Rust codebases by implementing robust error handling patterns and architectural decision-making frameworks.

IoT Development Guide for Rust

Simplifies building resilient IoT applications by providing Rust-specific patterns for sensor integration, power management, and reliable messaging.

Rust Type-Driven Design

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

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.

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.

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.

Rust Core Polyglot Architecture

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

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.

Akka.Hosting Actor Patterns

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

Microsoft Extensions Configuration Patterns

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

.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.NET Best Practices

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

.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.