documentation
API documentation with OpenAPI and developer portals
Best use case
documentation is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
API documentation with OpenAPI and developer portals
Teams using documentation should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/documentation/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How documentation Compares
| Feature / Agent | documentation | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
API documentation with OpenAPI and developer portals
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# API Documentation Skill
## Purpose
Create comprehensive API documentation.
## OpenAPI 3.1 Structure
```yaml
openapi: 3.1.0
info:
title: My API
version: 1.0.0
description: |
API description with **markdown** support.
## Authentication
Use Bearer tokens.
servers:
- url: https://api.example.com
description: Production
paths:
/users:
get:
operationId: listUsers
summary: List all users
tags: [Users]
parameters:
- $ref: '#/components/parameters/PageParam'
responses:
'200':
description: Success
content:
application/json:
schema:
$ref: '#/components/schemas/UserList'
components:
schemas:
User:
type: object
required: [id, name]
properties:
id:
type: string
format: uuid
name:
type: string
```
## Code Examples
### Multiple Languages
```yaml
# In OpenAPI
paths:
/users:
post:
x-codeSamples:
- lang: curl
source: |
curl -X POST https://api.example.com/users \
-H "Authorization: Bearer TOKEN" \
-d '{"name": "John"}'
- lang: python
source: |
import requests
requests.post('https://api.example.com/users',
headers={'Authorization': 'Bearer TOKEN'},
json={'name': 'John'})
- lang: javascript
source: |
await fetch('https://api.example.com/users', {
method: 'POST',
headers: { 'Authorization': 'Bearer TOKEN' },
body: JSON.stringify({ name: 'John' })
});
```
## SDK Generation
```bash
# Generate TypeScript SDK
npx @openapitools/openapi-generator-cli generate \
-i openapi.yaml \
-g typescript-fetch \
-o ./sdk
# Generate Python SDK
openapi-generator generate \
-i openapi.yaml \
-g python \
-o ./sdk-python
```
## Changelog Format
```markdown
# Changelog
## [1.2.0] - 2024-12-30
### Added
- `GET /users/export` endpoint
### Changed
- `POST /users` now returns 201
### Deprecated
- `GET /users/:id/profile` (use `/users/:id`)
### Fixed
- Pagination cursor encoding
```
---
## Unit Test Template
```typescript
import { validate } from '@apidevtools/swagger-parser';
describe('OpenAPI Spec', () => {
it('should be valid OpenAPI 3.1', async () => {
const api = await validate('./openapi.yaml');
expect(api.openapi).toMatch(/^3\.1\./);
});
it('should have examples for all endpoints', async () => {
const api = await validate('./openapi.yaml');
Object.values(api.paths).forEach(path => {
Object.values(path).forEach(operation => {
if (operation.responses?.['200']) {
expect(operation.responses['200'].content)
.toHaveProperty('application/json.examples');
}
});
});
});
});
```
---
## Troubleshooting
| Issue | Cause | Solution |
|-------|-------|----------|
| Spec validation fails | Invalid syntax | Use spectral linter |
| SDK types wrong | Schema mismatch | Regenerate from spec |
| Missing examples | Incomplete docs | Add request/response examples |
---
## Quality Checklist
- [ ] OpenAPI spec validates
- [ ] All endpoints documented
- [ ] Request/response examples
- [ ] Error responses documented
- [ ] Authentication explained
- [ ] SDKs generated and testedRelated Skills
using-live-documentation
Use BEFORE implementing, writing, configuring, or setting up ANY feature involving libraries, frameworks, or complex APIs - even before reading existing code. Fetches current documentation to ensure correct usage. Triggers on third-party libraries (such as react-query, FastAPI, Django, pytest), complex standard library modules (such as subprocess, streams, pathlib, logging), and "how to" questions about library usage. Do NOT use for trivial built-ins (such as dict.get, Array.map) or pure algorithms. Load this skill first to receive guidance on finding current documentation when implementing features, exploring code, or answering library-related questions.
architecture-documentation-creator
Create comprehensive technical documentation for code systems including data flow diagrams, architecture overviews, algorithm documentation, cheat sheets, and multi-file documentation sets. Use when documenting pipelines, algorithms, system architecture, data flow, multi-stage processes, similarity algorithms, or creating developer onboarding materials. Covers Mermaid diagrams, progressive disclosure, critical patterns, JSON schemas, Pydantic models, and print-friendly reference materials.
api-documentation-generator
Generate comprehensive, developer-friendly API documentation from code, including endpoints, parameters, examples, and best practices
AI SDK Documentation
This skill should be used when working with Vercel AI SDK, AI Gateway, streamText, generateText, generateObject, streamObject, tool calling, or AI SDK providers. Also relevant for "ai-sdk", "@ai-sdk/*" packages, or questions about AI SDK patterns, configuration, and best practices.
code-documentation-code-explain
You are a code education expert specializing in explaining complex code through clear narratives, visual diagrams, and step-by-step breakdowns. Transform difficult concepts into understandable expl...
api-reference-documentation
Creates professional API documentation using OpenAPI specifications with endpoints, authentication, and interactive examples. Use when documenting REST APIs, creating SDK references, or building developer portals.
api-documentation
API documentation standards and patterns
api-documentation-writer
Expert guide for writing comprehensive API documentation including OpenAPI specs, endpoint references, authentication guides, and code examples. Use when documenting APIs, creating developer portals, or improving API discoverability.
api-documentation-question
Answer API and technical documentation questions. Use when a customer asks about API usage, code implementation, or integration details.
bgo
Automates the complete Blender build-go workflow, from building and packaging your extension/add-on to removing old versions, installing, enabling, and launching Blender for quick testing and iteration.
writing-skills
Use when creating new skills, editing existing skills, or verifying skills work before deployment
writing-claude-md-files
Use when creating or updating CLAUDE.md files for projects or subdirectories - covers top-level vs domain-level organization, capturing architectural intent and contracts, and mandatory freshness dates