API Development Agent Skills

Metabase Malli API Schema Assistant

Standardizes and automates the addition of Malli validation schemas to Metabase API endpoints for enhanced type safety and error handling.

Java Error-as-Value Pattern

Implements type-safe error handling in Java using the Result pattern to replace exception-based control flows.

Zod 4 Validation Standards

Standardizes Zod 4 validation implementations with consistent schema definitions, type safety, and robust error handling patterns.

Rust Core Development

Accelerates Rust application development by providing expert guidance on core principles, architectural patterns, and performance optimization.

Next.js App Router Best Practices

Enforces Next.js App Router principles and architectural patterns for high-performance React applications.

Rust Core Development

Provides comprehensive guidance and automation for building high-performance Rust applications across web, CLI, and desktop domains.

Aico Backend Planner

Generates micro-level, atomic implementation plans for backend tasks using a strict TDD workflow.

Error Handling Patterns

Implements robust error handling strategies and resilient design patterns across multiple programming languages to improve application reliability.

Voice AI Development Architect

Builds high-performance, low-latency real-time voice applications using industry-leading AI providers and streaming architectures.

Node.js Backend Patterns

Develops scalable, production-ready Node.js backend services using modern architectural patterns and performance-focused frameworks.

.NET Backend Patterns

Implements production-grade .NET backend patterns for building robust APIs, MCP servers, and enterprise applications using Clean Architecture and C# best practices.

Home Assistant Core Integration

Integrates Home Assistant REST and WebSocket APIs for advanced smart home device management and automation.

CQRS Architecture Implementation

Implements Command Query Responsibility Segregation (CQRS) patterns to build highly scalable and performant backend systems.

AICO Backend Initializer

Initializes backend development environments by establishing tech stack constraints and standardized project documentation.

Enterprise Architectural Patterns

Applies proven architectural patterns from Martin Fowler’s PoEAA to build scalable, maintainable enterprise-grade applications.

AdonisJS Ace CLI Assistant

Accelerates TypeScript backend development with expert-level AdonisJS Ace CLI commands and architectural patterns.

Senior Software Architect

Designs, analyzes, and documents scalable full-stack system architectures using automated tools and industry-standard design patterns.

Zod Validation Skill

Implements type-safe data validation and schema definitions using Zod for robust JavaScript and TypeScript applications.

Windsurf Rate Limit Handler

Implements robust rate limiting, exponential backoff, and idempotency patterns for Windsurf API integrations.

Rails Conventions

Guides developers in building Ruby on Rails applications using established naming patterns, file structures, and architectural best practices.

Keycloak FastAPI Integration

Integrates Keycloak identity management and OIDC authentication into FastAPI backends with robust role-based access control.

OpenCode SDK

Provides a programmatic TypeScript interface to control, automate, and integrate the OpenCode AI coding agent into custom workflows and CI/CD pipelines.

Backend for Frontend (BFF) Pattern

Architects client-specific backend services that aggregate and transform data from microservices to optimize frontend performance and team autonomy.

MVC Architectural Pattern

Implements the Model-View-Controller pattern to decouple business logic from user interface components for more maintainable codebases.

Saga Orchestration & Distributed Transactions

Implements robust saga patterns to manage complex, multi-step distributed transactions and cross-service workflows with automated compensation.

Software Architecture & Clean Code

Implements quality-focused software development patterns based on Clean Architecture and Domain-Driven Design principles.

Domain-Driven Design (DDD) Assistant

Models complex software systems by aligning code structure with business domains and establishing a shared ubiquitous language.

Loose Coupling Architecture

Implements modular software design principles to minimize component dependencies and maximize system flexibility through well-defined interfaces and abstraction.

Senior Fullstack Architect

Builds and audits production-grade web applications using Next.js, Node.js, GraphQL, and cloud-native infrastructure patterns.

MVC Architecture & Design Pattern

Organizes software into Model, View, and Controller layers to ensure clean separation of concerns and improved code maintainability.