Agent skill

API Documenter

by FerroxLabs in FerroxLabs/wayland

Expert API documentation covering OpenAPI/Swagger specification, endpoint documentation, request/response examples, authentication docs, error code reference, SDK documentation, interactive API…

Apache-2.0Auto-check passedBackend & APIs

Install API Documenter

skills CLI
$ npx skills add FerroxLabs/wayland --skill api-documenter -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install FerroxLabs/wayland api-documenter --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/FerroxLabs/wayland.git skills-src && mkdir -p .claude/skills && cp -r skills-src/src/process/resources/skills-library/bodies/skills/writing/api-documenter .claude/skills/api-documenter && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
api-documenter
GitHub stars
608
Token cost
~3.1k tokens
SKILL.md length
585 words
Files
1
Skills in repo
1,194
Repo updated
First seen
Licence
Apache-2.0

At a glance

Expert API documentation covering OpenAPI/Swagger specification, endpoint documentation, request/response examples, authentication docs, error code reference, SDK documentation, interactive API…

  • The user asks about api documenter
  • SKILL.md covers Overview, OpenAPI/Swagger Specification, Endpoint Documentation Structure and API Key (For server-to-server), plus 10 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
  • Api documenter best practices

What it does

API Documenter is an agent skill from FerroxLabs/wayland. Expert API documentation covering OpenAPI/Swagger specification, endpoint documentation, request/response examples, authentication docs, error code reference, SDK documentation, interactive API explorers, versioning docs, and changelog. Use when the user asks about api documenter, api documenter best practices, or needs guidance on api documenter implementation. Do NOT use when the user needs a different specialized skill or is asking about an unrelated technology domain.

Its SKILL.md is about 3.1k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Backend & APIs, covering OpenAPI specifications and Technical documentation. It works with OpenAPI. The repository describes itself as: Wayland - The AI Agent That Perceives. Reasons. Acts. Evolves. The licence is Apache-2.0.

When your agent uses it

  • The user asks about api documenter
  • Api documenter best practices
  • Needs guidance on api documenter implementation
  • The user needs a different specialized skill

Example prompts

  • “/api-documenter”

Requirements

  • Python 3

What it can do on your machine

Read from SKILL.md and the folder at commit 4c030c7. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are markdown, bash, python, yaml and json).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

API Documenter loads about 3.1k tokens when it runs. Until then it costs about 123 tokens; SKILL.md has 585 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~123
When it runs · the whole SKILL.md, loaded when a task matches
~3.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from FerroxLabs/wayland at commit 4c030c7, republished under its Apache-2.0 licence (© FerroxLabs). 585 words, ~3,066 tokens.

