api-dev
Build High-Performance REST APIs
Building scalable APIs requires mastering async patterns, error handling, and rate limiting. This skill provides ready-to-use code patterns for circuit breakers, caching, testing, and production configurations that work across Python, Node.js, and Go.
Download the skill ZIP
Upload in Claude
Go to Settings → Capabilities → Skills → Upload skill
Toggle on and start using
Test it
Using "api-dev". Create an async API client with connection pooling and retry logic
Expected outcome:
- Created AsyncAPIClient class with TCPConnector for connection pooling
- Added retry logic using exponential backoff
- Included metrics tracking decorator for request duration and status codes
- Configured timeout handling and session lifecycle management
Using "api-dev". Implement rate limiting for my API endpoint
Expected outcome:
- Created RateLimiter class with Redis sliding window algorithm
- Added RateLimitMiddleware for FastAPI integration
- Configured default of 100 requests per minute per IP
- Included custom identifier function support for user-based limiting
Using "api-dev". Add circuit breaker pattern to external API calls
Expected outcome:
- Implemented CircuitBreaker class with OPEN, HALF_OPEN, CLOSED states
- Added configurable failure threshold and timeout values
- Created decorator for easy integration with async functions
- Included automatic circuit reset after timeout period
Security Audit
SafePure documentation skill containing example code patterns for API development. Static scanner flagged standard patterns (HTTP clients, connection strings, pickle serialization) as suspicious, but these are legitimate examples in documentation. No malicious intent found. Original audit correctly rated this skill safe.
Critical Issues (1)
Risk Factors
🌐 Network access (14)
📁 Filesystem access (1)
⚙️ External commands (15)
🔑 Env variables (10)
Quality Score
What You Can Build
Build production APIs
Implement async APIs with proper error handling, rate limiting, and circuit breakers for production reliability.
Configure API monitoring
Set up Prometheus metrics, structured logging, health checks, and performance optimization for API services.
Create API tests
Write comprehensive unit and integration tests for API endpoints with mocking and pagination validation.
Try These Prompts
Create an async API client in Python with connection pooling, retry logic, and metrics tracking for high-performance HTTP requests.
Implement rate limiting middleware using Redis sliding window algorithm with configurable limits per user or IP address.
Design an API versioning strategy supporting header-based, URL path-based, and query parameter-based version detection.
Write async API tests using pytest and httpx including unit tests, integration tests, and rate limiting validation.
Best Practices
- Always use connection pooling with limits to prevent resource exhaustion
- Implement circuit breakers to prevent cascade failures in distributed systems
- Use structured logging with correlation IDs for API request tracing
Avoid
- Making synchronous HTTP calls in async handlers
- Skipping rate limiting on public API endpoints
- Not validating input schema before processing requests