api-dev
Modern API development patterns for building high-performance, scalable web services. Expert in async/await patterns, REST/GraphQL APIs, middleware, error handling, rate limiting, OpenAPI documentation, testing, and production optimizations. Framework-agnostic patterns that work with Python, Node.js, Go, and other languages.
npx skills add majiayu000/claude-skill-registry --skill api-dev --agent claude-code
Same command for any agent — swap --agent for codex, cursor, copilot.
Weekly change comes from our own snapshots, not the repository page — it measures attention, not adoption.
What it does
Implements patterns for modern API development, including async/await patterns, REST/GraphQL APIs, middleware for auth/logging/validation, error handling, rate limiting, OpenAPI documentation, testing, and production optimizations. The skill covers framework-agnostic practices suitable for Python, Node.js, Go, and other languages.
How it works
- Async patterns: includes an AsyncAPIClient with connection pooling, metrics collection via a with_metrics decorator, and GET/POST methods that return JSON results.
- Circuit Breaker: provides a CircuitBreaker class with states (CLOSED, OPEN, HALF_OPEN), thresholds, timeout, and a wrapper to decorate async functions.
- Rate Limiting: uses Redis-based RateLimiter with a sliding window, plus a RateLimitMiddleware for FastAPI to enforce per-identifier limits.
- API Versioning: defines APIVersion, several strategies (HeaderVersionStrategy, URLPathVersionStrategy, QueryParamVersionStrategy), and a CompositeVersionStrategy to select a version from multiple sources; includes an APIHandlerRegistry for version-specific endpoints.
- OpenAPI Documentation: defines schemas for error handling, pagination, and a PaginatedResponse, plus an OPENAPI_CONFIG dict with server info and components for schemas/responses.
When to use it
Use this skill when designing and implementing APIs that require:
- RESTful or GraphQL interfaces with async patterns
- Middleware for authentication, logging, and validation
- Robust error handling and proper HTTP status codes
- Rate limiting and throttling mechanisms
- Auto-generated OpenAPI/Swagger documentation
- Comprehensive testing and production-ready configurations
- Performance optimizations like caching and connection pooling
- API versioning and backward compatibility
- Observability and monitoring setups
What it can touch
- Files and modules under patterns/ (example paths in code)
- Libraries: asyncio, aiohttp, aioredis, Prometheus/Datadog (as placeholders in comments), FastAPI concepts (BaseHTTPMiddleware), pydantic for schemas
- The OPENAPI_CONFIG dictionary for OpenAPI config
Caveats
- The code samples are illustrative patterns and may require adaptation to specific frameworks; some sections depend on external monitoring systems and Redis deployment.
- No explicit license text beyond MIT is shown in code snippets; license field indicates MIT.
# API Development Patterns & Best Practices This skill provides comprehensive patterns for building modern APIs in 2025, focusing on async/await patterns, performance optimization, security, testing, and production-ready configurations that work across different frameworks and languages. ## When to Use This Skill Use this skill when you need to: - Design RESTful or GraphQL APIs - Implement async/await patterns for high performance - Add middleware for authentication, logging, and validation - Handle errors gracefully with proper HTTP status codes - Implement rate limiting and throttling - Generate OpenAPI/Swagger documentation - Set up comprehensive testing strategies - Optimize API performance with caching and connection pooling - Implement API versioning and backward compatibility - Set up monitoring and observability ## Core API Design Principles ### 1. Async/Await Patterns for Performance ```python # patterns/async_patterns.py import asyncio import aiohttp import aioredis from typing import AsyncGenerator, Optional, List, Dict, Any from contextlib import asynccontextmanager from dataclasses import dataclass from functools import wraps import time @dataclass class RequestMetrics
- When to Use This Skill
- Core API Design Principles
- 1. Async/Await Patterns for Performance
- 2. Circuit Breaker Pattern
- 3. Rate Limiting with Redis
- 4. API Versioning Strategy
- 5. OpenAPI Documentation Enhancement
- 6. Testing Patterns for APIs
- 7. Performance Optimization Patterns
- 8. Production Configuration Checklist
What does the api-dev skill do?
Modern API development patterns for building high-performance, scalable web services. Expert in async/await patterns, REST/GraphQL APIs, middleware, error handling, rate limiting, OpenAPI documentation, testing, and production optimizations. Framework-agnostic patterns that work with Python, Node.js, Go, and other languages.
How do I install it?
Run `npx skills add majiayu000/claude-skill-registry --skill api-dev --agent claude-code` — it drops the skill into your project so the agent can pick it up. Swap the --agent value for codex, cursor or copilot if you use one of those.
Where does this skill come from?
From majiayu000/claude-skill-registry, a repository with 534 stars. We read it straight from the repository tree rather than a submitted listing, so what you see here is what is actually published.
Is a popular skill a good skill?
Not necessarily. Stars measure attention, not adoption — a repository can trend for a week and be abandoned. That is why we show the weekly change from our own snapshots next to the total, instead of a single flattering number.