PluginBench
Skill
Pass
Audit score 90

documentation-templates

sickn33/agentic-awesome-skills

Ready-to-use documentation templates for READMEs, APIs, code comments, and AI-friendly docs.

What is documentation-templates?

A collection of structured templates and guidelines for creating clear, maintainable documentation across projects. Use this when you need to establish documentation standards, create API docs, write code comments, or prepare your project for AI agent indexing.

  • Provides README structure templates with essential sections in priority order
  • Offers per-endpoint API documentation templates with parameters, responses, and examples
  • Includes JSDoc/TSDoc comment guidelines with best practices for when and what to document
  • Supplies Changelog template following Keep a Changelog conventions
  • Provides Architecture Decision Record (ADR) template for recording design decisions
  • Includes llms.txt and MCP-ready documentation templates for AI crawler compatibility

How to install documentation-templates

npx skills add https://github.com/sickn33/agentic-awesome-skills --skill documentation-templates
Claude Code
Cursor
Windsurf
Cline

How to use documentation-templates

  1. 1.Choose the relevant template from the skill (README, API docs, code comments, ADR, or changelog)
  2. 2.Adapt the template structure to your project's specific needs and context
  3. 3.Fill in project-specific details, examples, and explanations
  4. 4.For code comments, apply the JSDoc/TSDoc template to functions and complex logic
  5. 5.For AI compatibility, create an llms.txt file following the provided format
  6. 6.Review documentation for clarity, currency, and scanability using the listed principles
  7. 7.Keep documentation updated as your project evolves

Use cases

Good for
  • Creating a new project README with standard sections and quick-start guide
  • Documenting REST API endpoints with consistent parameter and response formatting
  • Adding JSDoc comments to TypeScript/JavaScript functions with proper parameter and return descriptions
  • Maintaining a structured changelog as you release new versions
  • Recording architectural decisions and their trade-offs for team reference
Who it's for
  • Software engineers and developers creating new projects
  • API developers documenting endpoints and contracts
  • Technical writers standardizing documentation formats
  • Teams adopting AI-friendly documentation practices
  • Open-source maintainers establishing contribution guidelines

documentation-templates FAQ

Should I use all these templates for every project?

No. Templates are starting points—adapt them to your project's actual needs. A simple script may need only a basic README; a complex API needs full endpoint documentation.

How detailed should code comments be?

Comment the 'why' and non-obvious behavior, not the obvious 'what'. Avoid commenting every line; focus on business logic, complex algorithms, and API contracts.

What is llms.txt and why do I need it?

llms.txt is a file for AI crawlers and agents to understand your project structure and key concepts. It helps with RAG indexing and improves AI agent context when working with your codebase.

How often should I update the changelog?

Update it with each release or significant change. Keep an 'Unreleased' section for ongoing work, then move it to a version number when you release.

What is an ADR and when should I write one?

An Architecture Decision Record documents important design decisions, their context, and trade-offs. Write one for significant technical choices that affect the project's direction or maintainability.

Full instructions (SKILL.md)

Source of truth, from sickn33/agentic-awesome-skills.


name: documentation-templates description: "Documentation templates and structure guidelines. README, API docs, code comments, and AI-friendly documentation." risk: safe source: community date_added: "2026-02-27"

Documentation Templates

Templates and structure guidelines for common documentation types.


1. README Structure

Essential Sections (Priority Order)

SectionPurpose
Title + One-linerWhat is this?
Quick StartRunning in <5 min
FeaturesWhat can I do?
ConfigurationHow to customize
API ReferenceLink to detailed docs
ContributingHow to help
LicenseLegal

README Template

# 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

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

/**
 * 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 algorithmsEvery line
Non-obvious behaviorSelf-explanatory code
API contractsImplementation details

4. Changelog Template (Keep a Changelog)

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

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

# 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

PrincipleWhy
ScannableHeaders, lists, tables
Examples firstShow, don't just tell
Progressive detailSimple → Complex
Up to dateOutdated = 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.

Limitations

  • Use this skill only when the task clearly matches the scope described above.
  • Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
  • Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.