More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Architecture Map with Real Progress (C4)

    2

    Static architecture diagrams go stale the week they are drawn, and progress reports are usually someone's guess.

    $9.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Architecture Map with Real Progress (C4)

    Architecture Map with Real Progress (C4)

    Example session with this skill installed

    Map the architecture of this repository and show me where each part stands. I want one page I can open on my phone and share with the team.

    • Read your context and instructions
    • Compiled the architecture map

    Summary

    Quick mode on the public

    Full Stack FastAPI Template repository, then full mode on the bundled example project to show progress and scope. Both outputs below are real script output.

    1. Quick mode: Full Stack FastAPI Template

    Command: python3 scripts/build_map.py quick . --name "Full Stack FastAPI Template"

    page: docs/architecture-map.html
    parts: 10 · arrows: 2 · code files: 159 · computed: f4bcfab, 2026-11-01
    
    PartLevelTechLinesTests
    backendcontainerPython, Shell1,23758
    backend / appcomponentPython1,2090
    backend / scriptscomponentShell280
    frontendcontainerTypeScript8,73961
    packagescontainerTypeScript3490
    packages / emailscomponentTypeScript1630
    packages / uicomponentTypeScript1860
    scriptscontainerPython, Shell2060
    hookscontainerPython60
    Total10,537119

    Arrows "uses" found from imports: backend tests → backend/app, emails → ui.

    What quick mode cannot show: progress, status, people and external systems. For those, run full mode: --write-spec docs/ARCHITECTURE-MAP.md writes a spec draft with the 10 parts and the module map it found, ready for review.

    2. Full mode: bundled example (Online bookshop, fake data)

    Command: python3 scripts/build_map.py example --out example-map.html

    PartStatusProgressNote
    Websitedone100%
    Servicein progress35%critical area
    Service / Catalogin progress60%
    Service / Ordersin progress40%1 task with PR open, 1 defect reproduced
    Service / Usersblocked22%waits for decision D-1 (two-factor login)
    Service / Paymentsto do0%
    Mobile appout of scopedimmed, still listed

    Total for the site: 12 done · 12 designed · 10 to design, out of 34 work items. Unassigned: OP-9 Electronic invoices (no part named).

    Simulate exclusion on Payments: 1 part excluded · 2 parts break (Orders and Mobile app depend on it) · 7 work items leave scope. Nothing is saved; "Copy decision" gives you the text to approve.

    Next steps

    1. Open docs/architecture-map.html in any browser, phone included.
    2. Review the spec draft and approve the parts, statuses and scope the agent proposes.
    3. Rebuild with build_map.py full . --spec docs/ARCHITECTURE-MAP.md; use --check to know when the page is out of date.

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

    About this skill

    Static architecture diagrams go stale the week they are drawn, and progress reports are usually someone's guess. Architecture Map turns a code repository into one self-contained HTML page that shows what the project is made of, how the parts depend on each other and how far each part really is. Every number on the page is computed by a bundled Python script from the repository and a written spec, with the commit and date it was computed from. Nothing is estimated by the model.

    What you get

    • Architecture view: a zoomable C4-style map (context, containers, components). Zoom, pan and pinch on phones, a lens to go one level down, a breadcrumb to go back up, arrows that stay attached at every zoom level.
    • Progress view: nested tiles colored by share done. Containers sum their parts, never average them.
    • Scope view with Simulate exclusion: tick the parts you want to postpone and see which other parts break along the written dependencies and how many work items leave scope. It copies a decision text for you to approve; nothing is saved.
    • Roadmap view: steps ready to start and steps waiting, each open step with a "Copy prompt" button.
    • Attention view: tasks in progress, tests exposing a defect, open decisions, stalled parts, unassigned items.
    • Details panel: status, progress, links and every work item of a part and of the parts inside it.
    • Download image: SVG of the current view, ready for a deck or a ticket.

    Light and dark follow the system. Status is always shown as color, icon and word, never color alone. The page works on desktop and phone and needs no server.

    Two modes

    QuickFull
    Needsthe repositorythe repository and a spec file
    Partscode foldersthe spec's Parts table
    Arrowsimports (Python, JS/TS)imports plus written links
    Numberslines, tests, TODO/FIXMEplus progress bar, status, decisions, open points, defect tests
    Timeone commanda short guided setup, one approval per phase

    Start with quick mode to see the map in one command. Move to full mode when you want progress, scope and roadmap: the script writes a spec draft from what it found, and the agent proposes each choice for your approval before writing it.

    What is inside

    • SKILL.md: the rules the agent follows (principles, both modes, calculation rules, update flow, limits).
    • scripts/build_map.py: the generator. Python 3.8+, standard library only. Reads the repository and the spec, counts lines and tests, applies the calculation rules and writes the page. --check tells you whether the page is up to date.
    • assets/map.html: the page. It is the same for every project and is never edited per project.
    • references/format.md and references/example.json: the data format and a fake project to try the page.

    Why it is different

    • Written rules, generated data. The map is a spec plus data computed from it. Lose the page and you lose nothing: rebuild it.
    • No invented parts or arrows. A part with no known work says "not broken down yet", never 0%. Gaps are shown to you, never filled in.
    • Same result for every buyer, fewer tokens. The script does the counting, so the agent does not rewrite a generator for each project.

    Limits

    • Import arrows are detected for Python and JS/TS; other languages get arrows from the spec's Links table.
    • Test counts use common test patterns per language; unusual frameworks may count zero.
    • Level 4 (operations) is supported by the page and the format but not generated by the script.

    Icons: Lucide (ISC). Colors: GitHub Primer (MIT).

    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.

    Auto-imports support Python/JS/TS only. Other languages need manual Links table entries. Level 4 generation is not automated. Python 3.8+ required for the build script.

    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 16 days ago

    Software
    Python 3.8+

    Permissions

    Terminal / Shell
    Browser
    Read Files
    Write Files

    File Scopes

    **/*
    (read
    only)
    docs/architecture-map.html
    docs/ARCHITECTURE-MAP.md

    Reads the repository to count lines, tests and imports. Writes only the map page and the spec file (by default docs/architecture-map.html and docs/ARCHITECTURE-MAP.md). Runs the bundled Python script from the shell. No network access.

    Listed16 days ago

    What's inside

    Frequently Asked Questions

    A bundled Python script reads the repository and a written spec and computes every part, arrow and number, with the commit and date it was computed from. The agent proposes, you approve, the script counts. Nothing is estimated.

    Parts, lines and tests work for any repository. Arrows from imports are detected for Python and JS/TS; for other languages you add arrows in the spec's Links table.

    SKILL.md with the rules, the build script (Python 3.8+, standard library only), the HTML page, the data format reference and an example project to try the page.

    Ask your agent to map the repository. Quick mode runs one command and writes docs/architecture-map.html. When you want progress and scope, the script writes a spec draft and the agent walks you through full mode.

    No. Progress comes from the work items in your spec, read through the status rules you approve. You rebuild on request, and --check tells you when the page is out of date. There are no scheduled or automatic updates.

    New in Technical Documentation