documentation-templates
Documentation templates and structure guidelines. README, API docs, code comments, and AI-friendly documentation.
About this skill
This skill equips an AI agent with a comprehensive set of templates and structural guidelines for generating high-quality, consistent, and AI-friendly documentation. It covers essential documentation types such as project READMEs, detailed API documentation, and in-code comments. By adhering to these predefined structures, AI agents can produce documentation that is easy to read, navigate, and understand for both human developers and other AI systems. The guidelines emphasize clarity, conciseness, and the inclusion of critical sections like quick starts, features, configuration, and licensing, making documentation generation more efficient and effective. This skill acts as a knowledge base for an AI agent tasked with creating structured content.
Best use case
Generating new project documentation (e.g., READMEs, CONTRIBUTING guides) that adheres to specific standards. Standardizing documentation across multiple projects or modules to maintain a uniform style. Assisting in the creation of comprehensive API reference documentation with consistent formatting. Improving code readability and maintainability through structured and informative code comments. Ensuring AI-generated documentation meets predefined quality and structure requirements.
Documentation templates and structure guidelines. README, API docs, code comments, and AI-friendly documentation.
Structured, consistent, and high-quality documentation (e.g., README files, API specifications, code comments). Documentation that adheres to predefined organizational or project-specific standards and best practices. Improved clarity, readability, and maintainability of project information. Enhanced AI-readiness for documentation, facilitating further automated processing, summarization, or translation.
Practical example
Example input
{"agent_instruction": "Please generate a comprehensive README.md file for a new Node.js project. The project is a REST API for managing user profiles, featuring CRUD operations, authentication, and database integration. Ensure the README follows the standard structure, including sections for Quick Start, Features, Configuration, API Reference, and Contributing as outlined in the documentation-templates guidelines.", "project_details": {"name": "UserProfilesAPI", "language": "Node.js", "features": ["CRUD operations", "JWT authentication", "MongoDB integration"], "setup_steps": ["npm install", "configure .env", "npm start"]}}Example output
```markdown
# UserProfilesAPI
A RESTful API for managing user profiles, built with Node.js, Express, and MongoDB.
## Quick Start
Get your local development environment up and running in minutes.
1. **Clone the repository:**
```bash
git clone https://github.com/yourusername/userprofilesapi.git
cd userprofilesapi
```
2. **Install dependencies:**
```bash
npm install
```
3. **Configure environment variables:**
Create a `.env` file in the root directory and add:
```
PORT=3000
MONGO_URI=mongodb://localhost:27017/userprofiles_db
JWT_SECRET=your_super_secret_key
```
4. **Start the server:**
```bash
npm start
```
The API will be available at `http://localhost:3000`.
## Features
* **User Management:** Create, Read, Update, and Delete (CRUD) user profiles.
* **Authentication:** Secure user access using JSON Web Tokens (JWT).
* **Database Integration:** Seamlessly connect with MongoDB for data persistence.
* **Input Validation:** Robust validation for all incoming API requests.
## Configuration
Customization options can be set in the `.env` file:
* `PORT`: Port for the API server (default: `3000`).
* `MONGO_URI`: MongoDB connection string.
* `JWT_SECRET`: Secret key for JWT signing.
## API Reference
Detailed API endpoints and request/response schemas can be found in the [API Documentation](docs/api.md).
### Key Endpoints:
* `POST /api/auth/register` - Register a new user
* `POST /api/auth/login` - Authenticate user and get a token
* `GET /api/users` - Get all user profiles (admin only)
* `GET /api/users/:id` - Get a single user profile
* `PUT /api/users/:id` - Update a user profile
* `DELETE /api/users/:id` - Delete a user profile
## Contributing
We welcome contributions! Please see our [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines on how to submit issues, pull requests, and coding standards.
## License
This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
```When to use this skill
- When an AI agent is tasked with creating any form of project or code documentation.
- When a uniform documentation style and structure are required across an organization or codebase.
- When you need to ensure generated documentation is clear, complete, and easy for other AI tools to parse and process.
- When aiming to streamline the documentation process by leveraging AI for structured content generation.
When not to use this skill
- When the documentation needs are highly specialized or informal and do not benefit from adherence to a strict template.
- When the agent's primary task is purely analytical, data processing, or generative without a documentation output requirement.
- When a quick, informal note or simple textual output is sufficient, not requiring a structured format.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/documentation-templates/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How documentation-templates Compares
| Feature / Agent | documentation-templates | Standard Approach |
|---|---|---|
| Platform Support | Claude | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | easy | N/A |
Frequently Asked Questions
What does this skill do?
Documentation templates and structure guidelines. README, API docs, code comments, and AI-friendly documentation.
Which AI agents support this skill?
This skill is designed for Claude.
How difficult is it to install?
The installation complexity is rated as easy. You can find the installation instructions above.
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.
Related Guides
Best AI Skills for Claude
Explore the best AI skills for Claude and Claude Code across coding, research, workflow automation, documentation, and agent operations.
AI Agents for Coding
Browse AI agent skills for coding, debugging, testing, refactoring, code review, and developer workflows across Claude, Cursor, and Codex.
ChatGPT vs Claude for Agent Skills
Compare ChatGPT and Claude for AI agent skills across coding, writing, research, and reusable workflow execution.
SKILL.md Source
# Documentation Templates > Templates and structure guidelines for common documentation types. --- ## 1. README Structure ### Essential Sections (Priority Order) | Section | Purpose | |---------|---------| | **Title + One-liner** | What is this? | | **Quick Start** | Running in <5 min | | **Features** | What can I do? | | **Configuration** | How to customize | | **API Reference** | Link to detailed docs | | **Contributing** | How to help | | **License** | Legal | ### README Template ```markdown # Project Name Brief one-line description. ## Quick Start [Minimum steps to run] ## Features - Feature 1 - Feature 2 ## Configuration | Variable | Description | Default | |----------|-------------|---------| | PORT | Server port | 3000 | ## Documentation - API Reference - Architecture ## License MIT ``` --- ## 2. API Documentation Structure ### Per-Endpoint Template ```markdown ## GET /users/:id Get a user by ID. **Parameters:** | Name | Type | Required | Description | |------|------|----------|-------------| | id | string | Yes | User ID | **Response:** - 200: User object - 404: User not found **Example:** [Request and response example] ``` --- ## 3. Code Comment Guidelines ### JSDoc/TSDoc Template ```typescript /** * Brief description of what the function does. * * @param paramName - Description of parameter * @returns Description of return value * @throws ErrorType - When this error occurs * * @example * const result = functionName(input); */ ``` ### When to Comment | ✅ Comment | ❌ Don't Comment | |-----------|-----------------| | Why (business logic) | What (obvious) | | Complex algorithms | Every line | | Non-obvious behavior | Self-explanatory code | | API contracts | Implementation details | --- ## 4. Changelog Template (Keep a Changelog) ```markdown # Changelog ## [Unreleased] ### Added - New feature ## [1.0.0] - 2025-01-01 ### Added - Initial release ### Changed - Updated dependency ### Fixed - Bug fix ``` --- ## 5. Architecture Decision Record (ADR) ```markdown # ADR-001: [Title] ## Status Accepted / Deprecated / Superseded ## Context Why are we making this decision? ## Decision What did we decide? ## Consequences What are the trade-offs? ``` --- ## 6. AI-Friendly Documentation (2025) ### llms.txt Template For AI crawlers and agents: ```markdown # Project Name > One-line objective. ## Core Files - [src/index.ts]: Main entry - [src/api/]: API routes - [docs/]: Documentation ## Key Concepts - Concept 1: Brief explanation - Concept 2: Brief explanation ``` ### MCP-Ready Documentation For RAG indexing: - Clear H1-H3 hierarchy - JSON/YAML examples for data structures - Mermaid diagrams for flows - Self-contained sections --- ## 7. Structure Principles | Principle | Why | |-----------|-----| | **Scannable** | Headers, lists, tables | | **Examples first** | Show, don't just tell | | **Progressive detail** | Simple → Complex | | **Up to date** | Outdated = misleading | --- > **Remember:** Templates are starting points. Adapt to your project's needs. ## When to Use This skill is applicable to execute the workflow or actions described in the overview.
Related Skills
internal-comms-community
To write internal communications, use this skill for:
internal-comms-anthropic
To write internal communications, use this skill for:
brand-guidelines
Write copy following Sentry brand guidelines. Use when writing UI text, error messages, empty states, onboarding flows, 404 pages, documentation, marketing copy, or any user-facing content. Covers both Plain Speech (default) and Sentry Voice tones.
fal-ai-media
Unified media generation via fal.ai MCP — image, video, and audio. Covers text-to-image (Nano Banana), text/image-to-video (Seedance, Kling, Veo 3), text-to-speech (CSM-1B), and video-to-audio (ThinkSound). Use when the user wants to generate images, videos, or audio with AI.
incident-runbook-templates
Production-ready templates for incident response runbooks covering detection, triage, mitigation, resolution, and communication.
fastapi-templates
Create production-ready FastAPI projects with async patterns, dependency injection, and comprehensive error handling. Use when building new FastAPI applications or setting up backend API projects.
employment-contract-templates
Templates and patterns for creating legally sound employment documentation including contracts, offer letters, and HR policies.
documentation
Documentation generation workflow covering API docs, architecture docs, README files, code comments, and technical writing.
documentation-generation-doc-generate
You are a documentation expert specializing in creating comprehensive, maintainable documentation from code. Generate API docs, architecture diagrams, user guides, and technical references using AI-powered analysis and industry best practices.
defi-protocol-templates
Implement DeFi protocols with production-ready templates for staking, AMMs, governance, and lending systems. Use when building decentralized finance applications or smart contract protocols.
code-documentation-doc-generate
You are a documentation expert specializing in creating comprehensive, maintainable documentation from code. Generate API docs, architecture diagrams, user guides, and technical references using AI-powered analysis and industry 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 explanations for developers at all levels.