Claude Skills: How to Create Custom AI Workflows

name: Code Review Skill
version: 1.0.0
category: Development
triggers: ["code_review", "review_code", "check_quality"]

When reviewing code:
1. Check for security vulnerabilities
2. Verify style consistency
3. Evaluate performance implications
4. Assess maintainability...

- All security issues highlighted
- Specific, actionable feedback
- Clear priority levels
- Consistent style

# Custom API Documentation Skill

## Skill Overview

This Skill teaches Claude how to generate comprehensive API documentation from source code. It understands patterns specific to RESTful APIs, handles endpoint documentation, request/response schemas, authentication methods, and error handling.

## When to Use This Skill

- Documenting REST API endpoints
- Creating OpenAPI/Swagger specifications
- Generating client SDK documentation
- Writing API migration guides
- Creating integration guides for API consumers

## Skill Context

### Our API Standards

1. All endpoints use RESTful conventions
2. Responses include standard headers (X-Request-ID, Content-Type)
3. Errors follow RFC 7807 Problem Details format
4. Authentication via JWT Bearer tokens
5. Rate limiting headers in responses
6. Pagination uses cursor-based approach

### Documentation Requirements

Each endpoint must document:
- HTTP method and path
- Authentication requirements
- Request parameters (path, query, body)
- Response codes and bodies
- Rate limit considerations
- Example requests and responses
- Common error scenarios
- SDK method signatures

## Procedure

When generating API documentation:

1. **Parse the API structure**
   - Identify all endpoints
   - Extract HTTP methods, paths, handlers
   - Map request/response types

2. **Analyze endpoint details**
   - Required vs optional parameters
   - Parameter validation rules
   - Response status codes
   - Error scenarios

3. **Document systematically**
   - Start with overview and authentication
   - Document each endpoint in a consistent format
   - Include practical examples
   - Document error handling
   - Add implementation notes

4. **Include usage patterns**
   - Basic usage examples
   - Authentication examples
   - Handling pagination
   - Error handling patterns
   - Rate limit awareness

5. **Quality check**
   - Verify all endpoints covered
   - Check consistency across documentation
   - Ensure examples are accurate and runnable
   - Confirm style and tone consistency

## Quality Standards

- Documentation must be complete and current
- Examples must be accurate (test them mentally)
- Rate limits clearly explained
- Authentication clearly documented
- All error codes explained
- Consistent formatting across all endpoints
- Professional tone suitable for external developers

## Example: Documenting a User Endpoint

### Input Code
```python
@app.get("/api/v1/users/{user_id}")
async def get_user(user_id: str, include_metadata: bool = False):
    """Get user by ID"""
    user = await db.users.find_one({"_id": user_id})
    if not user:
        raise HTTPException(404, "User not found")
    if include_metadata:
        user["metadata"] = await db.get_user_metadata(user_id)
    return user

## Get User

**Endpoint:** `GET /api/v1/users/{user_id}`

**Authentication:** Required (Bearer token)

**Parameters:**
- `user_id` (path, required): User ID
- `include_metadata` (query, optional): Include user metadata (default: false)

**Response:** 200 OK
```json
{
  "id": "user123",
  "email": "user@example.com",
  "created_at": "2024-01-15T10:30:00Z",
  "metadata": { ... } // Only if include_metadata=true
}

curl -H "Authorization: Bearer TOKEN" 
  "https://api.example.com/api/v1/users/user123?include_metadata=true"

## Skill Integration Points

### With Claude Code

Claude Code integrates with Skills through commands:

```bash
/api-docs --endpoint /users/{id} --output markdown

Code Change Detected
  ↓
Trigger Test Generation Skill
  ↓
Test Suite Generated
  ↓
Trigger Code Review Skill
  ↓
Review Complete
  ↓
Trigger Documentation Skill
  ↓
Updated Documentation Generated

# Blog Post Writing Skill

## Purpose
Generate blog posts that rank well for target keywords while providing genuine value.

## Key Context
- Target audience: AI/ML developers
- Tone: Educational but accessible
- Structure: Hook → Problem → Solution → Real example → Takeaways
- Must include code examples where relevant

## Quality Standards
- 2000+ words for in-depth articles
- Clear heading hierarchy
- Practical code examples (tested)
- Internal linking (3-5 links per post)
- CTA (2 strategic placements)
- SEO optimization

# Complete Code Review Skill

## Evaluation Dimensions
1. Correctness: Does it work as intended?
2. Performance: Are there optimization opportunities?
3. Security: Are there vulnerabilities or unsafe patterns?
4. Maintainability: Will others understand this code?
5. Style: Consistency with team standards
6. Tests: Adequate coverage and quality

## Standards
- All feedback includes severity level
- Provide alternatives for issues found
- Highlight good patterns worth replicating
- Specific, actionable recommendations

# Statistical Analysis Skill

## Methodology
1. Data validation and cleaning
2. Descriptive statistics
3. Distribution analysis
4. Hypothesis testing
5. Visualization recommendations
6. Insight summarization

## Output Format
- Executive summary
- Statistical findings
- Confidence levels and p-values
- Visualizations descriptions
- Actionable recommendations

Our codebase uses:
- PEP 8 for Python style
- 4-space indentation
- Type hints on all functions
- Docstrings for public APIs

Good Example:
```python
def validate_email(email: str) -> bool:
    """Validate email format.

    Args:
        email: Email address to validate

    Returns:
        True if valid, False otherwise
    """

def validate_email(email):
    # check email

Quality standards:
- All functions have docstrings
- No lines exceed 100 characters
- All imports sorted alphabetically
- Type hints on all parameters
- Passes mypy strict mode

Special cases:
- Empty input should return null, not error
- Unicode characters supported in names
- International phone numbers accepted
- Timezone-aware datetime handling required

User Request
  ↓
Documentation Review Skill
  ↓
(Identifies gaps)
  ↓
Content Creation Skill
  ↓
(Generates new content)
  ↓
SEO Optimization Skill
  ↓
(Optimizes for keywords)
  ↓
Quality Check Skill
  ↓
Final Output

Code Review Skill analysis → Detects performance issue
  ↓
Recommends Performance Optimization Skill
  ↓
Performance Skill generates optimization

v1.0: Original implementation
v1.1: Bug fixes (backwards compatible)
v2.0: New features (breaking changes noted)