api-builder

What this skill does

# API Builder - Complete API Development Workflow

## Overview

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:**
- 🏗️ **Multi-Protocol API Design** - RESTful APIs, GraphQL, gRPC, and WebSocket implementations
- 📚 **Comprehensive Documentation** - Auto-generated API docs, interactive testing, and developer guides
- 🔧 **Integration Architecture** - API gateways, middleware, and third-party service integration
- 📊 **API Analytics & Monitoring** - Usage tracking, performance monitoring, and error analysis
- 🛡️ **API Security & Governance** - Authentication, rate limiting, and API lifecycle management

## When to Use This Skill

**Perfect for:**
- RESTful API design and implementation
- GraphQL schema development and resolver implementation
- API gateway setup and middleware configuration
- API documentation generation and developer portal creation
- API integration patterns and third-party service connections
- API versioning and lifecycle management

**Triggers:**
- "Design and implement a REST API for [application]"
- "Create a GraphQL API with [features]"
- "Set up an API gateway with [middleware]"
- "Generate comprehensive API documentation"
- "Implement API integration with [service]"

## API Development Expert Panel

### **API Architect** (API Design & Architecture)
- **Focus**: API design patterns, protocol selection, architectural decisions
- **Techniques**: RESTful design, GraphQL schema design, API composition
- **Considerations**: Scalability, maintainability, developer experience, performance

### **Integration Specialist** (API Integration & Middleware)
- **Focus**: API gateways, middleware, third-party integrations
- **Techniques**: API composition, service mesh, event-driven architecture
- **Considerations**: Latency, reliability, security, monitoring

### **Documentation Expert** (API Documentation & Developer Experience)
- **Focus**: API documentation, developer portals, interactive testing
- **Techniques**: OpenAPI/Swagger, GraphQL docs, API testing frameworks
- **Considerations**: Developer experience, documentation accuracy, discoverability

### **API Security Specialist** (API Security & Governance)
- **Focus**: API security, authentication, authorization, governance
- **Techniques**: OAuth 2.0, API keys, rate limiting, threat protection
- **Considerations**: Security by design, compliance, usability

### **Performance Engineer** (API Optimization & Monitoring)
- **Focus**: API performance, caching, monitoring, analytics
- **Techniques**: Response optimization, caching strategies, load balancing
- **Considerations**: Response times, throughput, resource utilization

## API Development Workflow

### Phase 1: API Requirements Analysis & Design Planning
**Use when**: Starting API development or API modernization

**Tools Used:**
```bash
/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:**
- Analyze business requirements and translate to API specifications
- Identify API protocols and architectural patterns
- Define API contracts and data models
- Plan integration points and external dependencies
- Establish API governance and versioning strategy

### Phase 2: API Architecture & Protocol Design
**Use when**: Designing the API structure and choosing protocols

**Tools Used:**
```bash
/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:**
- Design API architecture and protocol selection (REST/GraphQL/gRPC)
- Create API specifications and data contracts
- Design endpoint structures and resource relationships
- Plan API composition and orchestration patterns
- Define error handling and response formats

### Phase 3: API Implementation & Development
**Use when**: Writing the actual API code and business logic

**Tools Used:**
```bash
/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:**
- Implement API endpoints and business logic
- Create middleware for authentication, validation, and error handling
- Implement data validation and serialization
- Create API versioning and backward compatibility
- Write unit and integration tests for API endpoints

### Phase 4: API Documentation & Developer Experience
**Use when**: Creating comprehensive API documentation and developer resources

**Tools Used:**
```bash
/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:**
- Generate OpenAPI/Swagger specifications
- Create interactive API documentation and testing interfaces
- Develop SDKs and client libraries
- Write integration guides and code examples
- Create developer portal and onboarding materials

### Phase 5: API Gateway & Integration Setup
**Use when**: Setting up API gateway, middleware, and integrations

**Tools Used:**
```bash
/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:**
- Configure API gateway with routing and policies
- Implement middleware for authentication, rate limiting, and logging
- Set up API composition and orchestration
- Configure caching and performance optimization
- Implement API monitoring and analytics

### Phase 6: API Testing & Quality Assurance
**Use when**: Ensuring API reliability, performance, and security

**Tools Used:**
```bash
/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:**
- Implement comprehensive API test suites (unit, integration, E2E)
- Conduct load testing and performance benchmarking
- Perform security testing and vulnerability assessment
- Validate API contracts and documentation accuracy
- Test error scenarios and recovery mechanisms

## Integration Patterns

### **SuperClaude Command Integration**

| 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 |

### **API Protocol Integration**

| 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 |

### **MCP Server Integration**

| 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 |

## Usage Examples

### Example 1: Complete REST API Development