More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    research report

    1

    Turn code analysis and session research into professionally typeset PDF reports and technical design documents.

    $35

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    research report

    research report

    Example session with this skill installed

    Document this repository for my manager. Focus on the high-level design and dependencies. Make it a standard 3 to 5 page report.

    • Read your context and instructions
    • Compiled the research report
    • Generated the document

    I have completed the repository scan and drafted the High-Level Design report. I analyzed the core service architecture, dependency tree, and entry points. The report includes a KPI section for code coverage and a visual representation of the module hierarchy.

    Technical Report: Architecture Overview

    File Path: report/architecture-overview.pdf

    ComponentResponsibilityPrimary Dependencies
    API GatewayRequest routing and authFastAPI, JWT
    Order ServiceTransaction logicSQLAlchemy, PostgreSQL
    Worker NodeAsync task processingCelery, Redis
    Fact SheetRaw data extractionrepo_scan.py

    Executive Summary preview:
    The system is built on a microservices architecture using Python 3.10. The core logic is decoupled from the transport layer, allowing for independent scaling of the Order Service. Current test coverage stands at 84%, with identified gaps in the asynchronous worker error handling.

    Next steps

    1. Review the generated PDF at report/architecture-overview.pdf to verify the module diagram layout.
    2. If you need to adjust the text, edit report/architecture-overview.md and I can rebuild the PDF.
    3. I can now proceed to generate the Low-Level Design for the Order Service module if required.

    architecture-overview.pdf

    PDF · document

    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

    When technical investigations or repository audits stay trapped in a chat history, knowledge is lost and stakeholders stay out of the loop. This skill converts session research and codebase analysis into professional, typeset PDF reports. It eliminates the friction of manual documentation by scanning repositories, organizing research flows, and rendering structured documents with cover pages, tables of contents, and data visualizations.

    What it does

    • Repository Scanning scans codebases to extract facts on languages, dependencies, and architecture.
    • Research Reconstruction tracks questions, sources, and dead ends from the current session.
    • PDF Rendering builds styled documents with cover pages, numbered sections, and KPI callouts.
    • Visual Data Integration generates charts and Markdown tables to illustrate technical findings.
    • Reference Management automatically logs and cites external sources and documentation.

    How it works

    1. Settle the Brief by defining report length, target audience, and subject scope.
    2. Gather Evidence using the repository scanner and logging session research steps.
    3. Plan the Storyline to draft a sequence of headings and visual assets based on the evidence.
    4. Build and Preview the PDF using the ReportLab renderer and page preview tools to ensure layout quality.

    Frameworks & tools

    The skill requires Python 3.9+ and uses reportlab for PDF generation, matplotlib for charts, pygments for code highlighting, and pymupdf for page previews.

    Why this beats prompting it yourself

    Generic prompts often produce unstructured, conversational text that fails as a formal document. This skill uses dedicated scripts for repo scanning and professional typesetting, ensuring reports follow strict structural templates for HLDs, LLDs, and audits.

    Use cases

    • Codebase Handover documenting architecture and dependencies for new developers.
    • Research Summary compiling session investigations into a shareable stakeholder report.
    • Technical Audits identifying performance bottlenecks or security gaps with supporting data.
    • Design Documentation creating high-level or low-level design PDFs directly from the source.

    Known limitations

    The PDF renderer does not support SVG images. Users must have Python and required libraries installed in the environment to build the final document.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Technical Documentation.

    Requires Python 3.9+ and reportlab. SVG images not supported; use PNG. Reports are strictly one-pagers or 3 to 5 page documents.

    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 today

    Software
    Node.jsPython

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Environment Variables
    Listedtoday

    What's inside

    Frequently Asked Questions

    This skill eliminates the manual labor of copy-pasting chat history into a document. It captures code audits and session insights, automatically structuring them into a professionally typeset PDF with tables of contents, syntax-highlighted code blocks, and data visualizations.

    The skill is designed for AI agents operating in Python 3.9+ environments. It utilizes specific libraries like ReportLab and Matplotlib to handle the rendering, making it compatible with any agent capable of executing local Python scripts.

    The repository scanner is built to analyze code structure, dependency trees, and architectural patterns. It can extract data on language composition and file hierarchies to provide a factual foundation for your technical audits and design documents.

    Yes, you can define the report's brief to target different audiences. Whether you need a high-level overview for stakeholders or a deep-dive Low-Level Design (LLD) document for engineers, the skill adjusts the depth and technicality of the output accordingly.

    The skill requires a Python 3.9+ environment with `reportlab`, `matplotlib`, `pygments`, and `pymupdf` installed. Once these dependencies are met, the agent can immediately begin scanning your codebase and generating professional reports.

    You receive the full skill package, including the repository scanning logic, the research reconstruction engine, and the professional PDF rendering templates. Updates and documentation for the included Python-based tools are also provided.

    New in Technical Documentation