More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    code map skills

    1

    Transform codebases and Git diffs into interactive, single-file HTML maps with linked diagrams and narrative tours.

    $1.50

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    code map skills

    code map skills

    Example session with this skill installed

    Generate a code map for the current PR changes to show how the new authentication middleware impacts the request flow.

    • Read your context and instructions
    • Compiled the code map
    • Generated the UI component

    I have analyzed the Git diff for the authentication middleware update. I extracted the changed files, identified the new CheckAuth interceptor, and mapped its interaction with the UserStore and SessionManager.

    A new code map has been generated at docs/code-map/auth-middleware-update/auth-update.html.

    Code Map: Authentication Middleware Update

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Auth Middleware Review</title>
    </head>
    <body>
        <!-- Engine logic hidden -->
        <script>
        /* ════════ MAP-DATA-START ════════ */
        const META = {
            title: "Auth Middleware Update",
            sub: "PR #421 - Security Layer",
            lang: "en",
            stats: { files: 4, inserts: 124, deletes: 12 }
        };
        const OVER_SRC = `
        flowchart LR
            Client-->GW[API Gateway]
            GW-->Auth[CheckAuth Interceptor]:::newc
            Auth-->Sess[SessionManager]
            Auth-->Store[UserStore]
            classDef newc fill:#e1f5fe,stroke:#01579b
        `;
        const SEQ_SRC = `
        sequenceDiagram
            participant C as Client
            participant A as CheckAuth
            participant S as SessionManager
            C->>A: Request with JWT
            A->>S: Validate Token
            alt Valid
                S-->>A: Session Object
                A->>A: Inject Context
            else Expired
                S-->>A: 401 Unauthorized
            end
        `;
        const TREE = [
            { id: "src/auth", text: "auth", children: [
                { id: "mid", text: "middleware.go", status: "MOD", doc: "d1", kw: "CheckAuth" }
            ]}
        ];
        const DOCS = [
            { id: "d1", title: "CheckAuth Interceptor", content: "Validates incoming JWTs and populates context. Uses a new grace period for token rotation to prevent race conditions during refresh." }
        ];
        const TOUR = [
            { title: "Review Entrypoint", text: "Start here to see the new middleware registration.", tab: "over", tree: "mid" }
        ];
        /* ════════ MAP-DATA-END ════════ */
        </script>
    </body>
    </html>
    

    Next steps

    1. Open docs/code-map/auth-middleware-update/auth-update.html in your browser.
    2. Click the Start Tour button to follow the request flow through the new logic.
    3. Use the Modified filter on the right panel to focus only on the changed logic cards.

    auth-update.html

    TSX · React component

    Generated

    Example file from a real run - the skill writes it into your workspace.

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

    About this skill

    Standard READMEs and folder trees fail to explain the execution flow or mental model of complex codebases. Developers on boarding to new projects or reviewing large pull requests often struggle to visualize how components interact across different layers.

    What it does

    • Standardized Visualization creates a three-panel interactive dashboard featuring project trees, Mermaid diagrams, and deep-dive documentation cards.
    • Tri-Directional Linkage synchronizes highlighting across all panels so clicking a tree node instantly focuses its logic in the diagram and its technical details in the documentation.
    • Guided Narrative Tours builds a sequence of 6 to 10 stations that walk readers through end-to-end execution paths or implementation steps.
    • Multi-Scenario Mapping adapts output for technical teaching, git diff reviews, feature blueprints, or architectural onboarding.
    • Zero-Dependency Delivery generates a single, self-contained HTML file that works in any browser without companion folders or local assets.

    How it works

    1. Context Extraction: The agent analyzes your repository, Git diffs, or feature specs to map class hierarchies and logic flows.
    2. Data Construction: It populates a pre-defined schema with Mermaid sources, project trees, and architectural intent cards.
    3. Validation: A static analysis script runs to ensure all keywords, documentation links, and diagram syntax are valid.
    4. HTML Generation: The final map is emitted as a standalone .html file, optionally inlined with all engines for offline use.

    Frameworks & tools

    This skill supports Java, Kotlin, TypeScript, JavaScript, Go, Python, and Rust. It utilizes the Mermaid.js engine for rendering flowcharts and sequence diagrams.

    Why this beats prompting it yourself

    Generic LLMs often produce disconnected diagrams or text descriptions that go out of sync. This skill enforces a hard quality gate via validation scripts and ensures that every visual element is structurally linked to its documentation and code location.

    Use cases

    • Onboarding new hires by providing a visual walkthrough of the core request lifecycle.
    • Visualizing PR reviews to see the blast radius of changes across multiple modules.
    • Drafting feature blueprints to map out architecture before writing the first line of code.
    • Technical documentation for complex open-source libraries that require more than just Javadoc.

    Known limitations

    Flowcharts are limited to a maximum subgraph depth of one. Sequence diagrams cannot use raw semicolons in notes or labels.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.

    Flowchart subgraph depth is limited to 1. Sequence diagrams cannot contain raw semicolons in labels. Support is limited to Java, Kotlin, TS, JS, Go, Python, and Rust.

    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 buying a skill.

    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

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 7 days ago

    Accounts
    GitHubChevrotainLangiumLodashOpenjsfUnderscorejsEngelschallJqueryTldrlegal
    Software
    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access

    Allowed Hosts

    www.w3.org
    github.com
    chevrotain.io
    langium.org
    en.wikipedia.org
    lodash.com
    openjsf.org
    underscorejs.org
    engelschall.com
    opensource.org
    jquery.org
    tldrlegal.com
    Listed7 days ago

    What's inside

    Frequently Asked Questions

    This skill generates a single, self-contained HTML file containing an interactive dashboard with three synchronized panels: a project tree, a Mermaid-based diagram, and technical documentation cards. Unlike static READMEs, these maps allow you to click any component to see its corresponding logic and documentation highlighted across all views simultaneously.

    The skill is compatible with AI agents that have filesystem access or Git integration, and it supports major languages including Java, Kotlin, TypeScript, JavaScript, Go, Python, and Rust. It requires a JavaScript-enabled browser to view the final interactive output, though the HTML file itself is zero-dependency.

    The skill includes a built-in validation script that performs static analysis on the generated map to ensure all Mermaid syntax is correct and that every documentation link resolves to a valid node. This prevents the "broken link" or hallucinated diagram issues often found when using generic LLM prompts for documentation.

    You will receive the AI agent skill definition, the visualization schema, the automated validation scripts, and a set of templates for various mapping scenarios like PR reviews and architectural onboarding. All future updates to the visualization engine and language support are included with your access.

    Yes, the "Guided Narrative Tours" feature allows you to define 6 to 10 specific "stations" that walk a viewer through a specific execution path, such as a user login flow or a data processing pipeline. This makes it ideal for onboarding new developers who need to understand the "why" behind the code structure.

    New in Agents & Orchestration