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-templatesHow to use documentation-templates
- 1.Choose the relevant template from the skill (README, API docs, code comments, ADR, or changelog)
- 2.Adapt the template structure to your project's specific needs and context
- 3.Fill in project-specific details, examples, and explanations
- 4.For code comments, apply the JSDoc/TSDoc template to functions and complex logic
- 5.For AI compatibility, create an llms.txt file following the provided format
- 6.Review documentation for clarity, currency, and scanability using the listed principles
- 7.Keep documentation updated as your project evolves
Use cases
- 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
- 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
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.
Comment the 'why' and non-obvious behavior, not the obvious 'what'. Avoid commenting every line; focus on business logic, complex algorithms, and API contracts.
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.
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.
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)
| 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
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:
# 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.
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.
Related skills
More from sickn33/agentic-awesome-skills and the wider catalog.

firebase
Complete backend platform with auth, database, storage, functions, and hosting—optimize for denormalized queries and watch your costs.

frontend-design
Design and implement distinctive, high-craft frontends within brand, accessibility, and performance constraints.

frontend-dev-guidelines
Senior frontend engineering standards for scalable React apps with Suspense-first data fetching and strict TypeScript discipline.

frontend-developer
Build modern React and Next.js applications with expert component architecture, server-side rendering, and performance optimization.

2d-games
2D game development principles: sprites, physics, cameras, and genre patterns for canvas/Phaser/Kaplay/Pixi games.

gcp-cloud-run
Build production-ready serverless applications on GCP Cloud Run with optimized cold starts and event-driven architecture.