Documentation Generator

Name: Documentation Generator
Author: aiskillstore

aiskillstore/marketplace

1 installs
404 repo stars
Updated August 5, 2026
aiskillstore/marketplace

documentation-generator is a Claude skill that auto-generates JSDoc, docstrings, README files, and API documentation from code.

About

This skill auto-generates code documentation such as JSDoc, docstrings, README files, and API reference. It analyzes function signatures, parameters, return values, and exceptions, then emits documentation in the right format for the language. A developer uses it to document undocumented code or produce a project README.

Auto-generates JSDoc, docstrings, README files, and API documentation
Supports JSDoc, Python docstrings, Rustdoc, Javadoc, and GoDoc
Analyzes signatures, parameters, return types, exceptions, and examples

Documentation Generator by the numbers

1 all-time installs (skills.sh)
Ranked #1,366 of 1,879 Documentation skills by installs in the Skillselion catalog
Data as of Aug 5, 2026 (Skillselion catalog sync)

At a glance

documentation-generator capabilities & compatibility

Free; no API keys required.

Capabilities: doc generation · readme generation · api doc generation
Use cases: documentation
Runs: Runs locally
Pricing: Free

From the docs

What documentation-generator says it does

Auto-generate JSDoc, docstrings, README files, and API documentation.

SKILL.md

Generate only missing documentation, don't overwrite custom docs

SKILL.md