Download SKILL.mdSave it as .claude/skills/api-documenter/SKILL.md (or your agent's skills folder).
name
api-documenter
description
Expert API documentation covering OpenAPI/Swagger specification, endpoint documentation, request/response examples, authentication docs, error code reference, SDK documentation, interactive API explorers, versioning docs, and changelog. Use when the user asks about api documenter, api documenter best practices, or needs guidance on api documenter implementation. Do NOT use when the user needs a different specialized skill or is asking about an unrelated technology domain.
license
Apache-2.0
metadata.author
foundry-skills
metadata.version
1.0.0
metadata.tags
technical-writing documentation api-design
metadata.category
writing
metadata.subcategory
technical-writing
metadata.disclaimer
none
metadata.difficulty
intermediate

API Documenter

Overview

This skill provides comprehensive expertise in creating clear, complete, and developer-friendly API documentation. It covers the full spectrum from OpenAPI specification authoring through interactive documentation portals, covering endpoint descriptions, authentication guides, error references, SDK documentation, and versioning strategies that help developers integrate quickly and confidently.

OpenAPI/Swagger Specification

Complete OpenAPI 3.1 Template
yaml
openapi: 3.1.0
info:
  title: Product Catalog API
  description: |
    The Product Catalog API provides programmatic access to manage products,
    categories, and inventory. It supports full CRUD operations with pagination,
    filtering, and search capabilities.

    ## Getting Started
    1. [Create an API key](#section/Authentication)
    2. Make your first request to `GET /products`
    # ... (condensed) ...
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'

Endpoint Documentation Structure

Template for Each Endpoint
markdown
## Create a Product

Creates a new product in the catalog. The product will be immediately
available in search results and listing endpoints.

### Request

`POST /v2/products`

#### Headers

# ... (condensed) ...
#### 201 Created

The product was created successfully.

```json
{
  "id": "prod_8a7b6c5d",
  "name": "Wireless Headphones",
  "description": "Noise-cancelling Bluetooth headphones",
  "price": 79.99,
  "category_id": "cat_1a2b3c4d",
  "sku": "WH-NC-001",
  "metadata": {},
  "created_at": "2025-01-15T10:30:00Z",
  "updated_at": "2025-01-15T10:30:00Z"
}
Error Responses
StatusCodeDescription
400VALIDATION_ERRORInvalid or missing required fields
401UNAUTHORIZEDMissing or invalid authentication
409DUPLICATE_SKUA product with this SKU already exists
429RATE_LIMITEDToo many requests

## Authentication Documentation

### Authentication Guide Template

```markdown
# Authentication

The API supports two authentication methods:

## Bearer Token (Recommended for applications)

Obtain a JWT token by authenticating with your credentials:

```shell
HTTP client request -X POST [reference URL] \
  -H "Content-Type: application/json" \
  -d '{
    "client_id": "your_client_id",
    "client_secret": "your_client_secret"
  }'

Response:

json
{
  "access_token": "eyJhbGciOiJSUzI1NiIs...",
  "token_type": "bearer",
  "expires_in": 3600,
  "refresh_token": "dGhpcyBpcyBhIHJlZnJlc2g..."
}

Use the token in subsequent requests:

shell
HTTP client request [reference URL] \
  -H "Authorization: Bearer eyJhbGciOiJSUzI1NiIs..."  # Example only -- not a real token
Token Lifecycle
  • Access tokens expire after 1 hour
  • Use the refresh token to obtain a new access token
  • Refresh tokens expire after 30 days
  • Revoke tokens via DELETE /auth/token

API Key (For server-to-server)

Generate an API key in the [Dashboard]([reference URL]).

shell
HTTP client request [reference URL] \
  -H "X-API-Key: sk_test_EXAMPLE_KEY_REPLACE_ME"
Security Best Practices
  • Never expose API keys in client-side code
  • Rotate keys every 90 days
  • Use environment variables, not hardcoded values
  • Set IP allowlists for production keys

## Error Code Reference

### Comprehensive Error Catalog

```markdown
# Error Reference

All errors follow a consistent format:

```json
{
  "error": {
    "code": "ERROR_CODE",
    "message": "Human-readable description",
    "details": [...],
    "request_id": "req_abc123"
  }
}

Client Errors (4xx)

CodeHTTPDescriptionResolution
VALIDATION_ERROR400Request body failed validationCheck details array for specific field errors
INVALID_PARAMETER400Query parameter has invalid valueVerify parameter type and allowed values
UNAUTHORIZED401Authentication missing or invalidProvide valid token or API key
TOKEN_EXPIRED401JWT token has expiredRefresh the token via POST /auth/token/refresh
FORBIDDEN403Authenticated but lacks permissionContact admin for role/permission update
NOT_FOUND404Requested resource does not existVerify the resource ID

... (condensed) ...

|-----------------------|------|---------------------------------------------|-------------------------------------------------| | INTERNAL_ERROR | 500 | Unexpected server error | Retry with exponential backoff; contact support | | SERVICE_UNAVAILABLE | 503 | Temporary maintenance | Retry after Retry-After header duration | | GATEWAY_TIMEOUT | 504 | Upstream service timeout | Retry the request |


## SDK Documentation Pattern

### SDK Quick Start Template

```markdown
# Python SDK

## Installation

```shell
install via pip: example-sdk

Quick Start

python
from example_sdk import Client

client = Client(api_key="sk_test_EXAMPLE_KEY_REPLACE_ME")

# List products
products = client.products.list(limit=10)
for product in products:
    print(f"{product.name}: ${product.price}")

# Create a product
new_product = client.products.create(
    name="Wireless Headphones",
    price=79.99,
    category_id="cat_1a2b3c4d",
)
print(f"Created: {new_product.id}")

# Error handling
from example_sdk.exceptions import ValidationError, NotFoundError

try:
    product = client.products.get("nonexistent_id")
except NotFoundError:
    print("Product not found")
except ValidationError as e:
    print(f"Validation failed: {e.details}")

Configuration

python
client = Client(
    api_key="sk_test_EXAMPLE_KEY_REPLACE_ME",
    base_url="[reference URL]",  # Supersede for staging
    timeout=30,        # Request timeout in seconds
    max_retries=3,     # Automatic retries on 5xx / network errors
)

## Interactive API Explorer

### Tool Comparison

| Tool | Best For | Hosting |
|------|----------|---------|
| Swagger UI | OpenAPI rendering, try-it-out | Self-hosted or SwaggerHub |
| Redoc | Beautiful read-only documentation | Self-hosted or Redocly |
| Stoplight | Full documentation platform | Cloud or self-hosted |
| Postman | Interactive collections, team sharing | Cloud + desktop app |
| Readme.io | Developer hub with metrics | Cloud (SaaS) |

### Documentation Site Configuration (Redoc)

```html
<!DOCTYPE html>
<html>
<head>
  <title>Product API Documentation</title>
  <meta charset="utf-8"/>
  <link rel="icon" type="image/png" href="/favicon.png">
  <link href="[reference URL]" rel="stylesheet">
</head>
<body>
  <redoc
    spec-url="/openapi.yaml"
    # ... (condensed) ...
  ></redoc>
  <script src="[reference URL]"></script>
</body>
</html>

Versioning Documentation

Versioning Strategy Communication
markdown
# API Versioning

## Version Policy

This API uses **URL path versioning**. The current version is **v2**.

- **Major versions** (v1 → v2): Breaking changes, 12-month migration window
- **Minor updates**: Additive changes within a version, no migration needed
- **Deprecation notice**: Minimum 6 months before sunsetting a version

## What Counts as a Breaking Change
# ... (condensed) ...
| v1 Endpoint | v2 Endpoint | Changes |
|-------------|-------------|---------|
| GET /v1/products | GET /v2/products | Pagination now uses cursor-based, response wrapper added |
| POST /v1/products | POST /v2/products | `category` (string) → `category_id` (uuid) |

API Changelog

Changelog Format
markdown
# API Changelog

## 2025-01-15 - v2.1.0

### Added
- `GET /v2/products/search` - Full-text search endpoint with relevance scoring
- `metadata` field on Product object (arbitrary key-value pairs)
- `Idempotency-Key` header support on all POST endpoints

### Changed
- Default pagination limit increased from 10 to 20
# ... (condensed) ...
- `category` field replaced with `category_id` (UUID reference)

### Migration Guide
See [v1 to v2 Migration Guide](/docs/migration/v1-to-v2)

Documentation Quality Checklist

  • Every endpoint has a clear summary and description
  • All parameters document type, required status, and constraints
  • Request and response bodies include realistic examples
  • Authentication is documented with copy-pasteable code
  • Error codes are cataloged with resolution guidance
  • Rate limits are documented by plan tier
  • Pagination behavior is explained (cursor vs. offset)
  • Webhooks are documented with payload examples
  • SDK quick starts are provided for top languages
  • Changelog is maintained with every release
  • Interactive "Try it" functionality is available
  • API spec passes OpenAPI linting (Spectral or similar)
  • Versioning policy is clearly communicated
  • Deprecation timeline is visible for sunset features
Show full SKILL.md (198 more words)Show less

When to Use

Use this skill when:

  • Designing or implementing api documenter solutions
  • Reviewing or improving existing api documenter approaches
  • Making architectural or implementation decisions about api documenter
  • Learning api documenter patterns and best practices
  • Troubleshooting api documenter-related issues

Do NOT use this skill when:

  • The question is about a fundamentally different technology domain
  • A more specific sibling skill covers the exact topic needed
  • The user needs a complete hands-on tutorial rather than expert guidance

Output Format

markdown
# Api Documenter Analysis

## Context Assessment
[Situation summary and constraints]

## Recommended Approach
[Primary recommendation with rationale]

## Implementation Steps
1. [Step with specific details]
2. [Step with specific details]
3. [Step with specific details]

## Trade-offs and Considerations
- [Key trade-off 1]
- [Key trade-off 2]

## Next Steps
- [Immediate action item]
- [Follow-up action item]

Example

Input: "Help me implement api documenter for a medium-scale production application"

Output: A structured analysis covering current state assessment, recommended api documenter approach with specific patterns, implementation roadmap with milestones, and risk mitigation strategies tailored to the application scale and constraints.

Edge Cases

  • Legacy system integration: When api documenter must coexist with legacy approaches, provide a gradual migration path rather than a complete rewrite
  • Scale mismatch: When the solution complexity exceeds the project scale, recommend a simpler approach and note when to revisit
  • Team skill gaps: When the team lacks experience with the recommended approach, include learning resources and simpler alternatives
  • Conflicting requirements: When constraints conflict (e.g., performance vs. maintainability), explicitly state the trade-off and recommend based on stated priorities

© FerroxLabs, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in src/process/resources/skills-library/bodies/skills/writing/api-documenter of FerroxLabs/wayland.

Open the folder on GitHubat commit 4c030c7

Compare with similar skills

API Documenter next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

API Documenter compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
API Documenter this skillFerroxLabs/wayland608—~3.1kAutomated safety check: PassApache-2.0
CLI Creatorhuangruiteng/CS-Notes4k2 repos~2.7kAutomated safety check: PassApache-2.0
Api2clialexknowshtml/api2cli455—~2.9kAutomated safety check: PassMIT
OpenAPI Spec Generationwshobson/agents40k9 repos~511Automated safety check: PassMIT
Sap API Stylesecondsky/sap-skills460—~4.4kAutomated safety check: PassGPL-3.0
Scalarcodewithmukesh/dotnet-claude-kit7511 repos~1.6kAutomated safety check: PassMIT

Similar skills

  • CLI Creator

    huangruiteng/CS-Notes

    Build a composable CLI for Codex from API docs, an OpenAPI spec, existing curl examples, an SDK, a web app, an admin tool, or a local script.

    4k GitHub starsUsed in 2 repos~2.7k tokens
    Backend & APIsAuto-check passed
  • Api2cli

    alexknowshtml/api2cli

    Generate a working CLI from any API, then wrap it in a Claude Code skill.

    455 GitHub stars~2.9k tokensUpdated 7 mo ago
    Backend & APIsAuto-check passed
  • Create, validate and maintain OpenAPI 3.1 specs for REST APIs, whether designed first or generated from existing code, and use them for docs and client SDKs.

    40k GitHub starsUsed in 9 repos~511 tokens
    Backend & APIsAuto-check passed
  • Sap API Style

    secondsky/sap-skills

    This skill provides comprehensive guidance for documenting SAP APIs following the SAP API Style Guide standards.

    460 GitHub stars~4.4k tokensUpdated 2 days ago
    Backend & APIsAuto-check passed
  • Scalar

    codewithmukesh/dotnet-claude-kit

    Scalar API documentation UI for .NET 10 applications. An agent skill from codewithmukesh/dotnet-claude-kit.

    751 GitHub starsUsed in 1 repo~1.6k tokens
    Backend & APIsAuto-check passed
  • Code Documenter

    zebbern/claude-code-guide

    A skill your agent uses when adding docstrings, creating API documentation, or building documentation sites.

    4.6k GitHub stars~1k tokensUpdated yesterday
    Backend & APIsAuto-check passed

More from FerroxLabs/wayland

All 1,194 skills in this repo
  • Star Office Helper

    FerroxLabs/wayland

    Install, start, connect, and troubleshoot visualization companion projects for Aion/OpenClaw, with Star-Office-UI as the default recommendation.

    608 GitHub stars~2.2k tokensUpdated yesterday
    Auto-check: notes
  • Openclaw Setup

    FerroxLabs/wayland

    OpenClaw usage expert: Helps you install, deploy, configure, and use OpenClaw personal AI assistant.

    608 GitHub stars~1.9k tokensUpdated yesterday
    Auto-check passed
  • Tvcontrol Setup

    FerroxLabs/wayland

    Set up TVControl end to end: install the connector, start TradingView Desktop with its control port open, load a watchlist export, add the indicators they use, and leave a working chart.

    608 GitHub stars~5.7k tokensUpdated yesterday
    Auto-check passed
  • Ab Testing Specialist

    FerroxLabs/wayland

    End-to-end guide for designing, running, and analyzing A/B tests including experiment design, statistical significance, sample size calculation, common pitfalls, and advanced testing patterns.

    608 GitHub stars~3.7k tokensUpdated yesterday
    Auto-check passed
  • Academic Writer

    FerroxLabs/wayland

    Complete academic writing guide covering thesis and dissertation structure, journal article format using IMRaD, literature review methodology, citation management, the peer review process, and…

    608 GitHub stars~4.5k tokensUpdated yesterday
    Auto-check passed
  • Accessibility Auditor

    FerroxLabs/wayland

    Web accessibility expertise covering WCAG 2.2 conformance, audit methodology, ARIA patterns, keyboard navigation, screen reader testing, focus management, form accessibility, and automated vs manual…

    608 GitHub stars~4.1k tokensUpdated yesterday
    Auto-check passed

Works with

Questions about API Documenter

What does API Documenter do?

Expert API documentation covering OpenAPI/Swagger specification, endpoint documentation, request/response examples, authentication docs, error code reference, SDK documentation, interactive API…. API Documenter is an agent skill from FerroxLabs/wayland. Expert API documentation covering OpenAPI/Swagger specification, endpoint documentation, request/response examples, authentication docs, error code reference, SDK documentation, interactive API explorers, versioning docs, and changelog.

When should I use API Documenter?

API Documenter fits situations like: the user asks about api documenter; api documenter best practices; needs guidance on api documenter implementation; the user needs a different specialized skill.

How do I install API Documenter in Claude Code?

Run `npx skills add FerroxLabs/wayland --skill api-documenter -a claude-code`. Or copy the skill folder (src/process/resources/skills-library/bodies/skills/writing/api-documenter in FerroxLabs/wayland) into .claude/skills/api-documenter in your project. Claude Code loads it when a task matches its description.

How do I install API Documenter in Codex?

Run `npx skills add FerroxLabs/wayland --skill api-documenter -a codex`. Or copy the skill folder (src/process/resources/skills-library/bodies/skills/writing/api-documenter in FerroxLabs/wayland) into .agents/skills/api-documenter in your project. Codex loads it when a task matches its description.

Can I use API Documenter in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add FerroxLabs/wayland --skill api-documenter -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/api-documenter, .gemini/skills/api-documenter, .github/skills/api-documenter and .opencode/skills/api-documenter in your project.

What does API Documenter need to run?

SKILL.md names no scripts, command-line tools or credentials: API Documenter is instructions for the agent only. Our summary lists: Python 3.

Does API Documenter access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is API Documenter safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does API Documenter use?

API Documenter is published under the Apache-2.0 licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does API Documenter use?

About 3.1k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to API Documenter?

Skills that share tags, products or a category with API Documenter: CLI Creator (huangruiteng/CS-Notes, 4k stars), Api2cli (alexknowshtml/api2cli, 455 stars), OpenAPI Spec Generation (wshobson/agents, 40k stars) and Sap API Style (secondsky/sap-skills, 460 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains API Documenter?

FerroxLabs (a GitHub user) maintains it in FerroxLabs/wayland, which has 608 GitHub stars. The repository holds 1,194 skills in this directory. The repository was last updated on October 6, 2026.

Source: FerroxLabs/wayland on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.