More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Plaindoc: docs in plain words, with examples that run

    1

    Reads your code and writes READMEs, function docs and architecture notes in plain words, with copy-paste examples that run and nothing padded.

    Free

    1 useSecurity scanned
    Plaindoc: docs in plain words, with examples that run

    Plaindoc: docs in plain words, with examples that run

    Example session with this skill installed

    Plaindoc src/utils/storage.ts:setWithExpiry

    • Read your context and instructions
    • Compiled the plaindoc

    I have generated the documentation for the setWithExpiry function in src/utils/storage.ts.

    Function Documentation

    setWithExpiry(key, value, ttl): persists a value in localStorage with a timestamp for automatic expiration.

    Args

    • key (string): the lookup key for the storage item
    • value (any): data to be serialized and stored
    • ttl (number): time-to-live in milliseconds from the current moment

    Returns: (void): nothing is returned

    Example

    import { setWithExpiry } from './storage';
    
    // Store user session for 1 hour
    setWithExpiry('session_token', 'abc-123', 3600000);
    

    Notes

    • Uses JSON.stringify internally; ensure values are serializable.
    • Does not automatically prune: the expiry check happens during the next get operation.
    • Fails silently if localStorage is full or unavailable in the environment.

    Next steps

    1. Add this to your STORAGE.md reference file.
    2. Verify the TTL calculation matches your backend's expiry logic.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Stop wasting time on bloated documentation that nobody reads. Most auto-generated docs just restate the obvious, explaining that a getUser function gets a user. This skill skips the fluff and focuses on what matters: how to use the code, why certain decisions were made, and how to avoid breaking things. It delivers concise, technical documentation including READMEs, API references, and architecture notes that prioritize working examples over marketing descriptions.

    What it does

    • README generation creates project-level overviews with quick starts and functional feature lists.
    • Function and class documentation extracts signatures, argument types, and return values with working code snippets.
    • Architecture mapping identifies components, data flow, dependencies, and known failure modes.
    • Example synthesis writes copy-pasteable code examples that run without modification.
    • Public surface scoping filters out private internals to keep API references clean and focused.

    How it works

    1. Context gathering analyzes your stack, folder structure, and existing manifests to understand the project environment.
    2. Targeting accepts a specific file, folder, function, or the entire root directory as a scope.
    3. Drafting applies a strict "no-padding" rule, stripping away preambles like "this function is responsible for."
    4. Validation checks that non-obvious logic choices are explained while obvious code is left to speak for itself.

    Frameworks & tools

    Works with any language or framework including TypeScript, JavaScript, Python, Go, and Rust. It formats output in standard GitHub-flavored Markdown.

    Why this beats prompting it yourself

    Standard prompts often produce verbose, repetitive text that mirrors the code structure without adding value. This skill is hard-coded to avoid documentation anti-patterns, ensuring you get technical "whys" and functional examples instead of generic "whats."

    Use cases

    • Onboarding new developers to a complex codebase with clear architecture notes.
    • Shipping libraries that require accurate, copy-pasteable API references for the public surface.
    • Standardizing project READMEs across a monorepo or organization.

    Known limitations

    Does not document private internals in API docs. Reads the project manifest and config files when present for project-level context.

    Focuses only on public surface area. Requires access to project configuration files for full context. Examples are restricted to 3-5 lines.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 27 days ago

    • Free with an Agensi account

    Permissions

    Read Files
    Write Files
    Listed29 days ago
    Updated27 days ago

    What's inside

    Frequently Asked Questions

    Unlike standard AI prompts that often restate what the code already says, this skill uses a strict 'no-padding' rule to strip out verbal filler and focus on technical 'whys,' architecture logic, and functional code examples.

    The skill is language-agnostic and works with any codebase including TypeScript, Python, Go, and Rust. When a project manifest (like package.json or requirements.txt) is present, it reads it for context.

    Yes, you can target specific files, folders, or even individual functions to generate focused updates without re-processing your entire directory.

    This skill generates clean, GitHub-flavored Markdown that includes project overviews, API references with copy-pasteable snippets, and architecture maps identifying data flow and dependencies.

    By default, the skill identifies and filters out private internal functions to ensure your public API documentation remains clean, concise, and focused on the end-user experience.

    New in Technical Documentation