npx skills add https://github.com/aiskillstore/marketplace --skill documentation-generator

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/aiskillstore/marketplace/documentation-generator.svg)](https://skillselion.com/skills/aiskillstore/marketplace/documentation-generator)

Installs	1
repo stars	★ 404
Last updated	August 5, 2026
Repository	aiskillstore/marketplace ↗

What it does

Auto-generate code docstrings, JSDoc, README, and API documentation from source code.

When should I use this skill?

When code lacks documentation and you need JSDoc, docstrings, a README, or API reference.

What you get

Generated docstrings, JSDoc, README, or API docs matching the code.

JSDoc comments
docstrings
README file

By the numbers

5 documentation formats supported
3 Python docstring styles (Google, NumPy, Sphinx)

Files

SKILL.mdMarkdownGitHub ↗

Documentation Generator Skill

Auto-generate JSDoc, docstrings, README files, and API documentation.

Instructions

You are a documentation expert. When invoked:

1. Analyze Code: Examine code to understand:

Function/method signatures and parameters
Return types and values
Exceptions/errors that may be thrown
Side effects and dependencies
Usage examples

2. Generate Documentation: Create appropriate documentation:

JSDoc for JavaScript/TypeScript
Docstrings for Python (Google, NumPy, or Sphinx style)
Rustdoc for Rust
Javadoc for Java
GoDoc for Go

3. Include Essential Elements:

Brief description of purpose
Parameter descriptions with types
Return value description
Exceptions/errors
Usage examples
Notes about edge cases or performance

4. README Generation: For project-level docs:

Project overview and purpose
Installation instructions
Usage examples
API reference
Configuration options
Contributing guidelines
License information

Documentation Standards

JavaScript/TypeScript (JSDoc)

/**
 * Calculates the total price including tax and discounts
 *
 * @param {number} basePrice - The original price before adjustments
 * @param {number} taxRate - Tax rate as decimal (e.g., 0.08 for 8%)
 * @param {number} [discount=0] - Optional discount as decimal (0-1)
 * @returns {number} The final price after tax and discounts
 * @throws {Error} If basePrice or taxRate is negative
 *
 * @example
 * const total = calculateTotal(100, 0.08, 0.1);
 * // Returns 97.2 (100 - 10% discount + 8% tax)
 */

Python (Google Style)

def calculate_total(base_price: float, tax_rate: float, discount: float = 0) -> float:
    """Calculates the total price including tax and discounts.

    Args:
        base_price: The original price before adjustments
        tax_rate: Tax rate as decimal (e.g., 0.08 for 8%)
        discount: Optional discount as decimal (0-1). Defaults to 0.

    Returns:
        The final price after tax and discounts

    Raises:
        ValueError: If base_price or tax_rate is negative

    Example:
        >>> calculate_total(100, 0.08, 0.1)
        97.2
    """

Usage Examples

@documentation-generator
@documentation-generator src/utils/
@documentation-generator --format jsdoc
@documentation-generator --readme-only
@documentation-generator UserService.js

README Template Structure

# Project Name

Brief description of what this project does

## Features

- Key feature 1
- Key feature 2
- Key feature 3

## Installation

npm install package-name


## Usage

// Basic usage example


## API Reference

### ClassName

#### method(param1, param2)

Description...

## Configuration

## Contributing

## License

Documentation Best Practices

Be Concise: Clear and to the point
Use Examples: Show real-world usage
Keep Updated: Documentation should match code
Explain Why: Not just what, but why decisions were made
Link References: Link to related functions, types, or docs
Format Consistently: Follow project conventions
Avoid Jargon: Use clear, accessible language

What to Document

Functions/Methods

Purpose and behavior
All parameters (name, type, constraints)
Return values
Side effects
Exceptions
Complexity (if relevant)

Classes

Purpose and responsibilities
Constructor parameters
Public methods and properties
Usage examples
Inheritance relationships

Modules/Packages

Overall purpose
Main exports
Dependencies
Getting started guide

Notes

Match existing documentation style in the project
Generate only missing documentation, don't overwrite custom docs
Include practical examples, not just trivial ones
Highlight important edge cases and gotchas
Keep documentation close to the code it describes

{
  "schema_version": "2.0",
  "meta": {
    "generated_at": "2026-01-16T22:21:16.343Z",
    "slug": "curiouslearner-documentation-generator",
    "source_url": "https://github.com/CuriousLearner/devkit/tree/main/skills/documentation-generator",
    "source_ref": "main",
    "model": "claude",
    "analysis_version": "3.0.0",
    "source_type": "community",
    "content_hash": "640febd6fbc5028961b0333e3c29b934684d78a0e82c654cb6764322e4877a09",
    "tree_hash": "bd8faca23b74950b0e65b914981cd8068f01fa5aee90ef09d47ddf3102aeb6b7"
  },
  "skill": {
    "name": "documentation-generator",
    "description": "Auto-generate JSDoc, docstrings, README files, and API documentation.",
    "summary": "Auto-generate JSDoc, docstrings, README files, and API documentation.",
    "icon": "📝",
    "version": "1.0.0",
    "author": "CuriousLearner",
    "license": "MIT",
    "category": "documentation",
    "tags": [
      "documentation",
      "code-quality",
      "api-docs",
      "readme"
    ],
    "supported_tools": [
      "claude",
      "codex",
      "claude-code"
    ],
    "risk_factors": [
      "network",
      "filesystem",
      "external_commands"
    ]
  },
  "security_audit": {
    "risk_level": "safe",
    "is_blocked": false,
    "safe_to_publish": true,
    "summary": "This is a pure prompt-based skill containing only documentation generation instructions for AI assistants. The static scanner flagged metadata fields (source URLs, content hashes), markdown code examples (backticks in code fences), and documentation keywords as security issues. All 30 findings are false positives - no executable code, network calls, command execution, or file system access exists in this skill.",
    "risk_factor_evidence": [
      {
        "factor": "network",
        "evidence": [
          {
            "file": "skill-report.json",
            "line_start": 6,
            "line_end": 6
          }
        ]
      },
      {
        "factor": "filesystem",
        "evidence": [
          {
            "file": "skill-report.json",
            "line_start": 117,
            "line_end": 117
          }
        ]
      },
      {
        "factor": "external_commands",
        "evidence": [
          {
            "file": "SKILL.md",
            "line_start": 48,
            "line_end": 62
          },
          {
            "file": "SKILL.md",
            "line_start": 62,
            "line_end": 65
          },
          {
            "file": "SKILL.md",
            "line_start": 65,
            "line_end": 84
          },
          {
            "file": "SKILL.md",
            "line_start": 84,
            "line_end": 88
          },
          {
            "file": "SKILL.md",
            "line_start": 88,
            "line_end": 94
          },
          {
            "file": "SKILL.md",
            "line_start": 94,
            "line_end": 98
          },
          {
            "file": "SKILL.md",
            "line_start": 98,
            "line_end": 111
          },
          {
            "file": "SKILL.md",
            "line_start": 111,
            "line_end": 113
          },
          {
            "file": "SKILL.md",
            "line_start": 113,
            "line_end": 117
          },
          {
            "file": "SKILL.md",
            "line_start": 117,
            "line_end": 119
          },
          {
            "file": "SKILL.md",
            "line_start": 119,
            "line_end": 134
          }
        ]
      }
    ],
    "critical_findings": [],
    "high_findings": [],
    "medium_findings": [],
    "low_findings": [],
    "dangerous_patterns": [],
    "files_scanned": 2,
    "total_lines": 354,
    "audit_model": "claude",
    "audited_at": "2026-01-16T22:21:16.343Z"
  },
  "content": {
    "user_title": "Generate documentation for code",
    "value_statement": "Writing documentation takes significant time and is often neglected. This skill automates the creation of JSDoc, docstrings, README files, and API documentation across multiple programming languages.",
    "seo_keywords": [
      "documentation generator",
      "JSDoc",
      "docstrings",
      "API documentation",
      "README generator",
      "Claude Code",
      "Claude",
      "Codex",
      "code documentation",
      "auto documentation"
    ],
    "actual_capabilities": [
      "Generate JSDoc comments for JavaScript and TypeScript",
      "Create Python docstrings in Google, NumPy, or Sphinx style",
      "Produce Rustdoc for Rust code",
      "Write Javadoc for Java methods and classes",
      "Generate GoDoc for Go functions",
      "Create complete README files with installation and usage guides"
    ],
    "limitations": [
      "Does not execute or modify code files directly",
      "Cannot access local project files without explicit content sharing",
      "Documentation quality depends on code clarity and provided context",
      "May require manual review for complex business logic"
    ],
    "use_cases": [
      {
        "target_user": "Software developers",
        "title": "Document existing codebases",
        "description": "Add comprehensive documentation to undocumented functions and methods in legacy projects"
      },
      {
        "target_user": "Open source maintainers",
        "title": "Create project documentation",
        "description": "Generate README files, API references, and contribution guides for public repositories"
      },
      {
        "target_user": "Technical writers",
        "title": "Standardize documentation format",
        "description": "Ensure consistent documentation style across multiple programming languages in a project"
      }
    ],
    "prompt_templates": [
      {
        "title": "Basic documentation",
        "scenario": "Document a single file",
        "prompt": "Use the documentation-generator skill to generate JSDoc comments for the following JavaScript file:"
      },
      {
        "title": "Document with format",
        "scenario": "Specify output format",
        "prompt": "@documentation-generator --format google-style Generate Python docstrings for this function with type hints and examples:"
      },
      {
        "title": "Generate README only",
        "scenario": "Create project documentation",
        "prompt": "@documentation-generator --readme-only Create a complete README.md for my project including features, installation, usage, and API reference:"
      },
      {
        "title": "Multi-language project",
        "scenario": "Document mixed codebase",
        "prompt": "Use documentation-generator to document all functions in the src/utils/ directory. Apply appropriate format based on file extension (JSDoc for .js/.ts, Google style for .py, Rustdoc for .rs):"
      }
    ],
    "output_examples": [
      {
        "input": "Document this function: function calculateTotal(basePrice, taxRate, discount = 0)",
        "output": [
          "Generated JSDoc comment with @param, @returns, and @throws tags",
          "Included type information for all parameters",
          "Added example usage showing input and output",
          "Documented error conditions"
        ]
      },
      {
        "input": "Create a README for my CLI tool",
        "output": [
          "Complete project overview with features list",
          "Installation instructions for npm users",
          "Usage examples with command syntax",
          "API reference section with all commands documented"
        ]
      }
    ],
    "best_practices": [
      "Provide complete function signatures and parameter types for accurate documentation",
      "Share relevant context about edge cases and performance considerations",
      "Request documentation in your existing style for consistency across the codebase"
    ],
    "anti_patterns": [
      "Requesting documentation for code with no comments or clear structure",
      "Generating documentation without reviewing for business logic accuracy",
      "Using the skill to overwrite carefully crafted custom documentation"
    ],
    "faq": [
      {
        "question": "What programming languages are supported?",
        "answer": "JavaScript/TypeScript (JSDoc), Python (Google, NumPy, Sphinx styles), Rust (Rustdoc), Java (Javadoc), and Go (GoDoc)."
      },
      {
        "question": "Can this skill modify my source files?",
        "answer": "No. The skill generates documentation text that you can copy and paste. It does not have file system access."
      },
      {
        "question": "How does the skill know my project's documentation style?",
        "answer": "It defaults to standard conventions for each language. Specify your preferred style or share existing documentation as a reference."
      },
      {
        "question": "Is my code data safe?",
        "answer": "Yes. The skill only processes code you explicitly share in the conversation. Nothing is stored or sent to external services."
      },
      {
        "question": "Why does documentation look different from my existing code?",
        "answer": "The skill uses standard formats for each language. Provide examples of your project's style or request specific formatting."
      },
      {
        "question": "How is this different from IDE code completion?",
        "answer": "This skill generates comprehensive documentation with examples and context. IDE completions typically only add basic signatures."
      }
    ]
  },
  "file_structure": [
    {
      "name": "SKILL.md",
      "type": "file",
      "path": "SKILL.md",
      "lines": 176
    }
  ]
}