Claude Skills

This skill generates complete REST API implementations from OpenAPI specifications or database schemas. It's designed for developers who need to quickly create RESTful API endpoints and can be triggered with phrases like "generate REST API" or "build REST endpoints." The skill handles API structure planning, endpoint generation, and integration with backend services.

This skill automates gRPC service creation by generating service definitions, client/server stubs, and implementation code from Protocol Buffers. It's designed for developers building high-performance gRPC APIs and can be triggered with commands like "generate gRPC service" or "build gRPC server." The tool streamlines development by handling code generation from API specifications.

This skill helps developers build production-ready GraphQL servers with complete schema design, resolver implementation, and subscription support. Use it when creating GraphQL APIs to get structured guidance on architecture, endpoints, and integration. It's triggered by phrases like "build GraphQL API" or "create GraphQL server."

This skill helps developers manage API versioning with backward compatibility, deprecation notices, and migration paths. It's triggered when you need to version APIs, handle compatibility, or plan migration strategies. Key capabilities include designing API structures, implementing versioning schemes, and maintaining existing API versions.

The throttling-apis skill manages API throttling policies to protect backend services from overload by controlling request rates. It allows developers to design, implement, and enforce rate-limiting rules using tools like Read, Write, and Bash commands. Use this skill when you need to throttle API endpoints or control request rates to prevent service degradation.

This skill scans APIs for security vulnerabilities like injection flaws, broken authentication, and data exposure. Use it when you need to audit API security by triggering with phrases such as "scan API security" or "check for vulnerabilities." It provides automated security testing using tools like Bash, Grep, and file operations on your API specifications.

This skill generates client SDKs in multiple languages from OpenAPI specifications, automating the creation of API consumption libraries. It's triggered by phrases like "generate SDK" or "create client library" and works with tools for reading, writing, and executing SDK generation commands. Use it when you need to produce ready-to-use client libraries from your API definitions.

This skill validates API schemas against OpenAPI, JSON Schema, and GraphQL specifications. Use it when checking API contracts with triggers like "validate API schema" or "check OpenAPI spec." It provides automated validation by examining specifications from designated directories.

This skill validates API responses against schemas to ensure contract compliance and data integrity. It's triggered by phrases like "validate responses" or "check API responses" and uses tools like Read, Write, and Bash to verify response correctness and format. Developers should use it when ensuring API response accuracy during development or testing.

This skill adds comprehensive API logging with correlation IDs, performance metrics, and security audit trails. Use it when you need to audit API requests and responses for debugging or compliance. It provides structured logging capabilities triggered by phrases like "log API requests" or "track API calls".

This skill implements sophisticated API rate limiting using sliding windows, token buckets, and quota systems. Use it when you need to protect your APIs from excessive requests and ensure fair usage. It provides ready-to-apply patterns triggered by phrases like "add rate limiting" or "implement rate limits."

This skill enables developers to build real-time API monitoring dashboards featuring health checks, performance metrics, and alerting. It is triggered by phrases like "monitor the API" and is used for tracking API health and performance. The skill provides tools to read specifications and execute monitoring-related commands.

The mocking-apis skill generates mock API servers with realistic response data for development and testing. It creates mock servers when triggered by phrases like "create mock API" or "setup mock server," using tools like Bash and file operations. Developers can use it to quickly prototype and test API integrations without needing live backend services.

This skill helps developers migrate APIs between versions, platforms, or frameworks with minimal downtime. It provides structured guidance for upgrading API versions and can be triggered with phrases like "migrate the API" or "upgrade API version." The skill includes tools for reading, writing, editing, and executing migration-related bash commands.

This skill enables automated load and stress testing of APIs to validate performance and scalability under various conditions. It triggers with commands like "load test the API" and provides tools for executing comprehensive benchmarks. Developers can use it to ensure their APIs meet performance requirements through structured testing workflows.

This Claude Skill builds API gateways for routing and managing multiple backend services. It provides key capabilities including routing, load balancing, rate limiting, and authentication setup. Use it when prompted with phrases like "build API gateway" or "setup API router" to create API gateway infrastructure.

This skill helps developers implement event-driven APIs by adding webhooks, Server-Sent Events, and real-time notifications. Use it when building event-driven API architectures, triggered by phrases like "add webhooks" or "create event-driven API". It provides tools and guidance for designing, integrating, and testing these real-time communication features.

This Claude skill helps developers implement standardized API error handling with proper HTTP status codes and structured error responses. It's triggered when you need to add consistent error handling across your API endpoints. The skill provides guidance on designing error formats, implementing middleware, and creating comprehensive error responses for different failure scenarios.

This skill generates comprehensive API documentation including examples, authentication guides, and SDKs. Use it when you need to create full API documentation by triggering with phrases like "generate API docs" or "document the API." It works with API specifications and supports tools like Read, Write, Edit, and Bash for documentation tasks.

This skill generates API contracts and OpenAPI specifications from existing code or design documents. It helps developers quickly create documentation when they need to define API structures, endpoints, and schemas. Use it by triggering with phrases like "generate API contract" or "create OpenAPI spec."

This Claude Skill implements intelligent API response caching with Redis, Memcached, and CDN integration to optimize API performance. Use it when you need to add caching or implement a cache layer for your APIs. It provides tools to design cache strategies, configure caching systems, and integrate them with your API architecture.

This Claude skill efficiently processes bulk API operations by implementing batching, throttling, and parallel execution. It's designed for developers handling large volumes of API calls, triggered with phrases like "process bulk requests" or "batch API calls." The skill provides structured guidance for API design and integration while managing execution constraints.

This Claude Skill helps developers implement secure API authentication systems using OAuth2, JWT, API keys, and session management. Use it when you need to build or add authentication flows to secure your API endpoints. It provides structured guidance for designing, implementing, and testing authentication strategies within your development environment.

This skill helps developers build production-ready ADK agents with proper architecture, testing, and deployment automation. It's designed for requests like "build ADK agent" or "engineer ADK application," focusing on multi-agent system design and implementation. Key capabilities include creating scalable agent code and automating the development lifecycle.