菜单
Comprehensive API design and development workflow that orchestrates API architecture, endpoint design, documentation generation, and integration patterns. Handles everything from RESTful API creation and GraphQL schema design to API gateway setup and version management.
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
基于 SOC 职业分类
Lightweight Flutter enterprise development skill focused on feature-based clean architecture. Use when user asks to: (1) Build enterprise Flutter apps with clean architecture, (2) Implement feature-based modular structure, (3) Set up scalable Flutter project organization, (4) Create maintainable enterprise codebase. Triggers: Flutter enterprise app, clean architecture Flutter, feature-based Flutter, enterprise Flutter structure, modular Flutter architecture
Manage UI components using MCP tools with primary focus on Svelte ecosystem. Specialized in Svelte component libraries including shadcn-svelte, Skeleton UI, and Melt UI. Use when user needs to: (1) Add new Svelte UI components to a project (2) Build complex UI features requiring multiple components (3) Research component implementations and examples (4) Get component installation commands (5) Choose appropriate Svelte component library Triggers: "add components", "UI components", "build UI", "install component", "create form", "create dialog", "svelte components", "shadcn-svelte", "skeleton ui"
Create distinctive, production-grade frontend interfaces with high design quality. Specialized in Svelte/SvelteKit applications with full-stack capabilities. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.
Implement or extend user-facing workflows in SvelteKit applications with full-stack capabilities. Specialized in SvelteKit's load functions, form actions, and progressive enhancement. Use when the feature is primarily a UI/UX change backed by existing APIs, affects only the web frontend, and requires following SvelteKit conventions.
Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.
Optimize SvelteKit applications by leveraging SvelteKit's full-stack architecture for instant server-side rendering and progressive enhancement. Specialized in load functions, form actions, and SvelteKit's data loading patterns. Use when: - User reports slow initial page load with loading spinners - Page uses onMount + fetch for data fetching - Store patterns cause waterfall fetching - Need to improve SEO (content not in initial HTML) - Converting client-side data fetching to server-side load functions - Implementing progressive enhancement patterns Triggers: "slow loading", "optimize fetching", "SSR data", "SvelteKit optimization", "remove loading spinner", "server-side fetch", "convert to load function", "progressive enhancement", "data fetch lambat", "loading lama"
| name | api-builder |
| description | Comprehensive API design and development workflow that orchestrates API architecture, endpoint design, documentation generation, and integration patterns. Handles everything from RESTful API creation and GraphQL schema design to API gateway setup and version management. |
| license | Apache 2.0 |
| tools | [] |
This skill provides end-to-end API development services by orchestrating API architects, integration specialists, and documentation experts. It transforms API requirements into production-ready APIs with comprehensive design, documentation, testing, and integration capabilities.
Key Capabilities:
Perfect for:
Triggers:
Use when: Starting API development or API modernization
Tools Used:
/sc:analyze api-requirements
API Architect: API design requirements and constraints
Integration Specialist: integration points and dependencies
Documentation Expert: documentation requirements and developer needs
Activities:
Use when: Designing the API structure and choosing protocols
Tools Used:
/sc:design --type api restful-architecture
/sc:design --type graphql schema
API Architect: comprehensive API design and protocol selection
Integration Specialist: integration architecture and patterns
Activities:
Use when: Writing the actual API code and business logic
Tools Used:
/sc:implement api-endpoints
API Architect: API implementation patterns and best practices
Integration Specialist: middleware and integration implementation
API Security Specialist: security controls and authentication
Activities:
Use when: Creating comprehensive API documentation and developer resources
Tools Used:
/sc:implement api-documentation
Documentation Expert: API docs and developer portal creation
API Architect: API specification validation and examples
Integration Specialist: integration guides and SDKs
Activities:
Use when: Setting up API gateway, middleware, and integrations
Tools Used:
/sc:implement api-gateway
Integration Specialist: API gateway configuration and middleware
API Security Specialist: security policies and access control
Performance Engineer: caching, rate limiting, and optimization
Activities:
Use when: Ensuring API reliability, performance, and security
Tools Used:
/sc:test api-comprehensive
Performance Engineer: load testing and performance validation
API Security Specialist: security testing and vulnerability assessment
Documentation Expert: documentation accuracy and usability testing
Activities:
| Command | Use Case | Output |
|---|---|---|
/sc:design --type api | API design | Complete API architecture |
/sc:implement restful | REST API | Production-ready REST endpoints |
/sc:implement graphql | GraphQL API | GraphQL schema and resolvers |
/sc:implement gateway | API gateway | Configured API gateway |
/sc:test api | API testing | Comprehensive test suite |
| Protocol | Role | Capabilities |
|---|---|---|
| RESTful | Standard API | HTTP-based REST API with proper semantics |
| GraphQL | Flexible API | Flexible query language and type system |
| gRPC | High-performance API | Binary protocol for high-performance scenarios |
| WebSocket | Real-time API | Real-time bidirectional communication |
| Server | Expertise | Use Case |
|---|---|---|
| Sequential | API reasoning | Complex API design and problem-solving |
| Web Search | API patterns | Latest API design trends and best practices |
| Firecrawl | API testing | External API integration and testing |
User: "Create a complete REST API for an e-commerce platform with user management, products, and orders"
Workflow:
1. Phase 1: Analyze e-commerce API requirements and design constraints
2. Phase 2: Design RESTful API architecture with proper resource modeling
3. Phase 3: Implement API endpoints with authentication and validation
4. Phase 4: Generate comprehensive API documentation and developer portal
5. Phase 5: Set up API gateway with rate limiting and monitoring
6. Phase 6: Test API performance, security, and documentation accuracy
Output: Production-ready e-commerce API with complete documentation and monitoring
User: "Implement a GraphQL API for a social media platform with real-time features"
Workflow:
1. Phase 1: Analyze GraphQL requirements and schema design needs
2. Phase 2: Design GraphQL schema with types, queries, and mutations
3. Phase 3: Implement resolvers with proper data fetching and caching
4. Phase 4: Create GraphQL documentation with schema explorer
5. Phase 5: Set up GraphQL gateway with subscriptions and real-time features
6. Phase 6: Test GraphQL queries, mutations, and subscription performance
Output: Feature-rich GraphQL API with real-time capabilities and comprehensive documentation
User: "Set up an API gateway to integrate multiple microservices with proper security and monitoring"
Workflow:
1. Phase 1: Analyze integration requirements and service dependencies
2. Phase 2: Design API gateway architecture with routing and policies
3. Phase 3: Implement gateway with authentication, rate limiting, and logging
4. Phase 4: Configure service discovery and load balancing
5. Phase 5: Set up monitoring, analytics, and alerting
6. Phase 6: Test gateway performance, security, and failover mechanisms
Output: Enterprise-grade API gateway with comprehensive security and monitoring
api-system/
├── endpoints/
│ ├── controllers/ # API endpoint implementations
│ ├── middleware/ # Authentication, validation, error handling
│ ├── routes/ # API routing and endpoint definitions
│ └── validators/ # Request/response validation
├── schemas/
│ ├── openapi/ # OpenAPI/Swagger specifications
│ ├── graphql/ # GraphQL schemas and resolvers
│ ├── models/ # Data models and DTOs
│ └── contracts/ # API contracts and interfaces
├── documentation/
│ ├── api-docs/ # Interactive API documentation
│ ├── developer-portal/ # Developer portal and guides
│ ├── examples/ # Code examples and tutorials
│ └── sdks/ # Client libraries and SDKs
├── gateway/
│ ├── config/ # API gateway configuration
│ ├── policies/ # Gateway policies and rules
│ ├── middleware/ # Custom gateway middleware
│ └── monitoring/ # Gateway monitoring and analytics
├── tests/
│ ├── unit/ # Unit tests for API endpoints
│ ├── integration/ # Integration tests for API interactions
│ ├── contract/ # API contract tests
│ └── performance/ # Load and performance tests
└── config/
├── development/ # Development environment configuration
├── staging/ # Staging environment configuration
└── production/ # Production environment configuration
This API builder skill transforms the complex process of API development into a guided, expert-supported workflow that ensures well-designed, well-documented, and production-ready APIs with comprehensive integration and monitoring capabilities.