Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
athola avatar

Architecture Diagram

  • 84 installs
  • 325 repo stars
  • Updated August 2, 2026
  • athola/claude-night-market

architecture-diagram is an agent skill that generates Mermaid flowcharts of high-level module and plugin relationships from codebase exploration.

About

architecture-diagram is an agent skill for solo builders who need a fast, accurate system map without hand-drawing every package edge in a growing repo. It pairs a structured codebase exploration step with Mermaid generation rules—top-down for hierarchies, left-right for pipelines, subgraphs by package, and a hard cap near 15–20 nodes so diagrams stay readable in READMEs and PRs. Use it during Build when documenting new plugins or services, during Ship review when reviewers need context, or during Idea/Validate when you are still mapping an unfamiliar fork. It does not replace deep security or performance analysis; it makes relationships legible so the next implementation or refactor conversation starts aligned.

  • Two-step workflow: dispatch codebase-explorer agent, then emit Mermaid flowchart TD or LR
  • 15–20 node cap with subgraph grouping and shape conventions for modules, entry points, and data stores
  • Designed for plugin/module relationship questions and "how does this fit together" onboarding
  • Explicit rules for labeled edges, aggregation of small modules, and PR-ready architecture snippets

Architecture Diagram by the numbers

  • 84 all-time installs (skills.sh)
  • Ranked #677 of 1,879 Documentation skills by installs in the Skillselion catalog
  • Security screen: LOW risk (skills.sh audit)
  • Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/athola/claude-night-market --skill architecture-diagram

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs84
repo stars325
Security audit3 / 3 scanners passed
Last updatedAugust 2, 2026
Repositoryathola/claude-night-market

What it does

Produce a capped Mermaid architecture flowchart from a codebase exploration so you can onboard, document modules, or explain structure in PRs.

Who is it for?

Best when you're documenting plugin architectures, monorepos, or agent toolchains and want Mermaid without manual graph editing.

Skip if: Deep sequence diagrams of every RPC, or production infra monitoring views that need live metrics rather than structural maps.

When should I use this skill?

Visualizing how plugins or modules relate, onboarding to system structure, or documenting architecture for PR reviews.

What you get

You get a PR- or README-ready Mermaid architecture diagram that summarizes component relationships within the skill’s node limits.

  • Mermaid flowchart snippet (TD or LR)
  • Grouped subgraphs with labeled relationships

By the numbers

  • 15–20 nodes maximum in generated diagrams

Files

SKILL.mdMarkdownGitHub ↗

Architecture Diagram

Generate a Mermaid flowchart showing high-level component relationships in a codebase.

When To Use

  • Visualizing how plugins/modules relate to each other
  • Onboarding to understand system structure
  • Documenting architecture for PR reviews
  • Answering "how does this system fit together?"

Workflow

Step 1: Explore the Codebase

Dispatch the codebase explorer agent to analyze the scope:

Agent(cartograph:codebase-explorer)
Prompt: Explore [scope] and return a structural model.
Focus on packages, modules, and their relationships
for an architecture diagram.

If no scope is provided, use the project root.

Step 2: Generate Mermaid Syntax

Transform the structural model into a Mermaid flowchart.

Rules for architecture diagrams:

  • Use flowchart TD (top-down) for hierarchical systems
  • Use flowchart LR (left-right) for pipeline/flow systems
  • Group related modules into subgraphs by package
  • Use descriptive edge labels for relationships
  • Limit to 15-20 nodes maximum (aggregate small modules)
  • Use shapes to distinguish component types:
  • [Rectangle] for modules/packages
  • ([Stadium]) for entry points/commands
  • [(Database)] for data stores
  • {Diamond} for decision points

Example output:

flowchart TD
    subgraph sanctum[Sanctum Plugin]
        commit[Commit Messages]
        pr[PR Preparation]
        workspace[Workspace Review]
    end

    subgraph leyline[Leyline Plugin]
        git[Git Platform]
        patterns[Error Patterns]
    end

    commit --> git
    pr --> workspace
    pr --> git
    workspace --> patterns

Step 3: Render via MCP

Call the Mermaid Chart MCP to render:

mcp__claude_ai_Mermaid_Chart__validate_and_render_mermaid_diagram
  prompt: "Architecture diagram of [scope]"
  mermaidCode: [generated syntax]
  diagramType: "flowchart"
  clientName: "claude-code"

If rendering fails, fix the Mermaid syntax based on the error message and retry (max 2 retries).

Step 4: Present Results

Show the rendered diagram to the user with a brief summary of what it depicts (2-3 sentences).

Exit Criteria

  • [ ] Mermaid flowchart syntax generated containing at least

one subgraph block grouping related modules

  • [ ] mcp__claude_ai_Mermaid_Chart__validate_and_render_mermaid_diagram

called and returns without error (or retry attempted on first failure and result reported)

  • [ ] Diagram node count is between 3 and 20 (per skill rules)
  • [ ] A 2-3 sentence description of what the diagram depicts is shown

alongside the rendered output

  • [ ] If the MCP render fails after 2 retries, the Mermaid syntax is

still presented as a code block with the error surfaced

Related skills

How it compares

Lightweight structural diagram generator—not a full C4 modeling suite or automatic dependency license audit.

FAQ

Who is architecture-diagram for?

Developers and small teams using Claude Code or similar agents who need onboarding diagrams and PR context for how modules relate.

When should I use architecture-diagram?

In Build docs when adding plugins, during Ship review before merge, or in Idea research when mapping an unfamiliar repo’s layout.

Is architecture-diagram safe to install?

It instructs codebase exploration and diagram output—review the Security Audits panel on this page and scope exploration to repos you trust.

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.