Skip to content
Skillpedia
Documentation48k · #2870

documentation-templates

Provides templates and guidelines for creating documentation. Helps organize information clearly and consistently.

What it does

This tool helps create the structure and content for various types of software project documentation. It provides templates for READMEs, API documentation, code comments, changelogs, architecture decisions, and AI-friendly documentation.

When to use it

  • ✓When starting a new project and needing a README.
  • ✓When documenting an API for other developers to understand.
  • ✓When wanting to organize important architecture decisions for your project.

Example of what to ask your AI

“Create a README template for a web application project.”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/sickn33/agentic-awesome-skills/blob/main/plugins/agentic-awesome-skills-claude/skills/documentation-templates/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/sickn33/agentic-awesome-skills/blob/main/plugins/agentic-awesome-skills-claude/skills/documentation-templates/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

The tool offers ready-made templates and structure guidelines for different documents. You choose the type of document you need, and the tool provides a skeleton for you to fill in with your project's specific information.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add sickn33/agentic-awesome-skills --skill documentation-templates

Or download just the file:

curl -L https://raw.githubusercontent.com/sickn33/agentic-awesome-skills/main/plugins/agentic-awesome-skills-claude/skills/documentation-templates/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

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

# 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

[Link to the actual project license; do not infer 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 algorithms Every line
Non-obvious behavior Self-explanatory code
API contracts Implementation 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 (the example.com links illustrate syntax; replace them with actual published project URLs):

# Project Name
> One-line objective.

## Core Files
- [Main entry](https://example.com/project/src/index.ts): Application entry
- [API routes](https://example.com/project/src/api/): Endpoint implementation
- [Documentation](https://example.com/project/docs/): User and contributor guides

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

Use when an actual project needs a README, endpoint reference, changelog, ADR or agent-readable index, and you need a structure adapted to its existing conventions.

Limitations

  • Replace illustrative paths, commands, dates and defaults with verified project facts. Templates are not installed workflows or evidence that links and examples work.
  • Preserve the actual license and confidentiality scope; do not publish private endpoints or invent accepted ADR decisions.
  • 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.
FAQ

What is a README?

It's the first file people see when they visit your project's code. It explains what the project does, how to use it, and how to contribute.

What is API documentation?

It's a guide that explains how to use the different parts (endpoints) of a software service, including what each part does, what data it expects, and what it returns.

What are ADRs?

ADRs (Architecture Decision Records) are short documents that record important decisions about a project's architecture, explaining the context, the decision made, and its consequences.

Details

Original description by the author

Documentation templates and structure guidelines. README, API docs, code comments, and AI-friendly documentation.

repo: sickn33/agentic-awesome-skills

Popularity

GitHub stars
48k
Ranking position
#2870
License
MIT
Updated
10/15/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills