Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    README From Reality

    1

    Generate a polished README from what the repository actually contains, with verified commands and marked unknowns.

    Free

    2 usesSecurity scanned
    README From Reality

    README From Reality

    Example session with this skill installed

    Generate a README from this repository evidence. Do not invent missing setup details.

    package.json

    • scripts: dev: vite, build: vite build, test: vitest
    • dependencies: React, Vite, Zod

    .env.example

    • VITE_API_URL=

    Files

    • src/main.tsx
    • src/api/client.ts
    • tests/
    • vite.config.ts

    The existing README only contains the project title.

    • Read your context and instructions
    • Compiled the readme from reality

    README DRAFT

    Project Name

    A React application built with Vite. The repository includes a typed API client and Vitest-based tests.

    Requirements

    • Node.js compatible with the repository's current toolchain
    • The repository's package manager/lockfile should be used for installation

    Configuration

    Create your local environment file from .env.example and provide:

    VITE_API_URL=
    

    Development

    Use the repository's package manager to install dependencies, then run the dev script.

    Available scripts

    • dev — starts Vite development mode
    • build — creates a production Vite build
    • test — runs Vitest

    DOCUMENTATION EVIDENCE

    Verified

    • React, Vite, Vitest, and Zod appear in package.json.
    • dev, build, and test scripts exist.
    • VITE_API_URL appears in .env.example.

    Inferred

    • src/api/client.ts suggests the application communicates with an external API.

    Missing / needs owner input

    • Exact Node.js version.
    • Product/business description.
    • Deployment method.

    Commands to verify before publishing

    • Run install using the detected lockfile's package manager.
    • Run dev, build, and test.

    Update triggers

    • Package scripts change.
    • Environment schema changes.
    • Deployment documentation is added.

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

    About this skill

    A README should describe the repository you have — not the repository an AI expects to exist.

    README From Reality generates polished developer documentation from the codebase itself: manifests, scripts, config, entry points, environment examples, tests, docs, CI, and deployment clues.

    The result is useful without pretending unknown things are known.

    What it does

    • Builds a fact map from the actual repository before writing.

    • Detects the real package manager, scripts, configuration, entry points, test setup, and environment requirements.

    • Separates verified repository facts from reasonable inference and missing owner knowledge.

    • Refuses to invent installation commands, environment variables, features, APIs, integrations, or deployment methods just to make the README look complete.

    • Uses the repository’s existing terminology instead of replacing it with generic AI marketing copy.

    • Produces a complete, copy-ready README with only the sections the project actually supports.

    • Adds an evidence appendix showing what was verified, inferred, or still missing.

    • Lists commands that should be run before publication when execution evidence is not available.

    • Defines the repository changes that should trigger a future documentation update.

    Use it when

    • a repository has no README
    • the README is stale or incomplete
    • AI-generated documentation contains suspicious commands or claims
    • onboarding instructions need to match the actual codebase
    • setup steps, environment variables, or scripts need verification
    • you want a professional README without hallucinated features

    What you get

    1. Complete README draft
    2. Verified repository facts
    3. Clearly marked inferences
    4. Missing information that needs owner input
    5. Commands to verify before publishing
    6. Documentation update triggers

    Why it is different

    Most README generators optimize for completeness and polish. This one optimizes for usefulness without losing contact with the repository.

    If the codebase does not support a claim, the skill does not quietly fill the gap.

    Known limitations

    A repository cannot reveal business positioning, private deployment procedures, undocumented external dependencies, or decisions that live only in team knowledge. Those gaps are surfaced explicitly instead of guessed.

    Designed as a focused developer utility, not a general-purpose consultant. It produces a concrete artifact and explicitly separates verified evidence from assumptions when the available context is incomplete.

    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

    2 uses

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 2 months ago

    • Free with an Agensi account

    Requires

    Node.js

    Permissions

    No special permissions declared or detected

    Listed2 months ago

    What's inside

    Frequently Asked Questions

    Unlike generic generators that hallucinate features to fill space, this skill builds a 'fact map' of your repository. It only documents what actually exists in your code, manifests, and configs, ensuring your README never promises a feature or command that isn't there.

    The skill is designed to work with any repository that has a clear structure, including TypeScript, JavaScript, Python, and Go projects. It scans manifests (like package.json), CI/CD configs, and entry points to understand your specific tech stack.

    When the skill encounters a gap—like a missing environment variable description or an unknown deployment target—it explicitly marks it as 'Missing Information' instead of guessing. You get a list of specific questions to answer to complete the documentation.

    You receive a copy-ready README draft, a verification appendix of repository facts, a list of commands to run for final validation, and a set of 'trigger events' that signal when your documentation needs a future update.

    This skill functions as a standalone analysis tool that can be integrated into your existing CI/CD pipeline or run manually via your preferred AI agent interface. It requires read access to your repository to generate the initial fact map.

    It is highly effective for refreshing stale documentation. The skill compares your current codebase against the existing README, identifying outdated commands and surfacing new features that have been added since the last manual update.

    New in Technical Documentation