API Development Claudeスキル

Django Patterns

Implements scalable Django architectural patterns including ORM optimization, service layers, and REST framework best practices.

LLM Integration Patterns

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

Rust Systems Programming

Implements high-performance Rust systems patterns focusing on memory safety, asynchronous execution, and robust error handling.

IoT Development Guide for Rust

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

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.

Rust Error Handling Strategy

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

Rust Type-Driven Design

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

Rust Domain Error Strategy

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

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.

Scala Pro Engineer

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

.NET Backend Development Patterns

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

Inertia.js for Boring Stack

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

Rust Core Polyglot Architecture

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

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.

TypeScript Bindings Patterns

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

Rust Module & API Architect

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

Modern Python Performance Standards

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

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 Serialization Expert

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

Microsoft Extensions Configuration Patterns

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

Akka.Hosting Actor Patterns

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

.NET Concurrency Patterns

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

Akka.NET Best Practices

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